Bump to 4.6.3

Fix for issue #351

CHANGELOG.md

@@ -4,14 +4,39 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.6.0] - 2022-09-17
+### Added
+ - CTkProgressBar indeterminate mode, automatic progress loop with .start() and .stop()
+
+## [4.5.0] - 2022-06-23
+### Added
+ - CTkScrollbar (vertical, horizontal)
+
+## [4.4.0] - 2022-06-14
+### Changed
+ - Changed custom dropdown menu to normal tkinter.Menu because of multiple platform specific bugs
+
+## [4.3.0] - 2022-06-1
+### Added
+ - Added CTkComboBox
+ - Small fixes for new dropdown menu
+
+## [4.2.0] - 2022-05-30
+### Added
+ - CTkOptionMenu with custom dropdown menu
+ - Support for clicking on labels of CTkCheckBox, CTkRadioButton, CTkSwitch
+
+## [4.1.0] - 2022-05-24
+### Added
+ - Configure width and height for frame, button, label, progressbar, slider, entry
+
 ## [4.0.0] - 2022-05-22
 ### Added
  - This changelog file
  - Adopted semantic versioning
  - Added HighDPI scaling to all widgets and geometry managers (place, pack, grid)
  - Restructured CTkSettings and renamed a few manager classes
-
-### Changed
+ - Orientation attribute for slider and progressbar
 
 ### Removed
  - A few unnecessary tests

Readme.md

@@ -16,7 +16,8 @@ CustomTkinter is a python UI-library based on Tkinter, which provides new, moder
 fully customizable widgets. They are created and used like normal Tkinter widgets and
 can also be used in combination with normal Tkinter elements. The widgets
 and the window colors either adapt to the system appearance or the manually set mode
-('light', 'dark'). With CustomTkinter you'll get a consistent and modern look across all
+('light', 'dark'), and all CustomTkinter widgets and windows support HighDPI scaling
+(Windows, macOS). With CustomTkinter you'll get a consistent and modern look across all
 desktop platforms (Windows, macOS, Linux).
 
 
@@ -30,7 +31,9 @@ pip3 install customtkinter
 
 ## Documentation
 
-A detailed documentation can be found in the Wiki Tab here: **[Documentation](https://github.com/TomSchimansky/CustomTkinter/wiki)**.
+The **official** documentation can be found in the Wiki Tab here:
+
+**--> [Documentation](https://github.com/TomSchimansky/CustomTkinter/wiki)**.
 
 ## Example Program
 To test customtkinter you can try this simple example with only a single button:

customtkinter/__init__.py

@@ -1,8 +1,9 @@
-__version__ = "4.1.0"
+__version__ = "4.6.3"
 
 import os
 import sys
 from tkinter.constants import *
+from tkinter import StringVar, IntVar, DoubleVar, BooleanVar
 
 # import manager classes
 from .settings import Settings
@@ -13,7 +14,15 @@ from .font_manager import FontManager
 from .draw_engine import DrawEngine
 
 AppearanceModeTracker.init_appearance_mode()
-ThemeManager.load_theme("blue")  # load default theme
+
+# load default blue theme
+try:
+    ThemeManager.load_theme("blue")
+except FileNotFoundError as err:
+    raise FileNotFoundError(f"{err}\n\nThe .json theme file for CustomTkinter could not be found.\n" +
+                            f"If packaging with pyinstaller was used, have a look at the wiki:\n" +
+                            f"https://github.com/TomSchimansky/CustomTkinter/wiki/Packaging#windows-pyinstaller-auto-py-to-exe")
+
 FontManager.init_font_manager()
 
 # determine draw method based on current platform
@@ -22,13 +31,16 @@ if sys.platform == "darwin":
 else:
     DrawEngine.preferred_drawing_method = "font_shapes"
 
+if sys.platform.startswith("win") and sys.getwindowsversion().build < 9000:  # No automatic scaling on Windows < 8.1
+    ScalingTracker.deactivate_automatic_dpi_awareness = True
+
 # load Roboto fonts (used on Windows/Linux)
 script_directory = os.path.dirname(os.path.abspath(__file__))
 FontManager.load_font(os.path.join(script_directory, "assets", "fonts", "Roboto", "Roboto-Regular.ttf"))
 FontManager.load_font(os.path.join(script_directory, "assets", "fonts", "Roboto", "Roboto-Medium.ttf"))
 
 # load font necessary for rendering the widgets (used on Windows/Linux)
-if FontManager.load_font(os.path.join(script_directory, "assets", "fonts", "CustomTkinter_shapes_font-fine.otf")) is False:
+if FontManager.load_font(os.path.join(script_directory, "assets", "fonts", "CustomTkinter_shapes_font.otf")) is False:
     # change draw method if font loading failed
     if DrawEngine.preferred_drawing_method == "font_shapes":
         sys.stderr.write("customtkinter.__init__ warning: " +
@@ -37,6 +49,7 @@ if FontManager.load_font(os.path.join(script_directory, "assets", "fonts", "Cust
         DrawEngine.preferred_drawing_method = "circle_shapes"
 
 # import widgets
+from .widgets.widget_base_class import CTkBaseClass
 from .widgets.ctk_button import CTkButton
 from .widgets.ctk_checkbox import CTkCheckBox
 from .widgets.ctk_entry import CTkEntry
@@ -47,6 +60,10 @@ from .widgets.ctk_label import CTkLabel
 from .widgets.ctk_radiobutton import CTkRadioButton
 from .widgets.ctk_canvas import CTkCanvas
 from .widgets.ctk_switch import CTkSwitch
+from .widgets.ctk_optionmenu import CTkOptionMenu
+from .widgets.ctk_combobox import CTkComboBox
+from .widgets.ctk_scrollbar import CTkScrollbar
+from .widgets.ctk_textbox import CTkTextbox
 
 # import windows
 from .windows.ctk_tk import CTk

customtkinter/appearance_mode_tracker.py

@@ -45,12 +45,15 @@ class AppearanceModeTracker:
                 cls.app_list.append(app)
 
                 if not cls.update_loop_running:
-                    app.after(500, cls.update)
+                    app.after(cls.update_loop_interval, cls.update)
                     cls.update_loop_running = True
 
     @classmethod
     def remove(cls, callback: Callable):
-        cls.callback_list.remove(callback)
+        try:
+            cls.callback_list.remove(callback)
+        except ValueError:
+            return
 
     @staticmethod
     def detect_appearance_mode() -> int:

customtkinter/assets/themes/blue.json

@@ -1,32 +1,41 @@
 {
   "color": {
-    "window_bg_color": ["gray95", "gray12"],
-    "button":["#5B97D3", "#3373B8"],
-    "button_hover": ["#4A7BAD", "#1D538D"],
-    "button_border": ["gray40", "#D5D9DE"],
-    "checkbox_border": ["gray40", "#D5D9DE"],
+    "window_bg_color": ["#EBEBEC", "#212325"],
+    "button": ["#3B8ED0", "#1F6AA5"],
+    "button_hover": ["#36719F", "#144870"],
+    "button_border": ["#3E454A", "#949A9F"],
+    "checkbox_border": ["#3E454A", "#949A9F"],
     "checkmark": ["white", "gray90"],
-    "entry": ["white", "gray24"],
-    "entry_border": ["gray70", "gray32"],
+    "entry": ["#F9F9FA", "#343638"],
+    "entry_border": ["#979DA2", "#565B5E"],
     "entry_placeholder_text": ["gray52", "gray62"],
-    "frame_border": ["#A7C2E0", "#5FB4DD"],
-    "frame_low": ["#E3E4E5", "gray16"],
-    "frame_high": ["#D7D8D9", "gray22"],
+    "frame_border": ["#979DA2", "#1F2122"],
+    "frame_low": ["#D1D5D8", "#2A2D2E"],
+    "frame_high": ["#C0C2C5", "#343638"],
     "label": [null, null],
-    "text": ["gray20", "#D5D9DE"],
+    "text": ["gray10", "#DCE4EE"],
     "text_disabled": ["gray60", "#777B80"],
     "text_button_disabled": ["gray40", "gray74"],
-    "progressbar": ["#6B6B6B", "gray0"],
-    "progressbar_progress": ["#5B97D3", "#3373B8"],
+    "progressbar": ["#939BA2", "#4A4D50"],
+    "progressbar_progress": ["#3B8ED0", "#1F6AA5"],
     "progressbar_border": ["gray", "gray"],
-    "slider": ["#6B6B6B", "gray0"],
-    "slider_progress": ["white", "gray40"],
-    "slider_button": ["#5B97D3", "#3373B8"],
-    "slider_button_hover": ["#4A7BAD", "#1D538D"],
-    "switch": ["gray70", "gray35"],
-    "switch_progress": ["#5B97D3", "#3373B8"],
+    "slider": ["#939BA2", "#4A4D50"],
+    "slider_progress": ["gray40", "#AAB0B5"],
+    "slider_button": ["#3B8ED0", "#1F6AA5"],
+    "slider_button_hover": ["#36719F", "#144870"],
+    "switch": ["#939BA2", "#4A4D50"],
+    "switch_progress": ["#3B8ED0", "#1F6AA5"],
     "switch_button": ["gray36", "#D5D9DE"],
-    "switch_button_hover": ["gray20", "gray100"]
+    "switch_button_hover": ["gray20", "gray100"],
+    "optionmenu_button": ["#36719F", "#144870"],
+    "optionmenu_button_hover": ["#27577D", "#203A4F"],
+    "combobox_border": ["#979DA2", "#565B5E"],
+    "combobox_button_hover": ["#6E7174", "#7A848D"],
+    "dropdown_color": ["gray90", "gray20"],
+    "dropdown_hover": ["gray75", "gray28"],
+    "dropdown_text": ["gray10", "#DCE4EE"],
+    "scrollbar_button": ["gray55", "gray41"],
+    "scrollbar_button_hover": ["gray40", "gray53"]
   },
   "text": {
     "macOS": {
@@ -43,26 +52,28 @@
     }
   },
   "shape": {
-    "button_corner_radius": 8,
+    "button_corner_radius": 6,
     "button_border_width": 0,
-    "checkbox_corner_radius": 7,
+    "checkbox_corner_radius": 6,
     "checkbox_border_width": 3,
     "radiobutton_corner_radius": 1000,
     "radiobutton_border_width_unchecked": 3,
     "radiobutton_border_width_checked": 6,
     "entry_border_width": 2,
-    "frame_corner_radius": 8,
+    "frame_corner_radius": 6,
     "frame_border_width": 0,
-    "label_corner_radius": 8,
+    "label_corner_radius": 0,
     "progressbar_border_width": 0,
     "progressbar_corner_radius": 1000,
     "slider_border_width": 6,
-    "slider_corner_radius": 8,
+    "slider_corner_radius": 1000,
     "slider_button_length": 0,
     "slider_button_corner_radius": 1000,
     "switch_border_width": 3,
     "switch_corner_radius": 1000,
     "switch_button_corner_radius": 1000,
-    "switch_button_length": 0
+    "switch_button_length": 0,
+    "scrollbar_corner_radius": 1000,
+    "scrollbar_border_spacing": 4
   }
 }

customtkinter/assets/themes/dark-blue.json

@@ -27,7 +27,15 @@
     "switch_progress": ["#608BD5", "#395E9C"],
     "switch_button": ["gray38", "gray70"],
     "switch_button_hover": ["gray30", "gray90"],
-    "darken_factor": 0.8
+    "optionmenu_button": ["#36719F", "#144870"],
+    "optionmenu_button_hover": ["#27577D", "#203A4F"],
+    "combobox_border": ["gray70", "gray32"],
+    "combobox_button_hover": ["#6E7174", "#7A848D"],
+    "dropdown_color": ["gray90", "gray20"],
+    "dropdown_hover": ["gray75", "gray28"],
+    "dropdown_text": ["gray10", "#DCE4EE"],
+    "scrollbar_button": ["gray55", "gray41"],
+    "scrollbar_button_hover": ["gray40", "gray53"]
   },
   "text": {
     "macOS": {
@@ -54,7 +62,7 @@
     "entry_border_width": 2,
     "frame_corner_radius": 10,
     "frame_border_width": 0,
-    "label_corner_radius": 8,
+    "label_corner_radius": 0,
     "progressbar_border_width": 0,
     "progressbar_corner_radius": 1000,
     "slider_border_width": 6,
@@ -64,6 +72,8 @@
     "switch_border_width": 3,
     "switch_corner_radius": 1000,
     "switch_button_corner_radius": 1000,
-    "switch_button_length": 0
+    "switch_button_length": 0,
+    "scrollbar_corner_radius": 1000,
+    "scrollbar_border_spacing": 4
   }
 }

customtkinter/assets/themes/green.json

@@ -27,7 +27,15 @@
     "switch_progress": ["#72CF9F", "#11B384"],
     "switch_button": ["gray38", "gray70"],
     "switch_button_hover": ["gray30", "gray90"],
-    "darken_factor": 0.8
+    "optionmenu_button": ["#0E9670", "#0D8A66"],
+    "optionmenu_button_hover":["gray40", "gray70"],
+    "combobox_border": ["gray70", "gray32"],
+    "combobox_button_hover": ["#6E7174", "#7A848D"],
+    "dropdown_color": ["gray90", "gray20"],
+    "dropdown_hover": ["gray75", "gray28"],
+    "dropdown_text": ["gray10", "#DCE4EE"],
+    "scrollbar_button": ["gray55", "gray41"],
+    "scrollbar_button_hover": ["gray40", "gray53"]
   },
   "text": {
     "macOS": {
@@ -54,7 +62,7 @@
     "entry_border_width": 2,
     "frame_corner_radius": 10,
     "frame_border_width": 0,
-    "label_corner_radius": 8,
+    "label_corner_radius": 0,
     "progressbar_border_width": 0,
     "progressbar_corner_radius": 1000,
     "slider_border_width": 6,
@@ -64,6 +72,8 @@
     "switch_border_width": 3,
     "switch_corner_radius": 1000,
     "switch_button_corner_radius": 1000,
-    "switch_button_length": 0
+    "switch_button_length": 0,
+    "scrollbar_corner_radius": 1000,
+    "scrollbar_border_spacing": 4
   }
-}
+}

customtkinter/assets/themes/sweetkind.json

@@ -1,33 +1,41 @@
 {
   "color": {
-    "window_bg_color": ["#181b28", "#181b28"],
-    "button": ["#212435", "#212435"],
-    "button_hover": ["#171926", "#171926"],
-    "button_border": ["#080b12", "#080b12"],
+    "window_bg_color": ["#ebf0f5", "#181b28"],
+    "button": ["#e46bff", "#212435"],
+    "button_hover": ["#8593d6", "#171926"],
+    "button_border": ["#525983", "#080b12"],
     "checkbox_border": ["#01e9c4", "#01e9c4"],
     "checkmark": ["#01e9c4", "#01e9c4"],
-    "entry": ["#212435", "#212435"],
-    "entry_border": ["#080b12", "#080b12"],
+    "entry": ["#dee2e7", "#212435"],
+    "entry_border": ["#fa00d0", "#080b12"],
     "entry_placeholder_text": ["#cdc8ce", "#cdc8ce"],
-    "frame_border": ["#10121f", "#10121f"],
-    "frame_low": ["#181b28", "#181b28"],
-    "frame_high": ["#181b28", "#181b28"],
+    "frame_border": ["#525983", "#10121f"],
+    "frame_low": ["#dee2e7", "#181b28"],
+    "frame_high": ["#dee2e7", "#1b1e2d"],
     "label": [null, null],
-    "text": ["#cdc8ce", "#cdc8ce"],
-    "text_disabled": ["#7a8894", "#7a8894"],
+    "text": ["#0c0e14", "#cdc8ce"],
+    "text_disabled": ["#5e6062", "#7a8894"],
     "text_button_disabled": ["#7a8894", "#7a8894"],
-    "progressbar": ["#c452f8", "#c452f8"],
+    "progressbar": ["#fa00d0", "#fa00d0"],
     "progressbar_progress": ["#363844", "#363844"],
-    "progressbar_border": ["#0d101f", "#0d101f"],
-    "slider": ["#c452f8", "#c452f8"],
-    "slider_progress": ["#363844", "#363844"],
-    "slider_button": ["#5b40c5", "#5b40c5"],
-    "slider_button_hover": ["#c452f8", "#c452f8"],
-    "switch": ["#1f2233", "#1f2233"],
+    "progressbar_border": ["#fa00d0", "#0d101f"],
+    "slider": ["#fa00d0", "#fa00d0"],
+    "slider_progress": ["#0d101f", "#0d101f"],
+    "slider_button": ["#fa00d0", "#fa00d0"],
+    "slider_button_hover": ["#e46bff", "#fa00d0"],
+    "switch": ["#7681be", "#1f2233"],
     "switch_progress": ["#00e6c3", "#00e6c3"],
-    "switch_button": ["#2e324a", "#2e324a"],
-    "switch_button_hover": ["#2e324a", "#2e324a"],
-    "darken_factor": 0.1
+    "switch_button": ["#525983", "#2e324a"],
+    "switch_button_hover": ["#fa00d0", "#2e324a"],
+    "optionmenu_button": ["#525983", "#080b12"],
+    "optionmenu_button_hover": ["#fa00d0", "#080b12"],
+    "combobox_border": ["#525983", "#080b12"],
+    "combobox_button_hover": ["#fa00d0", "#fa00d0"],
+    "dropdown_color": ["#dee2e7", "#212435"],
+    "dropdown_hover": ["#fa00d0", "#fa00d0"],
+    "dropdown_text": ["#0c0e14", "#cdc8ce"],
+    "scrollbar_button": ["#fa00d0", "#fa00d0"],
+    "scrollbar_button_hover": ["#9b45ff", "#9b45ff"]
   },
   "text": {
     "macOS": {
@@ -45,16 +53,16 @@
   },
   "shape": {
     "button_corner_radius": 8,
-    "button_border_width": 2,
+    "button_border_width": 1,
     "checkbox_corner_radius": 7,
-    "checkbox_border_width": 3,
+    "checkbox_border_width": 1,
     "radiobutton_corner_radius": 1000,
-    "radiobutton_border_width_unchecked": 3,
+    "radiobutton_border_width_unchecked": 2,
     "radiobutton_border_width_checked": 6,
-    "entry_border_width": 2,
+    "entry_border_width": 1,
     "frame_corner_radius": 10,
-    "frame_border_width": 2,
-    "label_corner_radius": 8,
+    "frame_border_width": 1,
+    "label_corner_radius": 3,
     "progressbar_border_width": 2,
     "progressbar_corner_radius": 1000,
     "slider_border_width": 6,
@@ -64,6 +72,8 @@
     "switch_border_width": 3,
     "switch_corner_radius": 1000,
     "switch_button_corner_radius": 1000,
-    "switch_button_length": 2
+    "switch_button_length": 2,
+    "scrollbar_corner_radius": 1000,
+    "scrollbar_border_spacing": 4
   }
-}
+}

customtkinter/draw_engine.py

@@ -17,9 +17,12 @@ class DrawEngine:
 
     Functions:
      - draw_rounded_rect_with_border()
+     - draw_rounded_rect_with_border_vertical_split()
      - draw_rounded_progress_bar_with_border()
      - draw_rounded_slider_with_border_and_button()
+     - draw_rounded_scrollbar()
      - draw_checkmark()
+     - draw_dropdown_arrow()
 
     """
 
@@ -27,9 +30,8 @@ class DrawEngine:
 
     def __init__(self, canvas: CTkCanvas):
         self._canvas = canvas
-        self._existing_tags = set()
 
-    def _calc_optimal_corner_radius(self, user_corner_radius: Union[float, int]) -> Union[float, int]:
+    def __calc_optimal_corner_radius(self, user_corner_radius: Union[float, int]) -> Union[float, int]:
         # optimize for drawing with polygon shapes
         if self.preferred_drawing_method == "polygon_shapes":
             if sys.platform == "darwin":
@@ -37,7 +39,7 @@ class DrawEngine:
             else:
                 return round(user_corner_radius)
 
-        # optimize forx drawing with antialiased font shapes
+        # optimize for drawing with antialiased font shapes
         elif self.preferred_drawing_method == "font_shapes":
             return round(user_corner_radius)
 
@@ -53,13 +55,14 @@ class DrawEngine:
             else:
                 return user_corner_radius
 
-    def draw_rounded_rect_with_border(self, width: int, height: int, corner_radius: Union[float, int], border_width: Union[float, int]) -> bool:
+    def draw_rounded_rect_with_border(self, width: Union[float, int], height: Union[float, int], corner_radius: Union[float, int],
+                                      border_width: Union[float, int], overwrite_preferred_drawing_method: str = None) -> bool:
         """ Draws a rounded rectangle with a corner_radius and border_width on the canvas. The border elements have a 'border_parts' tag,
             the main foreground elements have an 'inner_parts' tag to color the elements accordingly.
 
             returns bool if recoloring is necessary """
 
-        width = math.floor(width / 2) * 2  # round (floor) current_width and current_height and restrict them to even values only
+        width = math.floor(width / 2) * 2  # round (floor) _current_width and _current_height and restrict them to even values only
         height = math.floor(height / 2) * 2
         corner_radius = round(corner_radius)
 
@@ -67,21 +70,26 @@ class DrawEngine:
             corner_radius = min(width / 2, height / 2)
 
         border_width = round(border_width)
-        corner_radius = self._calc_optimal_corner_radius(corner_radius)  # optimize corner_radius for different drawing methods (different rounding)
+        corner_radius = self.__calc_optimal_corner_radius(corner_radius)  # optimize corner_radius for different drawing methods (different rounding)
 
         if corner_radius >= border_width:
             inner_corner_radius = corner_radius - border_width
         else:
             inner_corner_radius = 0
 
-        if self.preferred_drawing_method == "polygon_shapes":
-            return self._draw_rounded_rect_with_border_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius)
-        elif self.preferred_drawing_method == "font_shapes":
-            return self._draw_rounded_rect_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius, ())
-        elif self.preferred_drawing_method == "circle_shapes":
-            return self._draw_rounded_rect_with_border_circle_shapes(width, height, corner_radius, border_width, inner_corner_radius)
+        if overwrite_preferred_drawing_method is not None:
+            preferred_drawing_method = overwrite_preferred_drawing_method
+        else:
+            preferred_drawing_method = self.preferred_drawing_method
 
-    def _draw_rounded_rect_with_border_polygon_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int) -> bool:
+        if preferred_drawing_method == "polygon_shapes":
+            return self.__draw_rounded_rect_with_border_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius)
+        elif preferred_drawing_method == "font_shapes":
+            return self.__draw_rounded_rect_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius, ())
+        elif preferred_drawing_method == "circle_shapes":
+            return self.__draw_rounded_rect_with_border_circle_shapes(width, height, corner_radius, border_width, inner_corner_radius)
+
+    def __draw_rounded_rect_with_border_polygon_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int) -> bool:
         requires_recoloring = False
 
         # create border button parts (only if border exists)
@@ -134,8 +142,8 @@ class DrawEngine:
 
         return requires_recoloring
 
-    def _draw_rounded_rect_with_border_font_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
-                                                   exclude_parts: tuple) -> bool:
+    def __draw_rounded_rect_with_border_font_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
+                                                    exclude_parts: tuple) -> bool:
         requires_recoloring = False
 
         # create border button parts
@@ -272,7 +280,7 @@ class DrawEngine:
 
         return requires_recoloring
 
-    def _draw_rounded_rect_with_border_circle_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int) -> bool:
+    def __draw_rounded_rect_with_border_circle_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int) -> bool:
         requires_recoloring = False
 
         # border button parts
@@ -346,22 +354,312 @@ class DrawEngine:
 
         return requires_recoloring
 
-    def draw_rounded_progress_bar_with_border(self, width: int, height: int, corner_radius: Union[float, int], border_width: Union[float, int],
-                                              progress_value: float, orientation: str) -> bool:
-        """ Draws a rounded bar on the canvas, which is split in half according to the argument 'progress_value' (0 - 1).
+    def draw_rounded_rect_with_border_vertical_split(self, width: Union[float, int], height: Union[float, int], corner_radius: Union[float, int],
+                                                     border_width: Union[float, int], left_section_width: Union[float, int]) -> bool:
+        """ Draws a rounded rectangle with a corner_radius and border_width on the canvas which is split at left_section_width.
+            The border elements have the tags 'border_parts_left', 'border_parts_lright',
+            the main foreground elements have an 'inner_parts_left' and inner_parts_right' tag,
+            to color the elements accordingly.
+
+            returns bool if recoloring is necessary """
+
+        left_section_width = round(left_section_width)
+        width = math.floor(width / 2) * 2  # round (floor) _current_width and _current_height and restrict them to even values only
+        height = math.floor(height / 2) * 2
+        corner_radius = round(corner_radius)
+
+        if corner_radius > width / 2 or corner_radius > height / 2:  # restrict corner_radius if it's too larger
+            corner_radius = min(width / 2, height / 2)
+
+        border_width = round(border_width)
+        corner_radius = self.__calc_optimal_corner_radius(corner_radius)  # optimize corner_radius for different drawing methods (different rounding)
+
+        if corner_radius >= border_width:
+            inner_corner_radius = corner_radius - border_width
+        else:
+            inner_corner_radius = 0
+
+        if left_section_width > width - corner_radius * 2:
+            left_section_width = width - corner_radius * 2
+        elif left_section_width < corner_radius * 2:
+            left_section_width = corner_radius * 2
+
+        if self.preferred_drawing_method == "polygon_shapes" or self.preferred_drawing_method == "circle_shapes":
+            return self.__draw_rounded_rect_with_border_vertical_split_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius, left_section_width)
+        elif self.preferred_drawing_method == "font_shapes":
+            return self.__draw_rounded_rect_with_border_vertical_split_font_shapes(width, height, corner_radius, border_width, inner_corner_radius, left_section_width, ())
+
+    def __draw_rounded_rect_with_border_vertical_split_polygon_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
+                                                                      left_section_width: int) -> bool:
+        requires_recoloring = False
+
+        # create border button parts (only if border exists)
+        if border_width > 0:
+            if not self._canvas.find_withtag("border_parts"):
+                self._canvas.create_polygon((0, 0, 0, 0), tags=("border_line_left_1", "border_parts_left", "border_parts", "left_parts"))
+                self._canvas.create_polygon((0, 0, 0, 0), tags=("border_line_right_1", "border_parts_right", "border_parts", "right_parts"))
+                self._canvas.create_rectangle((0, 0, 0, 0), tags=("border_rect_left_1", "border_parts_left", "border_parts", "left_parts"), width=0)
+                self._canvas.create_rectangle((0, 0, 0, 0), tags=("border_rect_right_1", "border_parts_right", "border_parts", "right_parts"), width=0)
+                requires_recoloring = True
+
+            self._canvas.coords("border_line_left_1",
+                                (corner_radius,
+                                 corner_radius,
+                                 left_section_width - corner_radius,
+                                 corner_radius,
+                                 left_section_width - corner_radius,
+                                 height - corner_radius,
+                                 corner_radius,
+                                 height - corner_radius))
+            self._canvas.coords("border_line_right_1",
+                                (left_section_width + corner_radius,
+                                 corner_radius,
+                                 width - corner_radius,
+                                 corner_radius,
+                                 width - corner_radius,
+                                 height - corner_radius,
+                                 left_section_width + corner_radius,
+                                 height - corner_radius))
+            self._canvas.coords("border_rect_left_1",
+                                (left_section_width - corner_radius,
+                                 0,
+                                 left_section_width,
+                                 height))
+            self._canvas.coords("border_rect_right_1",
+                                (left_section_width,
+                                 0,
+                                 left_section_width + corner_radius,
+                                 height))
+            self._canvas.itemconfig("border_line_left_1", joinstyle=tkinter.ROUND, width=corner_radius * 2)
+            self._canvas.itemconfig("border_line_right_1", joinstyle=tkinter.ROUND, width=corner_radius * 2)
+
+        else:
+            self._canvas.delete("border_parts")
+
+        # create inner button parts
+        if not self._canvas.find_withtag("inner_parts"):
+            self._canvas.create_polygon((0, 0, 0, 0), tags=("inner_line_left_1", "inner_parts_left", "inner_parts", "left_parts"), joinstyle=tkinter.ROUND)
+            self._canvas.create_polygon((0, 0, 0, 0), tags=("inner_line_right_1", "inner_parts_right", "inner_parts", "right_parts"), joinstyle=tkinter.ROUND)
+            self._canvas.create_rectangle((0, 0, 0, 0), tags=("inner_rect_left_1", "inner_parts_left", "inner_parts", "left_parts"), width=0)
+            self._canvas.create_rectangle((0, 0, 0, 0), tags=("inner_rect_right_1", "inner_parts_right", "inner_parts", "right_parts"), width=0)
+            requires_recoloring = True
+
+        self._canvas.coords("inner_line_left_1",
+                            corner_radius,
+                            corner_radius,
+                            left_section_width - inner_corner_radius,
+                            corner_radius,
+                            left_section_width - inner_corner_radius,
+                            height - corner_radius,
+                            corner_radius,
+                            height - corner_radius)
+        self._canvas.coords("inner_line_right_1",
+                            left_section_width + inner_corner_radius,
+                            corner_radius,
+                            width - corner_radius,
+                            corner_radius,
+                            width - corner_radius,
+                            height - corner_radius,
+                            left_section_width + inner_corner_radius,
+                            height - corner_radius)
+        self._canvas.coords("inner_rect_left_1",
+                            (left_section_width - inner_corner_radius,
+                             border_width,
+                             left_section_width,
+                             height - border_width))
+        self._canvas.coords("inner_rect_right_1",
+                            (left_section_width,
+                             border_width,
+                             left_section_width + inner_corner_radius,
+                             height - border_width))
+        self._canvas.itemconfig("inner_line_left_1", width=inner_corner_radius * 2)
+        self._canvas.itemconfig("inner_line_right_1", width=inner_corner_radius * 2)
+
+        if requires_recoloring:  # new parts were added -> manage z-order
+            self._canvas.tag_lower("inner_parts")
+            self._canvas.tag_lower("border_parts")
+
+        return requires_recoloring
+
+    def __draw_rounded_rect_with_border_vertical_split_font_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
+                                                                   left_section_width: int, exclude_parts: tuple) -> bool:
+        requires_recoloring = False
+
+        # create border button parts
+        if border_width > 0:
+            if corner_radius > 0:
+                # create canvas border corner parts if not already created, but only if needed, and delete if not needed
+                if not self._canvas.find_withtag("border_oval_1_a") and "border_oval_1" not in exclude_parts:
+                    self._canvas.create_aa_circle(0, 0, 0, tags=("border_oval_1_a", "border_corner_part", "border_parts_left", "border_parts", "left_parts"), anchor=tkinter.CENTER)
+                    self._canvas.create_aa_circle(0, 0, 0, tags=("border_oval_1_b", "border_corner_part", "border_parts_left", "border_parts", "left_parts"), anchor=tkinter.CENTER,
+                                                  angle=180)
+                    requires_recoloring = True
+                elif self._canvas.find_withtag("border_oval_1_a") and "border_oval_1" in exclude_parts:
+                    self._canvas.delete("border_oval_1_a", "border_oval_1_b")
+
+                if not self._canvas.find_withtag("border_oval_2_a") and width > 2 * corner_radius and "border_oval_2" not in exclude_parts:
+                    self._canvas.create_aa_circle(0, 0, 0, tags=("border_oval_2_a", "border_corner_part", "border_parts_right", "border_parts", "right_parts"),
+                                                  anchor=tkinter.CENTER)
+                    self._canvas.create_aa_circle(0, 0, 0, tags=("border_oval_2_b", "border_corner_part", "border_parts_right", "border_parts", "right_parts"),
+                                                  anchor=tkinter.CENTER, angle=180)
+                    requires_recoloring = True
+                elif self._canvas.find_withtag("border_oval_2_a") and (not width > 2 * corner_radius or "border_oval_2" in exclude_parts):
+                    self._canvas.delete("border_oval_2_a", "border_oval_2_b")
+
+                if not self._canvas.find_withtag("border_oval_3_a") and height > 2 * corner_radius \
+                    and width > 2 * corner_radius and "border_oval_3" not in exclude_parts:
+                    self._canvas.create_aa_circle(0, 0, 0, tags=("border_oval_3_a", "border_corner_part", "border_parts_right", "border_parts", "right_parts"),
+                                                  anchor=tkinter.CENTER)
+                    self._canvas.create_aa_circle(0, 0, 0, tags=("border_oval_3_b", "border_corner_part", "border_parts_right", "border_parts", "right_parts"),
+                                                  anchor=tkinter.CENTER, angle=180)
+                    requires_recoloring = True
+                elif self._canvas.find_withtag("border_oval_3_a") and (not (height > 2 * corner_radius
+                                                                            and width > 2 * corner_radius) or "border_oval_3" in exclude_parts):
+                    self._canvas.delete("border_oval_3_a", "border_oval_3_b")
+
+                if not self._canvas.find_withtag("border_oval_4_a") and height > 2 * corner_radius and "border_oval_4" not in exclude_parts:
+                    self._canvas.create_aa_circle(0, 0, 0, tags=("border_oval_4_a", "border_corner_part", "border_parts_left", "border_parts", "left_parts"), anchor=tkinter.CENTER)
+                    self._canvas.create_aa_circle(0, 0, 0, tags=("border_oval_4_b", "border_corner_part", "border_parts_left", "border_parts", "left_parts"), anchor=tkinter.CENTER,
+                                                  angle=180)
+                    requires_recoloring = True
+                elif self._canvas.find_withtag("border_oval_4_a") and (not height > 2 * corner_radius or "border_oval_4" in exclude_parts):
+                    self._canvas.delete("border_oval_4_a", "border_oval_4_b")
+
+                # change position of border corner parts
+                self._canvas.coords("border_oval_1_a", corner_radius, corner_radius, corner_radius)
+                self._canvas.coords("border_oval_1_b", corner_radius, corner_radius, corner_radius)
+                self._canvas.coords("border_oval_2_a", width - corner_radius, corner_radius, corner_radius)
+                self._canvas.coords("border_oval_2_b", width - corner_radius, corner_radius, corner_radius)
+                self._canvas.coords("border_oval_3_a", width - corner_radius, height - corner_radius, corner_radius)
+                self._canvas.coords("border_oval_3_b", width - corner_radius, height - corner_radius, corner_radius)
+                self._canvas.coords("border_oval_4_a", corner_radius, height - corner_radius, corner_radius)
+                self._canvas.coords("border_oval_4_b", corner_radius, height - corner_radius, corner_radius)
+
+            else:
+                self._canvas.delete("border_corner_part")  # delete border corner parts if not needed
+
+            # create canvas border rectangle parts if not already created
+            if not self._canvas.find_withtag("border_rectangle_1"):
+                self._canvas.create_rectangle(0, 0, 0, 0, tags=("border_rectangle_left_1", "border_rectangle_part", "border_parts_left", "border_parts", "left_parts"), width=0)
+                self._canvas.create_rectangle(0, 0, 0, 0, tags=("border_rectangle_left_2", "border_rectangle_part", "border_parts_left", "border_parts", "left_parts"), width=0)
+                self._canvas.create_rectangle(0, 0, 0, 0, tags=("border_rectangle_right_1", "border_rectangle_part", "border_parts_right", "border_parts", "right_parts"), width=0)
+                self._canvas.create_rectangle(0, 0, 0, 0, tags=("border_rectangle_right_2", "border_rectangle_part", "border_parts_right", "border_parts", "right_parts"), width=0)
+                requires_recoloring = True
+
+            # change position of border rectangle parts
+            self._canvas.coords("border_rectangle_left_1", (0, corner_radius, left_section_width, height - corner_radius))
+            self._canvas.coords("border_rectangle_left_2", (corner_radius, 0, left_section_width, height))
+            self._canvas.coords("border_rectangle_right_1", (left_section_width, corner_radius, width, height - corner_radius))
+            self._canvas.coords("border_rectangle_right_2", (left_section_width, 0, width - corner_radius, height))
+
+        else:
+            self._canvas.delete("border_parts")
+
+        # create inner button parts
+        if inner_corner_radius > 0:
+
+            # create canvas border corner parts if not already created, but only if they're needed and delete if not needed
+            if not self._canvas.find_withtag("inner_oval_1_a") and "inner_oval_1" not in exclude_parts:
+                self._canvas.create_aa_circle(0, 0, 0, tags=("inner_oval_1_a", "inner_corner_part", "inner_parts_left", "inner_parts", "left_parts"), anchor=tkinter.CENTER)
+                self._canvas.create_aa_circle(0, 0, 0, tags=("inner_oval_1_b", "inner_corner_part", "inner_parts_left", "inner_parts", "left_parts"), anchor=tkinter.CENTER,
+                                              angle=180)
+                requires_recoloring = True
+            elif self._canvas.find_withtag("inner_oval_1_a") and "inner_oval_1" in exclude_parts:
+                self._canvas.delete("inner_oval_1_a", "inner_oval_1_b")
+
+            if not self._canvas.find_withtag("inner_oval_2_a") and width - (2 * border_width) > 2 * inner_corner_radius and "inner_oval_2" not in exclude_parts:
+                self._canvas.create_aa_circle(0, 0, 0, tags=("inner_oval_2_a", "inner_corner_part", "inner_parts_right", "inner_parts", "right_parts"), anchor=tkinter.CENTER)
+                self._canvas.create_aa_circle(0, 0, 0, tags=("inner_oval_2_b", "inner_corner_part", "inner_parts_right", "inner_parts", "right_parts"), anchor=tkinter.CENTER,
+                                              angle=180)
+                requires_recoloring = True
+            elif self._canvas.find_withtag("inner_oval_2_a") and (not width - (2 * border_width) > 2 * inner_corner_radius or "inner_oval_2" in exclude_parts):
+                self._canvas.delete("inner_oval_2_a", "inner_oval_2_b")
+
+            if not self._canvas.find_withtag("inner_oval_3_a") and height - (2 * border_width) > 2 * inner_corner_radius \
+                and width - (2 * border_width) > 2 * inner_corner_radius and "inner_oval_3" not in exclude_parts:
+                self._canvas.create_aa_circle(0, 0, 0, tags=("inner_oval_3_a", "inner_corner_part", "inner_parts_right", "inner_parts", "right_parts"), anchor=tkinter.CENTER)
+                self._canvas.create_aa_circle(0, 0, 0, tags=("inner_oval_3_b", "inner_corner_part", "inner_parts_right", "inner_parts", "right_parts"), anchor=tkinter.CENTER,
+                                              angle=180)
+                requires_recoloring = True
+            elif self._canvas.find_withtag("inner_oval_3_a") and (not (height - (2 * border_width) > 2 * inner_corner_radius
+                                                                       and width - (2 * border_width) > 2 * inner_corner_radius) or "inner_oval_3" in exclude_parts):
+                self._canvas.delete("inner_oval_3_a", "inner_oval_3_b")
+
+            if not self._canvas.find_withtag("inner_oval_4_a") and height - (2 * border_width) > 2 * inner_corner_radius and "inner_oval_4" not in exclude_parts:
+                self._canvas.create_aa_circle(0, 0, 0, tags=("inner_oval_4_a", "inner_corner_part", "inner_parts_left", "inner_parts", "left_parts"), anchor=tkinter.CENTER)
+                self._canvas.create_aa_circle(0, 0, 0, tags=("inner_oval_4_b", "inner_corner_part", "inner_parts_left", "inner_parts", "left_parts"), anchor=tkinter.CENTER,
+                                              angle=180)
+                requires_recoloring = True
+            elif self._canvas.find_withtag("inner_oval_4_a") and (not height - (2 * border_width) > 2 * inner_corner_radius or "inner_oval_4" in exclude_parts):
+                self._canvas.delete("inner_oval_4_a", "inner_oval_4_b")
+
+            # change position of border corner parts
+            self._canvas.coords("inner_oval_1_a", border_width + inner_corner_radius, border_width + inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("inner_oval_1_b", border_width + inner_corner_radius, border_width + inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("inner_oval_2_a", width - border_width - inner_corner_radius, border_width + inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("inner_oval_2_b", width - border_width - inner_corner_radius, border_width + inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("inner_oval_3_a", width - border_width - inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("inner_oval_3_b", width - border_width - inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("inner_oval_4_a", border_width + inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("inner_oval_4_b", border_width + inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
+        else:
+            self._canvas.delete("inner_corner_part")  # delete inner corner parts if not needed
+
+        # create canvas inner rectangle parts if not already created
+        if not self._canvas.find_withtag("inner_rectangle_1"):
+            self._canvas.create_rectangle(0, 0, 0, 0, tags=("inner_rectangle_left_1", "inner_rectangle_part", "inner_parts_left", "inner_parts", "left_parts"), width=0)
+            self._canvas.create_rectangle(0, 0, 0, 0, tags=("inner_rectangle_right_1", "inner_rectangle_part", "inner_parts_right", "inner_parts", "right_parts"), width=0)
+            requires_recoloring = True
+
+        if not self._canvas.find_withtag("inner_rectangle_2") and inner_corner_radius * 2 < height - (border_width * 2):
+            self._canvas.create_rectangle(0, 0, 0, 0, tags=("inner_rectangle_left_2", "inner_rectangle_part", "inner_parts_left", "inner_parts", "left_parts"), width=0)
+            self._canvas.create_rectangle(0, 0, 0, 0, tags=("inner_rectangle_right_2", "inner_rectangle_part", "inner_parts_right", "inner_parts", "right_parts"), width=0)
+            requires_recoloring = True
+
+        elif self._canvas.find_withtag("inner_rectangle_2") and not inner_corner_radius * 2 < height - (border_width * 2):
+            self._canvas.delete("inner_rectangle_left_2")
+            self._canvas.delete("inner_rectangle_right_2")
+
+        # change position of inner rectangle parts
+        self._canvas.coords("inner_rectangle_left_1", (border_width + inner_corner_radius,
+                                                       border_width,
+                                                       left_section_width,
+                                                       height - border_width))
+        self._canvas.coords("inner_rectangle_left_2", (border_width,
+                                                       border_width + inner_corner_radius,
+                                                       left_section_width,
+                                                       height - inner_corner_radius - border_width))
+        self._canvas.coords("inner_rectangle_right_1", (left_section_width,
+                                                        border_width,
+                                                        width - border_width - inner_corner_radius,
+                                                        height - border_width))
+        self._canvas.coords("inner_rectangle_right_2", (left_section_width,
+                                                        border_width + inner_corner_radius,
+                                                        width - border_width,
+                                                        height - inner_corner_radius - border_width))
+
+        if requires_recoloring:  # new parts were added -> manage z-order
+            self._canvas.tag_lower("inner_parts")
+            self._canvas.tag_lower("border_parts")
+
+        return requires_recoloring
+
+    def draw_rounded_progress_bar_with_border(self, width: Union[float, int], height: Union[float, int], corner_radius: Union[float, int],
+                                              border_width: Union[float, int], progress_value_1: float, progress_value_2: float, orientation: str) -> bool:
+        """ Draws a rounded bar on the canvas, and onntop sits a progress bar from value 1 to value 2 (range 0-1, left to right, bottom to top).
             The border elements get the 'border_parts' tag", the main elements get the 'inner_parts' tag and
             the progress elements get the 'progress_parts' tag. The 'orientation' argument defines from which direction the progress starts (n, w, s, e).
 
             returns bool if recoloring is necessary """
 
-        width = math.floor(width / 2) * 2  # round current_width and current_height and restrict them to even values only
+        width = math.floor(width / 2) * 2  # round _current_width and _current_height and restrict them to even values only
         height = math.floor(height / 2) * 2
 
         if corner_radius > width / 2 or corner_radius > height / 2:  # restrict corner_radius if it's too larger
             corner_radius = min(width / 2, height / 2)
 
         border_width = round(border_width)
-        corner_radius = self._calc_optimal_corner_radius(corner_radius)  # optimize corner_radius for different drawing methods (different rounding)
+        corner_radius = self.__calc_optimal_corner_radius(corner_radius)  # optimize corner_radius for different drawing methods (different rounding)
 
         if corner_radius >= border_width:
             inner_corner_radius = corner_radius - border_width
@@ -369,16 +667,16 @@ class DrawEngine:
             inner_corner_radius = 0
 
         if self.preferred_drawing_method == "polygon_shapes" or self.preferred_drawing_method == "circle_shapes":
-            return self._draw_rounded_progress_bar_with_border_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius,
-                                                                              progress_value, orientation)
+            return self.__draw_rounded_progress_bar_with_border_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius,
+                                                                               progress_value_1, progress_value_2, orientation)
         elif self.preferred_drawing_method == "font_shapes":
-            return self._draw_rounded_progress_bar_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
-                                                                           progress_value, orientation)
+            return self.__draw_rounded_progress_bar_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
+                                                                            progress_value_1, progress_value_2, orientation)
 
-    def _draw_rounded_progress_bar_with_border_polygon_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
-                                                              progress_value: float, orientation: str) -> bool:
+    def __draw_rounded_progress_bar_with_border_polygon_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
+                                                               progress_value_1: float, progress_value_2: float, orientation: str) -> bool:
 
-        requires_recoloring = self._draw_rounded_rect_with_border_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius)
+        requires_recoloring = self.__draw_rounded_rect_with_border_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius)
 
         if corner_radius <= border_width:
             bottom_right_shift = 0  # weird canvas rendering inaccuracy that has to be corrected in some cases
@@ -393,32 +691,32 @@ class DrawEngine:
 
         if orientation == "w":
             self._canvas.coords("progress_line_1",
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 border_width + inner_corner_radius,
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
                                 border_width + inner_corner_radius,
-                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
-                                border_width + inner_corner_radius,
-                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
                                 height - (border_width + inner_corner_radius) + bottom_right_shift,
-                                border_width + inner_corner_radius,
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 height - (border_width + inner_corner_radius) + bottom_right_shift)
 
         elif orientation == "s":
             self._canvas.coords("progress_line_1",
                                 border_width + inner_corner_radius,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value),
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2),
                                 width - (border_width + inner_corner_radius),
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value),
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2),
                                 width - (border_width + inner_corner_radius),
-                                height - (border_width + inner_corner_radius) + bottom_right_shift,
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1),
                                 border_width + inner_corner_radius,
-                                height - (border_width + inner_corner_radius) + bottom_right_shift)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1))
 
         self._canvas.itemconfig("progress_line_1", width=inner_corner_radius * 2)
 
         return requires_recoloring
 
-    def _draw_rounded_progress_bar_with_border_font_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
-                                                           progress_value: float, orientation: str) -> bool:
+    def __draw_rounded_progress_bar_with_border_font_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
+                                                            progress_value_1: float, progress_value_2: float, orientation: str) -> bool:
 
         requires_recoloring, requires_recoloring_2 = False, False
 
@@ -452,73 +750,81 @@ class DrawEngine:
 
         # horizontal orientation from the bottom
         if orientation == "w":
-            requires_recoloring_2 = self._draw_rounded_rect_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
-                                                                                    ("inner_oval_1", "inner_oval_4"))
+            requires_recoloring_2 = self.__draw_rounded_rect_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
+                                                                                     ())
 
             # set positions of progress corner parts
-            self._canvas.coords("progress_oval_1_a", border_width + inner_corner_radius, border_width + inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_1_b", border_width + inner_corner_radius, border_width + inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_2_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+            self._canvas.coords("progress_oval_1_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 border_width + inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_2_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+            self._canvas.coords("progress_oval_1_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 border_width + inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_3_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+            self._canvas.coords("progress_oval_2_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
+                                border_width + inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("progress_oval_2_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
+                                border_width + inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("progress_oval_3_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
                                 height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_3_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+            self._canvas.coords("progress_oval_3_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
+                                height - border_width - inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("progress_oval_4_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
+                                height - border_width - inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("progress_oval_4_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_4_a", border_width + inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_4_b", border_width + inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
 
             # set positions of progress rect parts
             self._canvas.coords("progress_rectangle_1",
-                                border_width + inner_corner_radius,
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 border_width,
-                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
                                 height - border_width)
             self._canvas.coords("progress_rectangle_2",
-                                border_width,
+                                border_width + 2 * inner_corner_radius + (width - 2 * inner_corner_radius - 2 * border_width) * progress_value_1,
                                 border_width + inner_corner_radius,
-                                border_width + 2 * inner_corner_radius + (width - 2 * inner_corner_radius - 2 * border_width) * progress_value,
+                                border_width + 2 * inner_corner_radius + (width - 2 * inner_corner_radius - 2 * border_width) * progress_value_2,
                                 height - inner_corner_radius - border_width)
 
         # vertical orientation from the bottom
         if orientation == "s":
-            requires_recoloring_2 = self._draw_rounded_rect_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
-                                                                                    ("inner_oval_3", "inner_oval_4"))
+            requires_recoloring_2 = self.__draw_rounded_rect_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
+                                                                                     ())
 
             # set positions of progress corner parts
             self._canvas.coords("progress_oval_1_a", border_width + inner_corner_radius,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value), inner_corner_radius)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2), inner_corner_radius)
             self._canvas.coords("progress_oval_1_b", border_width + inner_corner_radius,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value), inner_corner_radius)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2), inner_corner_radius)
             self._canvas.coords("progress_oval_2_a", width - border_width - inner_corner_radius,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value), inner_corner_radius)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2), inner_corner_radius)
             self._canvas.coords("progress_oval_2_b", width - border_width - inner_corner_radius,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value), inner_corner_radius)
-            self._canvas.coords("progress_oval_3_a", width - border_width - inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_3_b", width - border_width - inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_4_a", border_width + inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_4_b", border_width + inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2), inner_corner_radius)
+            self._canvas.coords("progress_oval_3_a", width - border_width - inner_corner_radius,
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1), inner_corner_radius)
+            self._canvas.coords("progress_oval_3_b", width - border_width - inner_corner_radius,
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1), inner_corner_radius)
+            self._canvas.coords("progress_oval_4_a", border_width + inner_corner_radius,
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1), inner_corner_radius)
+            self._canvas.coords("progress_oval_4_b", border_width + inner_corner_radius,
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1), inner_corner_radius)
 
             # set positions of progress rect parts
             self._canvas.coords("progress_rectangle_1",
                                 border_width + inner_corner_radius,
-                                border_width + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value),
+                                border_width + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2),
                                 width - border_width - inner_corner_radius,
-                                height - border_width)
+                                border_width + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1))
             self._canvas.coords("progress_rectangle_2",
                                 border_width,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value),
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2),
                                 width - border_width,
-                                height - inner_corner_radius - border_width)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1))
 
         return requires_recoloring or requires_recoloring_2
 
-    def draw_rounded_slider_with_border_and_button(self, width: int, height: int, corner_radius: Union[float, int], border_width: Union[float, int],
-                                                   button_length: Union[float, int], button_corner_radius: Union[float, int], slider_value: float,
-                                                   orientation: str) -> bool:
+    def draw_rounded_slider_with_border_and_button(self, width: Union[float, int], height: Union[float, int], corner_radius: Union[float, int],
+                                                   border_width: Union[float, int], button_length: Union[float, int], button_corner_radius: Union[float, int],
+                                                   slider_value: float, orientation: str) -> bool:
 
-        width = math.floor(width / 2) * 2  # round current_width and current_height and restrict them to even values only
+        width = math.floor(width / 2) * 2  # round _current_width and _current_height and restrict them to even values only
         height = math.floor(height / 2) * 2
 
         if corner_radius > width / 2 or corner_radius > height / 2:  # restrict corner_radius if it's too larger
@@ -530,7 +836,7 @@ class DrawEngine:
         button_length = round(button_length)
         border_width = round(border_width)
         button_corner_radius = round(button_corner_radius)
-        corner_radius = self._calc_optimal_corner_radius(corner_radius)  # optimize corner_radius for different drawing methods (different rounding)
+        corner_radius = self.__calc_optimal_corner_radius(corner_radius)  # optimize corner_radius for different drawing methods (different rounding)
 
         if corner_radius >= border_width:
             inner_corner_radius = corner_radius - border_width
@@ -538,18 +844,18 @@ class DrawEngine:
             inner_corner_radius = 0
 
         if self.preferred_drawing_method == "polygon_shapes" or self.preferred_drawing_method == "circle_shapes":
-            return self._draw_rounded_slider_with_border_and_button_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius,
-                                                                                   button_length, button_corner_radius, slider_value, orientation)
+            return self.__draw_rounded_slider_with_border_and_button_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius,
+                                                                                    button_length, button_corner_radius, slider_value, orientation)
         elif self.preferred_drawing_method == "font_shapes":
-            return self._draw_rounded_slider_with_border_and_button_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
-                                                                                button_length, button_corner_radius, slider_value, orientation)
+            return self.__draw_rounded_slider_with_border_and_button_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
+                                                                                 button_length, button_corner_radius, slider_value, orientation)
 
-    def _draw_rounded_slider_with_border_and_button_polygon_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
-                                                                   button_length: int, button_corner_radius: int, slider_value: float, orientation: str) -> bool:
+    def __draw_rounded_slider_with_border_and_button_polygon_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
+                                                                    button_length: int, button_corner_radius: int, slider_value: float, orientation: str) -> bool:
 
         # draw normal progressbar
-        requires_recoloring = self._draw_rounded_progress_bar_with_border_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius,
-                                                                                         slider_value, orientation)
+        requires_recoloring = self.__draw_rounded_progress_bar_with_border_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius,
+                                                                                          0, slider_value, orientation)
 
         # create slider button part
         if not self._canvas.find_withtag("slider_parts"):
@@ -583,12 +889,12 @@ class DrawEngine:
 
         return requires_recoloring
 
-    def _draw_rounded_slider_with_border_and_button_font_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
-                                                                button_length: int, button_corner_radius: int, slider_value: float, orientation: str) -> bool:
+    def __draw_rounded_slider_with_border_and_button_font_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
+                                                                 button_length: int, button_corner_radius: int, slider_value: float, orientation: str) -> bool:
 
         # draw normal progressbar
-        requires_recoloring = self._draw_rounded_progress_bar_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
-                                                                                      slider_value, orientation)
+        requires_recoloring = self.__draw_rounded_progress_bar_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
+                                                                                       0, slider_value, orientation)
 
         # create 4 circles (if not needed, then less)
         if not self._canvas.find_withtag("slider_oval_1_a"):
@@ -672,7 +978,147 @@ class DrawEngine:
 
         return requires_recoloring
 
-    def draw_checkmark(self, width: int, height: int, size: Union[int, float]) -> bool:
+    def draw_rounded_scrollbar(self, width: Union[float, int], height: Union[float, int], corner_radius: Union[float, int],
+                               border_spacing: Union[float, int], start_value: float, end_value: float, orientation: str) -> bool:
+        width = math.floor(width / 2) * 2  # round _current_width and _current_height and restrict them to even values only
+        height = math.floor(height / 2) * 2
+
+        if corner_radius > width / 2 or corner_radius > height / 2:  # restrict corner_radius if it's too larger
+            corner_radius = min(width / 2, height / 2)
+
+        border_spacing = round(border_spacing)
+        corner_radius = self.__calc_optimal_corner_radius(corner_radius)  # optimize corner_radius for different drawing methods (different rounding)
+
+        if corner_radius >= border_spacing:
+            inner_corner_radius = corner_radius - border_spacing
+        else:
+            inner_corner_radius = 0
+
+        if self.preferred_drawing_method == "polygon_shapes" or self.preferred_drawing_method == "circle_shapes":
+            return self.__draw_rounded_scrollbar_polygon_shapes(width, height, corner_radius, inner_corner_radius,
+                                                                start_value, end_value, orientation)
+        elif self.preferred_drawing_method == "font_shapes":
+            return self.__draw_rounded_scrollbar_font_shapes(width, height, corner_radius, inner_corner_radius,
+                                                             start_value, end_value, orientation)
+
+    def __draw_rounded_scrollbar_polygon_shapes(self, width: int, height: int, corner_radius: int, inner_corner_radius: int,
+                                                start_value: float, end_value: float, orientation: str) -> bool:
+        requires_recoloring = False
+
+        if not self._canvas.find_withtag("border_parts"):
+            self._canvas.create_rectangle(0, 0, 0, 0, tags=("border_rectangle_1", "border_parts"), width=0)
+            requires_recoloring = True
+        self._canvas.coords("border_rectangle_1", 0, 0, width, height)
+
+        if not self._canvas.find_withtag("scrollbar_parts"):
+            self._canvas.create_polygon((0, 0, 0, 0), tags=("scrollbar_polygon_1", "scrollbar_parts"), joinstyle=tkinter.ROUND)
+            self._canvas.tag_raise("scrollbar_parts", "border_parts")
+            requires_recoloring = True
+
+        if orientation == "vertical":
+            self._canvas.coords("scrollbar_polygon_1",
+                                corner_radius, corner_radius + (height - 2 * corner_radius) * start_value,
+                                width - corner_radius, corner_radius + (height - 2 * corner_radius) * start_value,
+                                width - corner_radius, corner_radius + (height - 2 * corner_radius) * end_value,
+                                corner_radius, corner_radius + (height - 2 * corner_radius) * end_value)
+        elif orientation == "horizontal":
+            self._canvas.coords("scrollbar_polygon_1",
+                                corner_radius + (width - 2 * corner_radius) * start_value, corner_radius,
+                                corner_radius + (width - 2 * corner_radius) * end_value, corner_radius,
+                                corner_radius + (width - 2 * corner_radius) * end_value, height - corner_radius,
+                                corner_radius + (width - 2 * corner_radius) * start_value, height - corner_radius,)
+
+        self._canvas.itemconfig("scrollbar_polygon_1", width=inner_corner_radius * 2)
+
+        return requires_recoloring
+
+    def __draw_rounded_scrollbar_font_shapes(self, width: int, height: int, corner_radius: int, inner_corner_radius: int,
+                                             start_value: float, end_value: float, orientation: str) -> bool:
+        requires_recoloring = False
+
+        if not self._canvas.find_withtag("border_parts"):
+            self._canvas.create_rectangle(0, 0, 0, 0, tags=("border_rectangle_1", "border_parts"), width=0)
+            requires_recoloring = True
+        self._canvas.coords("border_rectangle_1", 0, 0, width, height)
+
+        if inner_corner_radius > 0:
+            if not self._canvas.find_withtag("scrollbar_oval_1_a"):
+                self._canvas.create_aa_circle(0, 0, 0, tags=("scrollbar_oval_1_a", "scrollbar_corner_part", "scrollbar_parts"), anchor=tkinter.CENTER)
+                self._canvas.create_aa_circle(0, 0, 0, tags=("scrollbar_oval_1_b", "scrollbar_corner_part", "scrollbar_parts"), anchor=tkinter.CENTER, angle=180)
+                requires_recoloring = True
+
+            if not self._canvas.find_withtag("scrollbar_oval_2_a") and width > 2 * corner_radius:
+                self._canvas.create_aa_circle(0, 0, 0, tags=("scrollbar_oval_2_a", "scrollbar_corner_part", "scrollbar_parts"), anchor=tkinter.CENTER)
+                self._canvas.create_aa_circle(0, 0, 0, tags=("scrollbar_oval_2_b", "scrollbar_corner_part", "scrollbar_parts"), anchor=tkinter.CENTER, angle=180)
+                requires_recoloring = True
+            elif self._canvas.find_withtag("scrollbar_oval_2_a") and not width > 2 * corner_radius:
+                self._canvas.delete("scrollbar_oval_2_a", "scrollbar_oval_2_b")
+
+            if not self._canvas.find_withtag("scrollbar_oval_3_a") and height > 2 * corner_radius and width > 2 * corner_radius:
+                self._canvas.create_aa_circle(0, 0, 0, tags=("scrollbar_oval_3_a", "scrollbar_corner_part", "scrollbar_parts"), anchor=tkinter.CENTER)
+                self._canvas.create_aa_circle(0, 0, 0, tags=("scrollbar_oval_3_b", "scrollbar_corner_part", "scrollbar_parts"), anchor=tkinter.CENTER, angle=180)
+                requires_recoloring = True
+            elif self._canvas.find_withtag("scrollbar_oval_3_a") and not (height > 2 * corner_radius and width > 2 * corner_radius):
+                self._canvas.delete("scrollbar_oval_3_a", "scrollbar_oval_3_b")
+
+            if not self._canvas.find_withtag("scrollbar_oval_4_a") and height > 2 * corner_radius:
+                self._canvas.create_aa_circle(0, 0, 0, tags=("scrollbar_oval_4_a", "scrollbar_corner_part", "scrollbar_parts"), anchor=tkinter.CENTER)
+                self._canvas.create_aa_circle(0, 0, 0, tags=("scrollbar_oval_4_b", "scrollbar_corner_part", "scrollbar_parts"), anchor=tkinter.CENTER, angle=180)
+                requires_recoloring = True
+            elif self._canvas.find_withtag("scrollbar_oval_4_a") and not height > 2 * corner_radius:
+                self._canvas.delete("scrollbar_oval_4_a", "scrollbar_oval_4_b")
+        else:
+            self._canvas.delete("scrollbar_corner_part")
+
+        if not self._canvas.find_withtag("scrollbar_rectangle_1") and height > 2 * corner_radius:
+            self._canvas.create_rectangle(0, 0, 0, 0, tags=("scrollbar_rectangle_1", "scrollbar_rectangle_part", "scrollbar_parts"), width=0)
+            requires_recoloring = True
+        elif self._canvas.find_withtag("scrollbar_rectangle_1") and not height > 2 * corner_radius:
+            self._canvas.delete("scrollbar_rectangle_1")
+
+        if not self._canvas.find_withtag("scrollbar_rectangle_2") and width > 2 * corner_radius:
+            self._canvas.create_rectangle(0, 0, 0, 0, tags=("scrollbar_rectangle_2", "scrollbar_rectangle_part", "scrollbar_parts"), width=0)
+            requires_recoloring = True
+        elif self._canvas.find_withtag("scrollbar_rectangle_2") and not width > 2 * corner_radius:
+            self._canvas.delete("scrollbar_rectangle_2")
+
+        if orientation == "vertical":
+            self._canvas.coords("scrollbar_rectangle_1",
+                                corner_radius - inner_corner_radius, corner_radius + (height - 2 * corner_radius) * start_value,
+                                width - (corner_radius - inner_corner_radius), corner_radius + (height - 2 * corner_radius) * end_value)
+            self._canvas.coords("scrollbar_rectangle_2",
+                                corner_radius, corner_radius - inner_corner_radius + (height - 2 * corner_radius) * start_value,
+                                width - (corner_radius), corner_radius + inner_corner_radius + (height - 2 * corner_radius) * end_value)
+
+            self._canvas.coords("scrollbar_oval_1_a", corner_radius, corner_radius + (height - 2 * corner_radius) * start_value, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_1_b", corner_radius, corner_radius + (height - 2 * corner_radius) * start_value, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_2_a", width - corner_radius, corner_radius + (height - 2 * corner_radius) * start_value, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_2_b", width - corner_radius, corner_radius + (height - 2 * corner_radius) * start_value, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_3_a", width - corner_radius, corner_radius + (height - 2 * corner_radius) * end_value, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_3_b", width - corner_radius, corner_radius + (height - 2 * corner_radius) * end_value, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_4_a", corner_radius, corner_radius + (height - 2 * corner_radius) * end_value, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_4_b", corner_radius, corner_radius + (height - 2 * corner_radius) * end_value, inner_corner_radius)
+
+        if orientation == "horizontal":
+            self._canvas.coords("scrollbar_rectangle_1",
+                                corner_radius - inner_corner_radius + (width - 2 * corner_radius) * start_value, corner_radius,
+                                corner_radius + inner_corner_radius + (width - 2 * corner_radius) * end_value, height - corner_radius)
+            self._canvas.coords("scrollbar_rectangle_2",
+                                corner_radius + (width - 2 * corner_radius) * start_value, corner_radius - inner_corner_radius,
+                                corner_radius + (width - 2 * corner_radius) * end_value, height - (corner_radius - inner_corner_radius))
+
+            self._canvas.coords("scrollbar_oval_1_a", corner_radius + (width - 2 * corner_radius) * start_value, corner_radius, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_1_b", corner_radius + (width - 2 * corner_radius) * start_value, corner_radius, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_2_a", corner_radius + (width - 2 * corner_radius) * end_value, corner_radius, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_2_b", corner_radius + (width - 2 * corner_radius) * end_value, corner_radius, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_3_a", corner_radius + (width - 2 * corner_radius) * end_value, height - corner_radius, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_3_b", corner_radius + (width - 2 * corner_radius) * end_value, height - corner_radius, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_4_a", corner_radius + (width - 2 * corner_radius) * start_value, height - corner_radius, inner_corner_radius)
+            self._canvas.coords("scrollbar_oval_4_b", corner_radius + (width - 2 * corner_radius) * start_value, height - corner_radius, inner_corner_radius)
+
+        return requires_recoloring
+
+    def draw_checkmark(self, width: Union[float, int], height: Union[float, int], size: Union[int, float]) -> bool:
         """ Draws a rounded rectangle with a corner_radius and border_width on the canvas. The border elements have a 'border_parts' tag,
             the main foreground elements have an 'inner_parts' tag to color the elements accordingly.
 
@@ -701,3 +1147,35 @@ class DrawEngine:
             self._canvas.coords("checkmark", round(width / 2), round(height / 2))
 
         return requires_recoloring
+
+    def draw_dropdown_arrow(self, x_position: Union[int, float], y_position: Union[int, float], size: Union[int, float]) -> bool:
+        """ Draws a dropdown bottom facing arrow at (x_position, y_position) in a given size
+
+            returns bool if recoloring is necessary """
+
+        x_position, y_position, size = round(x_position), round(y_position), round(size)
+        requires_recoloring = False
+
+        if self.preferred_drawing_method == "polygon_shapes" or self.preferred_drawing_method == "circle_shapes":
+            if not self._canvas.find_withtag("dropdown_arrow"):
+                self._canvas.create_line(0, 0, 0, 0, tags="dropdown_arrow", width=round(size / 3), joinstyle=tkinter.ROUND, capstyle=tkinter.ROUND)
+                self._canvas.tag_raise("dropdown_arrow")
+                requires_recoloring = True
+
+            self._canvas.coords("dropdown_arrow",
+                                x_position - (size / 2),
+                                y_position - (size / 5),
+                                x_position,
+                                y_position + (size / 5),
+                                x_position + (size / 2),
+                                y_position - (size / 5))
+
+        elif self.preferred_drawing_method == "font_shapes":
+            if not self._canvas.find_withtag("dropdown_arrow"):
+                self._canvas.create_text(0, 0, text="Y", font=("CustomTkinter_shapes_font", -size), tags="dropdown_arrow", anchor=tkinter.CENTER)
+                self._canvas.tag_raise("dropdown_arrow")
+                requires_recoloring = True
+
+            self._canvas.coords("dropdown_arrow", x_position, y_position)
+
+        return requires_recoloring

customtkinter/font_manager.py

@@ -6,13 +6,15 @@ from typing import Union
 
 class FontManager:
 
+    linux_font_path = "~/.fonts/"
+
     @classmethod
     def init_font_manager(cls):
         # Linux
         if sys.platform.startswith("linux"):
             try:
-                if not os.path.isdir(os.path.expanduser('~/.fonts/')):
-                    os.mkdir(os.path.expanduser('~/.fonts/'))
+                if not os.path.isdir(os.path.expanduser(cls.linux_font_path)):
+                    os.mkdir(os.path.expanduser(cls.linux_font_path))
                 return True
             except Exception as err:
                 sys.stderr.write("FontManager error: " + str(err) + "\n")
@@ -53,7 +55,7 @@ class FontManager:
         # Linux
         elif sys.platform.startswith("linux"):
             try:
-                shutil.copy(font_path, os.path.expanduser("~/.fonts/"))
+                shutil.copy(font_path, os.path.expanduser(cls.linux_font_path))
                 return True
             except Exception as err:
                 sys.stderr.write("FontManager error: " + str(err) + "\n")

customtkinter/scaling_tracker.py

@@ -124,7 +124,7 @@ class ScalingTracker:
 
     @classmethod
     def activate_high_dpi_awareness(cls):
-        """ make process DPI aware, customtkinter elemets will get scaled automatically,
+        """ make process DPI aware, customtkinter elements will get scaled automatically,
             only gets activated when CTk object is created """
 
         if not cls.deactivate_automatic_dpi_awareness:
@@ -135,37 +135,40 @@ class ScalingTracker:
                 from ctypes import windll
                 windll.shcore.SetProcessDpiAwareness(2)
                 # Microsoft Docs: https://docs.microsoft.com/en-us/windows/win32/api/shellscalingapi/ne-shellscalingapi-process_dpi_awareness
-
             else:
                 pass  # DPI awareness on Linux not implemented
 
     @classmethod
     def get_window_dpi_scaling(cls, window) -> float:
-        if sys.platform == "darwin":
-            return 1  # scaling works automatically on macOS
+        if not cls.deactivate_automatic_dpi_awareness:
+            if sys.platform == "darwin":
+                return 1  # scaling works automatically on macOS
 
-        elif sys.platform.startswith("win"):
-            from ctypes import windll, pointer, wintypes
+            elif sys.platform.startswith("win"):
+                from ctypes import windll, pointer, wintypes
 
-            DPI100pc = 96  # DPI 96 is 100% scaling
-            DPI_type = 0  # MDT_EFFECTIVE_DPI = 0, MDT_ANGULAR_DPI = 1, MDT_RAW_DPI = 2
-            window_hwnd = wintypes.HWND(window.winfo_id())
-            monitor_handle = windll.user32.MonitorFromWindow(window_hwnd, wintypes.DWORD(2))  # MONITOR_DEFAULTTONEAREST = 2
-            x_dpi, y_dpi = wintypes.UINT(), wintypes.UINT()
-            windll.shcore.GetDpiForMonitor(monitor_handle, DPI_type, pointer(x_dpi), pointer(y_dpi))
-            return (x_dpi.value + y_dpi.value) / (2 * DPI100pc)
+                DPI100pc = 96  # DPI 96 is 100% scaling
+                DPI_type = 0  # MDT_EFFECTIVE_DPI = 0, MDT_ANGULAR_DPI = 1, MDT_RAW_DPI = 2
+                window_hwnd = wintypes.HWND(window.winfo_id())
+                monitor_handle = windll.user32.MonitorFromWindow(window_hwnd, wintypes.DWORD(2))  # MONITOR_DEFAULTTONEAREST = 2
+                x_dpi, y_dpi = wintypes.UINT(), wintypes.UINT()
+                windll.shcore.GetDpiForMonitor(monitor_handle, DPI_type, pointer(x_dpi), pointer(y_dpi))
+                return (x_dpi.value + y_dpi.value) / (2 * DPI100pc)
 
+            else:
+                return 1  # DPI awareness on Linux not implemented
         else:
-            return 1  # DPI awareness on Linux not implemented
+            return 1
 
     @classmethod
     def check_dpi_scaling(cls):
         # check for every window if scaling value changed
         for window in cls.window_widgets_dict:
-            current_dpi_scaling_value = cls.get_window_dpi_scaling(window)
-            if current_dpi_scaling_value != cls.window_dpi_scaling_dict[window]:
-                cls.window_dpi_scaling_dict[window] = current_dpi_scaling_value
-                cls.update_scaling_callbacks_for_window(window)
+            if window.winfo_exists():
+                current_dpi_scaling_value = cls.get_window_dpi_scaling(window)
+                if current_dpi_scaling_value != cls.window_dpi_scaling_dict[window]:
+                    cls.window_dpi_scaling_dict[window] = current_dpi_scaling_value
+                    cls.update_scaling_callbacks_for_window(window)
 
         # find an existing tkinter object for the next call of .after()
         for app in cls.window_widgets_dict.keys():

customtkinter/settings.py

@@ -3,3 +3,4 @@ class Settings:
     cursor_manipulation_enabled = True
     deactivate_macos_window_header_manipulation = False
     deactivate_windows_window_header_manipulation = False
+    use_dropdown_fallback = True

customtkinter/theme_manager.py

@@ -62,6 +62,19 @@ class ThemeManager:
 
         return cls.rgb2hex(new_rgb)
 
+    @classmethod
+    def get_minimal_darker(cls, color: str) -> str:
+        if color.startswith("#"):
+            color_rgb = cls.hex2rgb(color)
+            if color_rgb[0] > 0:
+                return cls.rgb2hex((color_rgb[0] - 1, color_rgb[1], color_rgb[2]))
+            elif color_rgb[1] > 0:
+                return cls.rgb2hex((color_rgb[0], color_rgb[1] - 1, color_rgb[2]))
+            elif color_rgb[2] > 0:
+                return cls.rgb2hex((color_rgb[0], color_rgb[1], color_rgb[2] - 1))
+            else:
+                return cls.rgb2hex((color_rgb[0] + 1, color_rgb[1], color_rgb[2] - 1))  # otherwise slightly lighter
+
     @classmethod
     def multiply_hex_color(cls, hex_color: str, factor: float = 1.0) -> str:
         try:

customtkinter/widgets/ctk_button.py

@@ -1,6 +1,6 @@
 import tkinter
 import sys
-import math
+from typing import Union, Tuple, Callable
 
 from .ctk_canvas import CTkCanvas
 from ..theme_manager import ThemeManager
@@ -10,83 +10,82 @@ from .widget_base_class import CTkBaseClass
 
 
 class CTkButton(CTkBaseClass):
-    """ tkinter custom button with border, rounded corners and hover effect """
+    """ button with border, rounded corners, hover effect, image support """
 
     def __init__(self, *args,
-                 bg_color=None,
-                 fg_color="default_theme",
-                 hover_color="default_theme",
-                 border_color="default_theme",
-                 border_width="default_theme",
-                 command=None,
-                 textvariable=None,
-                 width=120,
-                 height=30,
-                 corner_radius="default_theme",
-                 text_font="default_theme",
-                 text_color="default_theme",
-                 text_color_disabled="default_theme",
-                 text="CTkButton",
-                 hover=True,
-                 image=None,
-                 compound=tkinter.LEFT,
-                 state=tkinter.NORMAL,
+                 bg_color: Union[str, Tuple[str, str], None] = None,
+                 fg_color: Union[str, Tuple[str, str], None] = "default_theme",
+                 hover_color: Union[str, Tuple[str, str]] = "default_theme",
+                 border_color: Union[str, Tuple[str, str]] = "default_theme",
+                 text_color: Union[str, Tuple[str, str]] = "default_theme",
+                 text_color_disabled: Union[str, Tuple[str, str]] = "default_theme",
+                 width: int = 140,
+                 height: int = 28,
+                 corner_radius: Union[int, str] = "default_theme",
+                 border_width: Union[int, str] = "default_theme",
+                 text: str = "CTkButton",
+                 textvariable: tkinter.Variable = None,
+                 text_font: any = "default_theme",
+                 image: tkinter.PhotoImage = None,
+                 hover: bool = True,
+                 compound: str = "left",
+                 state: str = "normal",
+                 command: Callable = None,
                  **kwargs):
 
-        # transfer basic functionality (bg_color, size, appearance_mode, scaling) to CTkBaseClass
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
         super().__init__(*args, bg_color=bg_color, width=width, height=height, **kwargs)
 
-        self.configure_basic_grid()
-
-        # color variables
+        # color
         self.fg_color = ThemeManager.theme["color"]["button"] if fg_color == "default_theme" else fg_color
         self.hover_color = ThemeManager.theme["color"]["button_hover"] if hover_color == "default_theme" else hover_color
         self.border_color = ThemeManager.theme["color"]["button_border"] if border_color == "default_theme" else border_color
+        self.text_color = ThemeManager.theme["color"]["text"] if text_color == "default_theme" else text_color
+        self.text_color_disabled = ThemeManager.theme["color"]["text_button_disabled"] if text_color_disabled == "default_theme" else text_color_disabled
 
         # shape
         self.corner_radius = ThemeManager.theme["shape"]["button_corner_radius"] if corner_radius == "default_theme" else corner_radius
         self.border_width = ThemeManager.theme["shape"]["button_border_width"] if border_width == "default_theme" else border_width
 
-        # text and font and image
+        # text, font, image
         self.image = image
         self.image_label = None
         self.text = text
         self.text_label = None
-        self.text_color = ThemeManager.theme["color"]["text"] if text_color == "default_theme" else text_color
-        self.text_color_disabled = ThemeManager.theme["color"]["text_button_disabled"] if text_color_disabled == "default_theme" else text_color_disabled
         self.text_font = (ThemeManager.theme["text"]["font"], ThemeManager.theme["text"]["size"]) if text_font == "default_theme" else text_font
 
         # callback and hover functionality
-        self.function = command
+        self.command = command
         self.textvariable = textvariable
         self.state = state
         self.hover = hover
         self.compound = compound
         self.click_animation_running = False
 
+        # configure grid system (2x2)
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=1)
+        self.grid_rowconfigure(1, weight=1)
+        self.grid_columnconfigure(1, weight=1)
+
+        # canvas
         self.canvas = CTkCanvas(master=self,
                                 highlightthickness=0,
-                                width=self.apply_widget_scaling(self.desired_width),
-                                height=self.apply_widget_scaling(self.desired_height))
+                                width=self.apply_widget_scaling(self._desired_width),
+                                height=self.apply_widget_scaling(self._desired_height))
         self.canvas.grid(row=0, column=0, rowspan=2, columnspan=2, sticky="nsew")
         self.draw_engine = DrawEngine(self.canvas)
 
-        # event bindings
+        # canvas event bindings
         self.canvas.bind("<Enter>", self.on_enter)
         self.canvas.bind("<Leave>", self.on_leave)
         self.canvas.bind("<Button-1>", self.clicked)
         self.canvas.bind("<Button-1>", self.clicked)
         self.bind('<Configure>', self.update_dimensions_event)
 
+        # configure cursor and initial draw
         self.set_cursor()
-        self.draw()  # initial draw
-
-    def configure_basic_grid(self):
-        # Configuration of a grid system (2x2) in which all parts of CTkButton are centered
-        self.grid_rowconfigure(0, weight=1)
-        self.grid_columnconfigure(0, weight=1)
-        self.grid_rowconfigure(1, weight=1)
-        self.grid_columnconfigure(1, weight=1)
+        self.draw()
 
     def set_scaling(self, *args, **kwargs):
         super().set_scaling(*args, **kwargs)
@@ -98,41 +97,41 @@ class CTkButton(CTkBaseClass):
             self.image_label.destroy()
             self.image_label = None
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width),
-                              height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
-    def set_dimensions(self, width=None, height=None):
+    def set_dimensions(self, width: int = None, height: int = None):
         super().set_dimensions(width, height)
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width),
-                              height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def draw(self, no_color_updates=False):
-        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self.current_width),
-                                                                             self.apply_widget_scaling(self.current_height),
+        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self._current_width),
+                                                                             self.apply_widget_scaling(self._current_height),
                                                                              self.apply_widget_scaling(self.corner_radius),
                                                                              self.apply_widget_scaling(self.border_width))
 
         if no_color_updates is False or requires_recoloring:
 
-            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
             # set color for the button border parts (outline)
             self.canvas.itemconfig("border_parts",
-                                   outline=ThemeManager.single_color(self.border_color, self.appearance_mode),
-                                   fill=ThemeManager.single_color(self.border_color, self.appearance_mode))
+                                   outline=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.border_color, self._appearance_mode))
 
             # set color for inner button parts
             if self.fg_color is None:
                 self.canvas.itemconfig("inner_parts",
-                                       outline=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                       fill=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                                       outline=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                       fill=ThemeManager.single_color(self.bg_color, self._appearance_mode))
             else:
                 self.canvas.itemconfig("inner_parts",
-                                       outline=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                       fill=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       fill=ThemeManager.single_color(self.fg_color, self._appearance_mode))
 
         # create text label if text given
         if self.text is not None and self.text != "":
@@ -140,6 +139,7 @@ class CTkButton(CTkBaseClass):
             if self.text_label is None:
                 self.text_label = tkinter.Label(master=self,
                                                 font=self.apply_font_scaling(self.text_font),
+                                                text=self.text,
                                                 textvariable=self.textvariable)
 
                 self.text_label.bind("<Enter>", self.on_enter)
@@ -149,19 +149,17 @@ class CTkButton(CTkBaseClass):
 
             if no_color_updates is False:
                 # set text_label fg color (text color)
-                self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self.appearance_mode))
+                self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
 
                 if self.state == tkinter.DISABLED:
-                    self.text_label.configure(fg=(ThemeManager.single_color(self.text_color_disabled, self.appearance_mode)))
+                    self.text_label.configure(fg=(ThemeManager.single_color(self.text_color_disabled, self._appearance_mode)))
                 else:
-                    self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self.appearance_mode))
+                    self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
 
                 if self.fg_color is None:
-                    self.text_label.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                    self.text_label.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
                 else:
-                    self.text_label.configure(bg=ThemeManager.single_color(self.fg_color, self.appearance_mode))
-
-            self.text_label.configure(text=self.text)  # set text
+                    self.text_label.configure(bg=ThemeManager.single_color(self.fg_color, self._appearance_mode))
 
         else:
             # delete text_label if no text given
@@ -183,9 +181,9 @@ class CTkButton(CTkBaseClass):
             if no_color_updates is False:
                 # set image_label bg color (background color of label)
                 if self.fg_color is None:
-                    self.image_label.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                    self.image_label.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
                 else:
-                    self.image_label.configure(bg=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                    self.image_label.configure(bg=ThemeManager.single_color(self.fg_color, self._appearance_mode))
 
             self.image_label.configure(image=self.image)  # set image
 
@@ -237,102 +235,91 @@ class CTkButton(CTkBaseClass):
                                      padx=max(self.apply_widget_scaling(self.corner_radius), self.apply_widget_scaling(self.border_width)),
                                      pady=(self.apply_widget_scaling(self.border_width), 2))
 
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
-
+    def configure(self, require_redraw=False, **kwargs):
         if "text" in kwargs:
-            self.set_text(kwargs["text"])
-            del kwargs["text"]
+            self.text = kwargs.pop("text")
+            if self.text_label is None:
+                require_redraw = True  # text_label will be created in .draw()
+            else:
+                self.text_label.configure(text=self.text)
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            if self.text_label is not None:
+                self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
         if "state" in kwargs:
-            self.state = kwargs["state"]
+            self.state = kwargs.pop("state")
             self.set_cursor()
             require_redraw = True
-            del kwargs["state"]
 
         if "image" in kwargs:
-            self.set_image(kwargs["image"])
-            del kwargs["image"]
+            self.image = kwargs.pop("image")
+            require_redraw = True
+
+        if "corner_radius" in kwargs:
+            self.corner_radius = kwargs.pop("corner_radius")
+            require_redraw = True
 
         if "compound" in kwargs:
-            self.compound = kwargs["compound"]
+            self.compound = kwargs.pop("compound")
             require_redraw = True
-            del kwargs["compound"]
 
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
-            del kwargs["fg_color"]
 
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
-            del kwargs["border_color"]
-
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
 
         if "hover_color" in kwargs:
-            self.hover_color = kwargs["hover_color"]
+            self.hover_color = kwargs.pop("hover_color")
             require_redraw = True
-            del kwargs["hover_color"]
 
         if "text_color" in kwargs:
-            self.text_color = kwargs["text_color"]
+            self.text_color = kwargs.pop("text_color")
             require_redraw = True
-            del kwargs["text_color"]
 
         if "command" in kwargs:
-            self.function = kwargs["command"]
-            del kwargs["command"]
+            self.command = kwargs.pop("command")
 
         if "textvariable" in kwargs:
-            self.textvariable = kwargs["textvariable"]
+            self.textvariable = kwargs.pop("textvariable")
             if self.text_label is not None:
                 self.text_label.configure(textvariable=self.textvariable)
-            del kwargs["textvariable"]
 
         if "width" in kwargs:
-            self.set_dimensions(width=kwargs["width"])
-            del kwargs["width"]
+            self.set_dimensions(width=kwargs.pop("width"))
 
         if "height" in kwargs:
-            self.set_dimensions(height=kwargs["height"])
-            del kwargs["height"]
+            self.set_dimensions(height=kwargs.pop("height"))
 
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)
 
     def set_cursor(self):
         if Settings.cursor_manipulation_enabled:
             if self.state == tkinter.DISABLED:
-                if sys.platform == "darwin" and self.function is not None and Settings.cursor_manipulation_enabled:
+                if sys.platform == "darwin" and self.command is not None and Settings.cursor_manipulation_enabled:
                     self.configure(cursor="arrow")
-                elif sys.platform.startswith("win") and self.function is not None and Settings.cursor_manipulation_enabled:
+                elif sys.platform.startswith("win") and self.command is not None and Settings.cursor_manipulation_enabled:
                     self.configure(cursor="arrow")
 
             elif self.state == tkinter.NORMAL:
-                if sys.platform == "darwin" and self.function is not None and Settings.cursor_manipulation_enabled:
+                if sys.platform == "darwin" and self.command is not None and Settings.cursor_manipulation_enabled:
                     self.configure(cursor="pointinghand")
-                elif sys.platform.startswith("win") and self.function is not None and Settings.cursor_manipulation_enabled:
+                elif sys.platform.startswith("win") and self.command is not None and Settings.cursor_manipulation_enabled:
                     self.configure(cursor="hand2")
 
-    def set_text(self, text):
-        self.text = text
-        self.draw()
-
     def set_image(self, image):
-        self.image = image
-        self.draw()
+        """ will be removed in next major """
+        self.configure(image=image)
 
-    def on_enter(self, event=0):
+    def set_text(self, text):
+        """ will be removed in next major """
+        self.configure(text=text)
+
+    def on_enter(self, event=None):
         if self.hover is True and self.state == tkinter.NORMAL:
             if self.hover_color is None:
                 inner_parts_color = self.fg_color
@@ -341,18 +328,18 @@ class CTkButton(CTkBaseClass):
 
             # set color of inner button parts to hover color
             self.canvas.itemconfig("inner_parts",
-                                   outline=ThemeManager.single_color(inner_parts_color, self.appearance_mode),
-                                   fill=ThemeManager.single_color(inner_parts_color, self.appearance_mode))
+                                   outline=ThemeManager.single_color(inner_parts_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(inner_parts_color, self._appearance_mode))
 
             # set text_label bg color to button hover color
             if self.text_label is not None:
-                self.text_label.configure(bg=ThemeManager.single_color(inner_parts_color, self.appearance_mode))
+                self.text_label.configure(bg=ThemeManager.single_color(inner_parts_color, self._appearance_mode))
 
             # set image_label bg color to button hover color
             if self.image_label is not None:
-                self.image_label.configure(bg=ThemeManager.single_color(inner_parts_color, self.appearance_mode))
+                self.image_label.configure(bg=ThemeManager.single_color(inner_parts_color, self._appearance_mode))
 
-    def on_leave(self, event=0):
+    def on_leave(self, event=None):
         self.click_animation_running = False
 
         if self.hover is True:
@@ -363,28 +350,28 @@ class CTkButton(CTkBaseClass):
 
             # set color of inner button parts
             self.canvas.itemconfig("inner_parts",
-                                   outline=ThemeManager.single_color(inner_parts_color, self.appearance_mode),
-                                   fill=ThemeManager.single_color(inner_parts_color, self.appearance_mode))
+                                   outline=ThemeManager.single_color(inner_parts_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(inner_parts_color, self._appearance_mode))
 
             # set text_label bg color (label color)
             if self.text_label is not None:
-                self.text_label.configure(bg=ThemeManager.single_color(inner_parts_color, self.appearance_mode))
+                self.text_label.configure(bg=ThemeManager.single_color(inner_parts_color, self._appearance_mode))
 
             # set image_label bg color (image bg color)
             if self.image_label is not None:
-                self.image_label.configure(bg=ThemeManager.single_color(inner_parts_color, self.appearance_mode))
+                self.image_label.configure(bg=ThemeManager.single_color(inner_parts_color, self._appearance_mode))
 
     def click_animation(self):
         if self.click_animation_running:
             self.on_enter()
 
-    def clicked(self, event=0):
-        if self.function is not None:
-            if self.state is not tkinter.DISABLED:
+    def clicked(self, event=None):
+        if self.command is not None:
+            if self.state != tkinter.DISABLED:
 
                 # click animation: change color with .on_leave() and back to normal after 100ms with click_animation()
                 self.on_leave()
                 self.click_animation_running = True
                 self.after(100, self.click_animation)
 
-                self.function()
+                self.command()

customtkinter/widgets/ctk_canvas.py

@@ -8,7 +8,6 @@ class CTkCanvas(tkinter.Canvas):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-
         self.aa_circle_canvas_ids = set()
 
     @classmethod
@@ -21,7 +20,7 @@ class CTkCanvas(tkinter.Canvas):
 
         radius_to_char_fine_windows_10 = {19: 'A', 18: 'A', 17: 'B', 16: 'B', 15: 'B', 14: 'B', 13: 'C', 12: 'C',
                                           11: 'C', 10: 'C',
-                                          9: 'D', 8: 'D', 7: 'D', 6: 'F', 5: 'D', 4: 'G', 3: 'G', 2: 'H', 1: 'H',
+                                          9: 'D', 8: 'D', 7: 'D', 6: 'C', 5: 'D', 4: 'G', 3: 'G', 2: 'H', 1: 'H',
                                           0: 'A'}
 
         radius_to_char_fine_windows_11 = {19: 'A', 18: 'A', 17: 'B', 16: 'B', 15: 'B', 14: 'B', 13: 'C', 12: 'C',
@@ -29,12 +28,19 @@ class CTkCanvas(tkinter.Canvas):
                                           9: 'E', 8: 'F', 7: 'C', 6: 'I', 5: 'E', 4: 'G', 3: 'P', 2: 'R', 1: 'R',
                                           0: 'A'}
 
+        radius_to_char_fine_linux = {19: 'A', 18: 'A', 17: 'B', 16: 'B', 15: 'B', 14: 'B', 13: 'F', 12: 'C',
+                                          11: 'F', 10: 'C',
+                                          9: 'D', 8: 'G', 7: 'D', 6: 'F', 5: 'D', 4: 'G', 3: 'M', 2: 'H', 1: 'H',
+                                          0: 'A'}
+
         if sys.platform.startswith("win"):
             if sys.getwindowsversion().build > 20000:  # Windows 11
                 cls.radius_to_char_fine = radius_to_char_fine_windows_11
             else:  # < Windows 11
                 cls.radius_to_char_fine = radius_to_char_fine_windows_10
-        else:  # macOS and Linux
+        elif sys.platform.startswith("linux"):  # Optimized on Kali Linux
+            cls.radius_to_char_fine = radius_to_char_fine_linux
+        else:
             cls.radius_to_char_fine = radius_to_char_fine_windows_10
 
     def get_char_from_radius(self, radius: int) -> str:

customtkinter/widgets/ctk_checkbox.py

@@ -1,5 +1,6 @@
 import tkinter
 import sys
+from typing import Union
 
 from .ctk_canvas import CTkCanvas
 from ..theme_manager import ThemeManager
@@ -34,7 +35,7 @@ class CTkCheckBox(CTkBaseClass):
                  textvariable=None,
                  **kwargs):
 
-        # transfer basic functionality (bg_color, size, appearance_mode, scaling) to CTkBaseClass
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
         super().__init__(*args, bg_color=bg_color, width=width, height=height, **kwargs)
 
         # color
@@ -49,21 +50,22 @@ class CTkCheckBox(CTkBaseClass):
 
         # text
         self.text = text
-        self.text_label = None
+        self.text_label: Union[tkinter.Label, None] = None
         self.text_color = ThemeManager.theme["color"]["text"] if text_color == "default_theme" else text_color
         self.text_color_disabled = ThemeManager.theme["color"]["text_disabled"] if text_color_disabled == "default_theme" else text_color_disabled
         self.text_font = (ThemeManager.theme["text"]["font"], ThemeManager.theme["text"]["size"]) if text_font == "default_theme" else text_font
 
         # callback and hover functionality
-        self.function = command
+        self.command = command
         self.state = state
         self.hover = hover
         self.check_state = False
+
         self.onvalue = onvalue
         self.offvalue = offvalue
         self.variable: tkinter.Variable = variable
         self.variable_callback_blocked = False
-        self.textvariable = textvariable
+        self.textvariable: tkinter.Variable = textvariable
         self.variable_callback_name = None
 
         # configure grid system (1x3)
@@ -74,34 +76,41 @@ class CTkCheckBox(CTkBaseClass):
 
         self.bg_canvas = CTkCanvas(master=self,
                                    highlightthickness=0,
-                                   width=self.apply_widget_scaling(self.desired_width),
-                                   height=self.apply_widget_scaling(self.desired_height))
+                                   width=self.apply_widget_scaling(self._desired_width),
+                                   height=self.apply_widget_scaling(self._desired_height))
         self.bg_canvas.grid(row=0, column=0, padx=0, pady=0, columnspan=3, rowspan=1, sticky="nswe")
 
         self.canvas = CTkCanvas(master=self,
                                 highlightthickness=0,
-                                width=self.apply_widget_scaling(self.desired_width),
-                                height=self.apply_widget_scaling(self.desired_height))
+                                width=self.apply_widget_scaling(self._desired_width),
+                                height=self.apply_widget_scaling(self._desired_height))
         self.canvas.grid(row=0, column=0, padx=0, pady=0, columnspan=1, rowspan=1)
         self.draw_engine = DrawEngine(self.canvas)
 
-        if self.hover is True:
-            self.canvas.bind("<Enter>", self.on_enter)
-            self.canvas.bind("<Leave>", self.on_leave)
-
-        self.canvas.bind("<Button-1>", self.toggle)
+        self.canvas.bind("<Enter>", self.on_enter)
+        self.canvas.bind("<Leave>", self.on_leave)
         self.canvas.bind("<Button-1>", self.toggle)
 
-        # set select state according to variable
-        if self.variable is not None:
+        self.text_label = tkinter.Label(master=self,
+                                        bd=0,
+                                        text=self.text,
+                                        justify=tkinter.LEFT,
+                                        font=self.apply_font_scaling(self.text_font),
+                                        textvariable=self.textvariable)
+        self.text_label.grid(row=0, column=2, padx=0, pady=0, sticky="w")
+        self.text_label["anchor"] = "w"
+
+        self.text_label.bind("<Enter>", self.on_enter)
+        self.text_label.bind("<Leave>", self.on_leave)
+        self.text_label.bind("<Button-1>", self.toggle)
+
+        # register variable callback and set state according to variable
+        if self.variable is not None and self.variable != "":
             self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
-            if self.variable.get() == self.onvalue:
-                self.select(from_variable_callback=True)
-            elif self.variable.get() == self.offvalue:
-                self.deselect(from_variable_callback=True)
+            self.check_state = True if variable.get() == self.onvalue else False
 
-        self.set_cursor()
         self.draw()  # initial draw
+        self.set_cursor()
 
     def set_scaling(self, *args, **kwargs):
         super().set_scaling(*args, **kwargs)
@@ -109,8 +118,9 @@ class CTkCheckBox(CTkBaseClass):
         self.grid_columnconfigure(1, weight=0, minsize=self.apply_widget_scaling(6))
         self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
-        self.bg_canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.delete("checkmark")
+        self.bg_canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def destroy(self):
@@ -120,176 +130,151 @@ class CTkCheckBox(CTkBaseClass):
         super().destroy()
 
     def draw(self, no_color_updates=False):
-        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self.current_width),
-                                                                             self.apply_widget_scaling(self.current_height),
+        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self._current_width),
+                                                                             self.apply_widget_scaling(self._current_height),
                                                                              self.apply_widget_scaling(self.corner_radius),
                                                                              self.apply_widget_scaling(self.border_width))
 
         if self.check_state is True:
-            self.draw_engine.draw_checkmark(self.apply_widget_scaling(self.current_width),
-                                            self.apply_widget_scaling(self.current_height),
-                                            self.apply_widget_scaling(self.current_height * 0.58))
+            self.draw_engine.draw_checkmark(self.apply_widget_scaling(self._current_width),
+                                            self.apply_widget_scaling(self._current_height),
+                                            self.apply_widget_scaling(self._current_height * 0.58))
         else:
             self.canvas.delete("checkmark")
 
-        self.bg_canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
-        self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+        self.bg_canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+        self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
         if self.check_state is True:
             self.canvas.itemconfig("inner_parts",
-                                   outline=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                   fill=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                                   outline=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.fg_color, self._appearance_mode))
             self.canvas.itemconfig("border_parts",
-                                   outline=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                   fill=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                                   outline=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.fg_color, self._appearance_mode))
 
             if "create_line" in self.canvas.gettags("checkmark"):
-                self.canvas.itemconfig("checkmark", fill=ThemeManager.single_color(self.checkmark_color, self.appearance_mode))
+                self.canvas.itemconfig("checkmark", fill=ThemeManager.single_color(self.checkmark_color, self._appearance_mode))
             else:
-                self.canvas.itemconfig("checkmark", fill=ThemeManager.single_color(self.checkmark_color, self.appearance_mode))
+                self.canvas.itemconfig("checkmark", fill=ThemeManager.single_color(self.checkmark_color, self._appearance_mode))
         else:
             self.canvas.itemconfig("inner_parts",
-                                   outline=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                   fill=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                                   outline=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.bg_color, self._appearance_mode))
             self.canvas.itemconfig("border_parts",
-                                   outline=ThemeManager.single_color(self.border_color, self.appearance_mode),
-                                   fill=ThemeManager.single_color(self.border_color, self.appearance_mode))
-
-        if self.text_label is None:
-            self.text_label = tkinter.Label(master=self,
-                                            bd=0,
-                                            text=self.text,
-                                            justify=tkinter.LEFT,
-                                            font=self.apply_font_scaling(self.text_font))
-            self.text_label.grid(row=0, column=2, padx=0, pady=0, sticky="w")
-            self.text_label["anchor"] = "w"
+                                   outline=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.border_color, self._appearance_mode))
 
         if self.state == tkinter.DISABLED:
-            self.text_label.configure(fg=(ThemeManager.single_color(self.text_color_disabled, self.appearance_mode)))
+            self.text_label.configure(fg=(ThemeManager.single_color(self.text_color_disabled, self._appearance_mode)))
         else:
-            self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self.appearance_mode))
-        self.text_label.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+            self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
 
-        self.set_text(self.text)
-
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw()
+        self.text_label.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
+    def configure(self, require_redraw=False, **kwargs):
         if "text" in kwargs:
-            self.set_text(kwargs["text"])
-            del kwargs["text"]
+            self.text = kwargs.pop("text")
+            self.text_label.configure(text=self.text)
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            if self.text_label is not None:
+                self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
         if "state" in kwargs:
-            self.state = kwargs["state"]
+            self.state = kwargs.pop("state")
             self.set_cursor()
             require_redraw = True
-            del kwargs["state"]
 
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
-            del kwargs["fg_color"]
-
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
 
         if "hover_color" in kwargs:
-            self.hover_color = kwargs["hover_color"]
+            self.hover_color = kwargs.pop("hover_color")
             require_redraw = True
-            del kwargs["hover_color"]
 
         if "text_color" in kwargs:
-            self.text_color = kwargs["text_color"]
+            self.text_color = kwargs.pop("text_color")
             require_redraw = True
-            del kwargs["text_color"]
 
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
-            del kwargs["border_color"]
 
         if "command" in kwargs:
-            self.function = kwargs["command"]
-            del kwargs["command"]
+            self.command = kwargs.pop("command")
+
+        if "textvariable" in kwargs:
+            self.textvariable = kwargs.pop("textvariable")
+            self.text_label.configure(textvariable=self.textvariable)
 
         if "variable" in kwargs:
-            if self.variable is not None:
-                self.variable.trace_remove("write", self.variable_callback_name)
+            if self.variable is not None and self.variable != "":
+                self.variable.trace_remove("write", self.variable_callback_name)  # remove old variable callback
 
-            self.variable = kwargs["variable"]
+            self.variable = kwargs.pop("variable")
 
             if self.variable is not None and self.variable != "":
                 self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
-                if self.variable.get() == self.onvalue:
-                    self.select(from_variable_callback=True)
-                elif self.variable.get() == self.offvalue:
-                    self.deselect(from_variable_callback=True)
-            else:
-                self.variable = None
+                self.check_state = True if self.variable.get() == self.onvalue else False
+                require_redraw = True
 
-            del kwargs["variable"]
-
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)
 
     def set_cursor(self):
         if Settings.cursor_manipulation_enabled:
             if self.state == tkinter.DISABLED:
                 if sys.platform == "darwin" and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="arrow")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="arrow")
                 elif sys.platform.startswith("win") and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="arrow")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="arrow")
 
             elif self.state == tkinter.NORMAL:
                 if sys.platform == "darwin" and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="pointinghand")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="pointinghand")
                 elif sys.platform.startswith("win") and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="hand2")
-
-    def set_text(self, text):
-        self.text = text
-        if self.text_label is not None:
-            self.text_label.configure(text=self.text)
-        else:
-            sys.stderr.write("ERROR (CTkButton): Cant change text because checkbox has no text.")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="hand2")
 
     def on_enter(self, event=0):
         if self.hover is True and self.state == tkinter.NORMAL:
             if self.check_state is True:
                 self.canvas.itemconfig("inner_parts",
-                                       fill=ThemeManager.single_color(self.hover_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.hover_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.hover_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.hover_color, self._appearance_mode))
                 self.canvas.itemconfig("border_parts",
-                                       fill=ThemeManager.single_color(self.hover_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.hover_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.hover_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.hover_color, self._appearance_mode))
             else:
                 self.canvas.itemconfig("inner_parts",
-                                       fill=ThemeManager.single_color(self.hover_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.hover_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.hover_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.hover_color, self._appearance_mode))
 
     def on_leave(self, event=0):
         if self.hover is True:
             if self.check_state is True:
                 self.canvas.itemconfig("inner_parts",
-                                       fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
                 self.canvas.itemconfig("border_parts",
-                                       fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
             else:
                 self.canvas.itemconfig("inner_parts",
-                                       fill=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.bg_color, self._appearance_mode))
                 self.canvas.itemconfig("border_parts",
-                                       fill=ThemeManager.single_color(self.border_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.border_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.border_color, self._appearance_mode))
 
     def variable_callback(self, var_name, index, mode):
         if not self.variable_callback_blocked:
@@ -307,14 +292,14 @@ class CTkCheckBox(CTkBaseClass):
                 self.check_state = True
                 self.draw()
 
-            if self.function is not None:
-                self.function()
-
             if self.variable is not None:
                 self.variable_callback_blocked = True
                 self.variable.set(self.onvalue if self.check_state is True else self.offvalue)
                 self.variable_callback_blocked = False
 
+            if self.command is not None:
+                self.command()
+
     def select(self, from_variable_callback=False):
         self.check_state = True
         self.draw()
@@ -324,12 +309,6 @@ class CTkCheckBox(CTkBaseClass):
             self.variable.set(self.onvalue)
             self.variable_callback_blocked = False
 
-        if self.function is not None:
-            try:
-                self.function()
-            except:
-                pass
-
     def deselect(self, from_variable_callback=False):
         self.check_state = False
         self.draw()
@@ -339,11 +318,5 @@ class CTkCheckBox(CTkBaseClass):
             self.variable.set(self.offvalue)
             self.variable_callback_blocked = False
 
-        if self.function is not None:
-            try:
-                self.function()
-            except:
-                pass
-
     def get(self):
         return self.onvalue if self.check_state is True else self.offvalue

customtkinter/widgets/ctk_combobox.py

@@ -0,0 +1,297 @@
+import tkinter
+import sys
+
+from .dropdown_menu import DropdownMenu
+from .ctk_canvas import CTkCanvas
+from ..theme_manager import ThemeManager
+from ..settings import Settings
+from ..draw_engine import DrawEngine
+from .widget_base_class import CTkBaseClass
+
+
+class CTkComboBox(CTkBaseClass):
+    def __init__(self, *args,
+                 bg_color=None,
+                 fg_color="default_theme",
+                 border_color="default_theme",
+                 button_color="default_theme",
+                 button_hover_color="default_theme",
+                 dropdown_color="default_theme",
+                 dropdown_hover_color="default_theme",
+                 dropdown_text_color="default_theme",
+                 variable=None,
+                 values=None,
+                 command=None,
+                 width=140,
+                 height=28,
+                 corner_radius="default_theme",
+                 border_width="default_theme",
+                 text_font="default_theme",
+                 dropdown_text_font="default_theme",
+                 text_color="default_theme",
+                 text_color_disabled="default_theme",
+                 hover=True,
+                 state=tkinter.NORMAL,
+                 **kwargs):
+
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
+        super().__init__(*args, bg_color=bg_color, width=width, height=height, **kwargs)
+
+        # color variables
+        self.fg_color = ThemeManager.theme["color"]["entry"] if fg_color == "default_theme" else fg_color
+        self.border_color = ThemeManager.theme["color"]["combobox_border"] if border_color == "default_theme" else border_color
+        self.button_color = ThemeManager.theme["color"]["combobox_border"] if button_color == "default_theme" else button_color
+        self.button_hover_color = ThemeManager.theme["color"]["combobox_button_hover"] if button_hover_color == "default_theme" else button_hover_color
+
+        # shape
+        self.corner_radius = ThemeManager.theme["shape"]["button_corner_radius"] if corner_radius == "default_theme" else corner_radius
+        self.border_width = ThemeManager.theme["shape"]["entry_border_width"] if border_width == "default_theme" else border_width
+
+        # text and font
+        self.text_color = ThemeManager.theme["color"]["text"] if text_color == "default_theme" else text_color
+        self.text_color_disabled = ThemeManager.theme["color"]["text_button_disabled"] if text_color_disabled == "default_theme" else text_color_disabled
+        self.text_font = (ThemeManager.theme["text"]["font"], ThemeManager.theme["text"]["size"]) if text_font == "default_theme" else text_font
+
+        # callback and hover functionality
+        self.command = command
+        self.textvariable = variable
+        self.state = state
+        self.hover = hover
+
+        if values is None:
+            self.values = ["CTkComboBox"]
+        else:
+            self.values = values
+
+        self.dropdown_menu = DropdownMenu(master=self,
+                                          values=self.values,
+                                          command=self.dropdown_callback,
+                                          fg_color=dropdown_color,
+                                          hover_color=dropdown_hover_color,
+                                          text_color=dropdown_text_color,
+                                          text_font=dropdown_text_font)
+
+        # configure grid system (1x1)
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=1)
+
+        self.canvas = CTkCanvas(master=self,
+                                highlightthickness=0,
+                                width=self.apply_widget_scaling(self._desired_width),
+                                height=self.apply_widget_scaling(self._desired_height))
+        self.canvas.grid(row=0, column=0, rowspan=1, columnspan=1, sticky="nsew")
+        self.draw_engine = DrawEngine(self.canvas)
+
+        self.entry = tkinter.Entry(master=self,
+                                   state=self.state,
+                                   width=1,
+                                   bd=0,
+                                   highlightthickness=0,
+                                   font=self.apply_font_scaling(self.text_font))
+        left_section_width = self._current_width - self._current_height
+        self.entry.grid(row=0, column=0, rowspan=1, columnspan=1, sticky="ew",
+                        padx=(max(self.apply_widget_scaling(self.corner_radius), self.apply_widget_scaling(3)),
+                              max(self.apply_widget_scaling(self._current_width - left_section_width + 3), self.apply_widget_scaling(3))))
+
+        # insert default value
+        if len(self.values) > 0:
+            self.entry.insert(0, self.values[0])
+        else:
+            self.entry.insert(0, "CTkComboBox")
+
+        self.draw()  # initial draw
+
+        # event bindings
+        self.canvas.tag_bind("right_parts", "<Enter>", self.on_enter)
+        self.canvas.tag_bind("dropdown_arrow", "<Enter>", self.on_enter)
+        self.canvas.tag_bind("right_parts", "<Leave>", self.on_leave)
+        self.canvas.tag_bind("dropdown_arrow", "<Leave>", self.on_leave)
+        self.canvas.tag_bind("right_parts", "<Button-1>", self.clicked)
+        self.canvas.tag_bind("dropdown_arrow", "<Button-1>", self.clicked)
+        self.bind('<Configure>', self.update_dimensions_event)
+
+        if self.textvariable is not None:
+            self.entry.configure(textvariable=self.textvariable)
+
+    def set_scaling(self, *args, **kwargs):
+        super().set_scaling(*args, **kwargs)
+
+        # change entry font size and grid padding
+        left_section_width = self._current_width - self._current_height
+        self.entry.configure(font=self.apply_font_scaling(self.text_font))
+        self.entry.grid(row=0, column=0, rowspan=1, columnspan=1, sticky="ew",
+                        padx=(max(self.apply_widget_scaling(self.corner_radius), self.apply_widget_scaling(3)),
+                              max(self.apply_widget_scaling(self._current_width - left_section_width + 3), self.apply_widget_scaling(3))))
+
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
+        self.draw()
+
+    def set_dimensions(self, width: int = None, height: int = None):
+        super().set_dimensions(width, height)
+
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
+        self.draw()
+
+    def draw(self, no_color_updates=False):
+        left_section_width = self._current_width - self._current_height
+        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border_vertical_split(self.apply_widget_scaling(self._current_width),
+                                                                                            self.apply_widget_scaling(self._current_height),
+                                                                                            self.apply_widget_scaling(self.corner_radius),
+                                                                                            self.apply_widget_scaling(self.border_width),
+                                                                                            self.apply_widget_scaling(left_section_width))
+
+        requires_recoloring_2 = self.draw_engine.draw_dropdown_arrow(self.apply_widget_scaling(self._current_width - (self._current_height / 2)),
+                                                                     self.apply_widget_scaling(self._current_height / 2),
+                                                                     self.apply_widget_scaling(self._current_height / 3))
+
+        if no_color_updates is False or requires_recoloring or requires_recoloring_2:
+
+            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+
+            self.canvas.itemconfig("inner_parts_left",
+                                   outline=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.fg_color, self._appearance_mode))
+            self.canvas.itemconfig("border_parts_left",
+                                   outline=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.border_color, self._appearance_mode))
+            self.canvas.itemconfig("inner_parts_right",
+                                   outline=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.border_color, self._appearance_mode))
+            self.canvas.itemconfig("border_parts_right",
+                                   outline=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.border_color, self._appearance_mode))
+
+            self.entry.configure(bg=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                 fg=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                                 disabledforeground=ThemeManager.single_color(self.text_color_disabled, self._appearance_mode),
+                                 disabledbackground=ThemeManager.single_color(self.fg_color, self._appearance_mode))
+
+            if self.state == tkinter.DISABLED:
+                self.canvas.itemconfig("dropdown_arrow",
+                                       fill=ThemeManager.single_color(self.text_color_disabled, self._appearance_mode))
+            else:
+                self.canvas.itemconfig("dropdown_arrow",
+                                       fill=ThemeManager.single_color(self.text_color, self._appearance_mode))
+
+    def open_dropdown_menu(self):
+        self.dropdown_menu.open(self.winfo_rootx(),
+                                self.winfo_rooty() + self.apply_widget_scaling(self._current_height + 0))
+
+    def configure(self, require_redraw=False, **kwargs):
+        if "state" in kwargs:
+            self.state = kwargs.pop("state")
+            self.entry.configure(state=self.state)
+            require_redraw = True
+
+        if "fg_color" in kwargs:
+            self.fg_color = kwargs.pop("fg_color")
+            require_redraw = True
+
+        if "button_color" in kwargs:
+            self.button_color = kwargs.pop("button_color")
+            require_redraw = True
+
+        if "button_hover_color" in kwargs:
+            self.button_hover_color = kwargs.pop("button_hover_color")
+            require_redraw = True
+
+        if "text_color" in kwargs:
+            self.text_color = kwargs.pop("text_color")
+            require_redraw = True
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.entry.configure(font=self.apply_font_scaling(self.text_font))
+
+        if "command" in kwargs:
+            self.command = kwargs.pop("command")
+
+        if "variable" in kwargs:
+            self.textvariable = kwargs.pop("variable")
+            self.entry.configure(textvariable=self.textvariable)
+
+        if "width" in kwargs:
+            self.set_dimensions(width=kwargs.pop("width"))
+
+        if "height" in kwargs:
+            self.set_dimensions(height=kwargs.pop("height"))
+
+        if "values" in kwargs:
+            self.values = kwargs.pop("values")
+            self.dropdown_menu.configure(values=self.values)
+
+        if "dropdown_color" in kwargs:
+            self.dropdown_menu.configure(fg_color=kwargs.pop("dropdown_color"))
+
+        if "dropdown_hover_color" in kwargs:
+            self.dropdown_menu.configure(hover_color=kwargs.pop("dropdown_hover_color"))
+
+        if "dropdown_text_color" in kwargs:
+            self.dropdown_menu.configure(text_color=kwargs.pop("dropdown_text_color"))
+
+        if "dropdown_text_font" in kwargs:
+            self.dropdown_menu.configure(text_font=kwargs.pop("dropdown_text_font"))
+
+        super().configure(require_redraw=require_redraw, **kwargs)
+
+    def on_enter(self, event=0):
+        if self.hover is True and self.state == tkinter.NORMAL and len(self.values) > 0:
+            if sys.platform == "darwin" and len(self.values) > 0 and Settings.cursor_manipulation_enabled:
+                self.canvas.configure(cursor="pointinghand")
+            elif sys.platform.startswith("win") and len(self.values) > 0 and Settings.cursor_manipulation_enabled:
+                self.canvas.configure(cursor="hand2")
+
+            # set color of inner button parts to hover color
+            self.canvas.itemconfig("inner_parts_right",
+                                   outline=ThemeManager.single_color(self.button_hover_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.button_hover_color, self._appearance_mode))
+            self.canvas.itemconfig("border_parts_right",
+                                   outline=ThemeManager.single_color(self.button_hover_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.button_hover_color, self._appearance_mode))
+
+    def on_leave(self, event=0):
+        if self.hover is True:
+            if sys.platform == "darwin" and len(self.values) > 0 and Settings.cursor_manipulation_enabled:
+                self.canvas.configure(cursor="arrow")
+            elif sys.platform.startswith("win") and len(self.values) > 0 and Settings.cursor_manipulation_enabled:
+                self.canvas.configure(cursor="arrow")
+
+            # set color of inner button parts
+            self.canvas.itemconfig("inner_parts_right",
+                                   outline=ThemeManager.single_color(self.button_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.button_color, self._appearance_mode))
+            self.canvas.itemconfig("border_parts_right",
+                                   outline=ThemeManager.single_color(self.button_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.button_color, self._appearance_mode))
+
+    def dropdown_callback(self, value: str):
+        if self.state == "readonly":
+            self.entry.configure(state="normal")
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, value)
+            self.entry.configure(state="readonly")
+        else:
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, value)
+
+        if self.command is not None:
+            self.command(value)
+
+    def set(self, value: str):
+        if self.state == "readonly":
+            self.entry.configure(state="normal")
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, value)
+            self.entry.configure(state="readonly")
+        else:
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, value)
+
+    def get(self) -> str:
+        return self.entry.get()
+
+    def clicked(self, event=0):
+        if self.state is not tkinter.DISABLED and len(self.values) > 0:
+            self.open_dropdown_menu()

customtkinter/widgets/ctk_entry.py

@@ -17,41 +17,48 @@ class CTkEntry(CTkBaseClass):
                  corner_radius="default_theme",
                  border_width="default_theme",
                  border_color="default_theme",
-                 width=120,
-                 height=30,
+                 width=140,
+                 height=28,
                  state=tkinter.NORMAL,
+                 textvariable: tkinter.Variable = None,
                  **kwargs):
 
-        # transfer basic functionality (bg_color, size, appearance_mode, scaling) to CTkBaseClass
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
         if "master" in kwargs:
-            super().__init__(*args, bg_color=bg_color, width=width, height=height, master=kwargs["master"])
-            del kwargs["master"]
+            super().__init__(*args, bg_color=bg_color, width=width, height=height, master=kwargs.pop("master"))
         else:
             super().__init__(*args, bg_color=bg_color, width=width, height=height)
 
+        # configure grid system (1x1)
         self.grid_rowconfigure(0, weight=1)
         self.grid_columnconfigure(0, weight=1)
 
+        # color
         self.fg_color = ThemeManager.theme["color"]["entry"] if fg_color == "default_theme" else fg_color
         self.text_color = ThemeManager.theme["color"]["text"] if text_color == "default_theme" else text_color
         self.placeholder_text_color = ThemeManager.theme["color"]["entry_placeholder_text"] if placeholder_text_color == "default_theme" else placeholder_text_color
         self.text_font = (ThemeManager.theme["text"]["font"], ThemeManager.theme["text"]["size"]) if text_font == "default_theme" else text_font
         self.border_color = ThemeManager.theme["color"]["entry_border"] if border_color == "default_theme" else border_color
 
+        # shape
+        self.corner_radius = ThemeManager.theme["shape"]["button_corner_radius"] if corner_radius == "default_theme" else corner_radius
+        self.border_width = ThemeManager.theme["shape"]["entry_border_width"] if border_width == "default_theme" else border_width
+
+        # placeholder text
         self.placeholder_text = placeholder_text
         self.placeholder_text_active = False
         self.pre_placeholder_arguments = {}  # some set arguments of the entry will be changed for placeholder and then set back
 
-        self.state = state
+        # textvariable
+        self.textvariable = textvariable
 
-        self.corner_radius = ThemeManager.theme["shape"]["button_corner_radius"] if corner_radius == "default_theme" else corner_radius
-        self.border_width = ThemeManager.theme["shape"]["entry_border_width"] if border_width == "default_theme" else border_width
+        self.state = state
 
         self.canvas = CTkCanvas(master=self,
                                 highlightthickness=0,
-                                width=self.apply_widget_scaling(self.current_width),
-                                height=self.apply_widget_scaling(self.current_height))
-        self.canvas.grid(column=0, row=0, sticky="we")
+                                width=self.apply_widget_scaling(self._current_width),
+                                height=self.apply_widget_scaling(self._current_height))
+        self.canvas.grid(column=0, row=0, sticky="nswe")
         self.draw_engine = DrawEngine(self.canvas)
 
         self.entry = tkinter.Entry(master=self,
@@ -60,16 +67,18 @@ class CTkEntry(CTkBaseClass):
                                    highlightthickness=0,
                                    font=self.apply_font_scaling(self.text_font),
                                    state=self.state,
+                                   textvariable=self.textvariable,
                                    **kwargs)
-        self.entry.grid(column=0, row=0, sticky="we",
-                        padx=self.apply_widget_scaling(self.corner_radius) if self.corner_radius >= 6 else self.apply_widget_scaling(6))
+        self.entry.grid(column=0, row=0, sticky="nswe",
+                        padx=self.apply_widget_scaling(self.corner_radius) if self.corner_radius >= 6 else self.apply_widget_scaling(6),
+                        pady=(self.apply_widget_scaling(self.border_width), self.apply_widget_scaling(self.border_width + 1)))
 
         super().bind('<Configure>', self.update_dimensions_event)
-        self.entry.bind('<FocusOut>', self.set_placeholder)
-        self.entry.bind('<FocusIn>', self.clear_placeholder)
+        self.entry.bind('<FocusOut>', self.entry_focus_out)
+        self.entry.bind('<FocusIn>', self.entry_focus_in)
 
+        self.activate_placeholder()
         self.draw()
-        self.set_placeholder()
 
     def set_scaling(self, *args, **kwargs):
         super().set_scaling( *args, **kwargs)
@@ -78,138 +87,156 @@ class CTkEntry(CTkBaseClass):
         self.entry.grid(column=0, row=0, sticky="we",
                         padx=self.apply_widget_scaling(self.corner_radius) if self.corner_radius >= 6 else self.apply_widget_scaling(6))
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def set_dimensions(self, width=None, height=None):
         super().set_dimensions(width, height)
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width),
-                              height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
-    def set_placeholder(self, event=None):
-        if self.placeholder_text is not None:
-            if not self.placeholder_text_active and self.entry.get() == "":
-                self.placeholder_text_active = True
-                self.pre_placeholder_arguments = {"show": self.entry.cget("show")}
-                self.entry.config(fg=ThemeManager.single_color(self.placeholder_text_color, self.appearance_mode), show="")
-                self.entry.delete(0, tkinter.END)
-                self.entry.insert(0, self.placeholder_text)
-
-    def clear_placeholder(self, event=None):
-        if self.placeholder_text_active:
-            self.placeholder_text_active = False
-            self.entry.config(fg=ThemeManager.single_color(self.text_color, self.appearance_mode))
-            self.entry.delete(0, tkinter.END)
-            for argument, value in self.pre_placeholder_arguments.items():
-                self.entry[argument] = value
-
     def draw(self, no_color_updates=False):
-        self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+        self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
-        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self.current_width),
-                                                                             self.apply_widget_scaling(self.current_height),
+        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self._current_width),
+                                                                             self.apply_widget_scaling(self._current_height),
                                                                              self.apply_widget_scaling(self.corner_radius),
                                                                              self.apply_widget_scaling(self.border_width))
 
         if requires_recoloring or no_color_updates is False:
-            if ThemeManager.single_color(self.fg_color, self.appearance_mode) is not None:
+            if ThemeManager.single_color(self.fg_color, self._appearance_mode) is not None:
                 self.canvas.itemconfig("inner_parts",
-                                       fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
-                self.entry.configure(bg=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                     disabledbackground=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                     highlightcolor=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                     fg=ThemeManager.single_color(self.text_color, self.appearance_mode),
-                                     disabledforeground=ThemeManager.single_color(self.text_color, self.appearance_mode),
-                                     insertbackground=ThemeManager.single_color(self.text_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
+                self.entry.configure(bg=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                     disabledbackground=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                     highlightcolor=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                     fg=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                                     disabledforeground=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                                     insertbackground=ThemeManager.single_color(self.text_color, self._appearance_mode))
             else:
                 self.canvas.itemconfig("inner_parts",
-                                       fill=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.bg_color, self.appearance_mode))
-                self.entry.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                     disabledbackground=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                     highlightcolor=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                     fg=ThemeManager.single_color(self.text_color, self.appearance_mode),
-                                     disabledforeground=ThemeManager.single_color(self.text_color, self.appearance_mode),
-                                     insertbackground=ThemeManager.single_color(self.text_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+                self.entry.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                     disabledbackground=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                     highlightcolor=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                     fg=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                                     disabledforeground=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                                     insertbackground=ThemeManager.single_color(self.text_color, self._appearance_mode))
 
             self.canvas.itemconfig("border_parts",
-                                   fill=ThemeManager.single_color(self.border_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.border_color, self.appearance_mode))
+                                   fill=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.border_color, self._appearance_mode))
 
             if self.placeholder_text_active:
-                self.entry.config(fg=ThemeManager.single_color(self.placeholder_text_color, self.appearance_mode))
+                self.entry.config(fg=ThemeManager.single_color(self.placeholder_text_color, self._appearance_mode))
 
     def bind(self, *args, **kwargs):
         self.entry.bind(*args, **kwargs)
 
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
-
+    def configure(self, require_redraw=False, **kwargs):
         if "state" in kwargs:
-            self.state = kwargs["state"]
+            self.state = kwargs.pop("state")
             self.entry.configure(state=self.state)
-            del kwargs["state"]
-
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
 
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
-            del kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
 
         if "text_color" in kwargs:
-            self.text_color = kwargs["text_color"]
-            del kwargs["text_color"]
+            self.text_color = kwargs.pop("text_color")
             require_redraw = True
 
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
-            del kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
 
         if "corner_radius" in kwargs:
-            self.corner_radius = kwargs["corner_radius"]
+            self.corner_radius = kwargs.pop("corner_radius")
 
-            if self.corner_radius * 2 > self.current_height:
-                self.corner_radius = self.current_height / 2
-            elif self.corner_radius * 2 > self.current_width:
-                self.corner_radius = self.current_width / 2
+            if self.corner_radius * 2 > self._current_height:
+                self.corner_radius = self._current_height / 2
+            elif self.corner_radius * 2 > self._current_width:
+                self.corner_radius = self._current_width / 2
 
             self.entry.grid(column=0, row=0, sticky="we", padx=self.apply_widget_scaling(self.corner_radius) if self.corner_radius >= 6 else self.apply_widget_scaling(6))
-            del kwargs["corner_radius"]
             require_redraw = True
 
         if "width" in kwargs:
-            self.set_dimensions(width=kwargs["width"])
-            del kwargs["width"]
+            self.set_dimensions(width=kwargs.pop("width"))
 
         if "height" in kwargs:
-            self.set_dimensions(height=kwargs["height"])
-            del kwargs["height"]
+            self.set_dimensions(height=kwargs.pop("height"))
 
         if "placeholder_text" in kwargs:
-            pass
+            self.placeholder_text = kwargs.pop("placeholder_text")
+            if self.placeholder_text_active:
+                self.entry.delete(0, tkinter.END)
+                self.entry.insert(0, self.placeholder_text)
+            else:
+                self.activate_placeholder()
 
-        self.entry.configure(*args, **kwargs)
+        if "placeholder_text_color" in kwargs:
+            self.placeholder_text_color = kwargs.pop("placeholder_text_color")
+            require_redraw = True
 
-        if require_redraw is True:
-            self.draw()
+        if "textvariable" in kwargs:
+            self.textvariable = kwargs.pop("textvariable")
+            self.entry.configure(textvariable=self.textvariable)
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.entry.configure(font=self.apply_font_scaling(self.text_font))
+
+        if "show" in kwargs:
+            if self.placeholder_text_active:
+                self.pre_placeholder_arguments["show"] = kwargs.pop("show")
+            else:
+                self.entry.configure(show=kwargs.pop("show"))
+
+        if "bg_color" in kwargs:
+            super().configure(bg_color=kwargs.pop("bg_color"), require_redraw=require_redraw)
+        else:
+            super().configure(require_redraw=require_redraw)
+
+        self.entry.configure(**kwargs)  # pass remaining kwargs to entry
+
+    def activate_placeholder(self):
+        if self.entry.get() == "" and self.placeholder_text is not None and (self.textvariable is None or self.textvariable == ""):
+            self.placeholder_text_active = True
+
+            self.pre_placeholder_arguments = {"show": self.entry.cget("show")}
+            self.entry.config(fg=ThemeManager.single_color(self.placeholder_text_color, self._appearance_mode), show="")
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, self.placeholder_text)
+
+    def deactivate_placeholder(self):
+        if self.placeholder_text_active:
+            self.placeholder_text_active = False
+
+            self.entry.config(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
+            self.entry.delete(0, tkinter.END)
+            for argument, value in self.pre_placeholder_arguments.items():
+                self.entry[argument] = value
+
+    def entry_focus_out(self, event=None):
+        self.activate_placeholder()
+
+    def entry_focus_in(self, event=None):
+        self.deactivate_placeholder()
 
     def delete(self, *args, **kwargs):
         self.entry.delete(*args, **kwargs)
-        self.set_placeholder()
+
+        if self.entry.get() == "":
+            self.activate_placeholder()
 
     def insert(self, *args, **kwargs):
-        self.clear_placeholder()
+        self.deactivate_placeholder()
+
         return self.entry.insert(*args, **kwargs)
 
     def get(self):
@@ -217,3 +244,9 @@ class CTkEntry(CTkBaseClass):
             return ""
         else:
             return self.entry.get()
+
+    def focus(self):
+        self.entry.focus()
+
+    def focus_force(self):
+        self.entry.focus_force()

customtkinter/widgets/ctk_frame.py

@@ -13,14 +13,16 @@ class CTkFrame(CTkBaseClass):
                  corner_radius="default_theme",
                  width=200,
                  height=200,
+                 overwrite_preferred_drawing_method: str = None,
                  **kwargs):
 
-        # transfer basic functionality (bg_color, size, appearance_mode, scaling) to CTkBaseClass
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
         super().__init__(*args, bg_color=bg_color, width=width, height=height, **kwargs)
 
         # color
         self.border_color = ThemeManager.theme["color"]["frame_border"] if border_color == "default_theme" else border_color
 
+        # determine fg_color of frame
         if fg_color == "default_theme":
             if isinstance(self.master, CTkFrame):
                 if self.master.fg_color == ThemeManager.theme["color"]["frame_low"]:
@@ -38,11 +40,12 @@ class CTkFrame(CTkBaseClass):
 
         self.canvas = CTkCanvas(master=self,
                                 highlightthickness=0,
-                                width=self.apply_widget_scaling(self.current_width),
-                                height=self.apply_widget_scaling(self.current_height))
+                                width=self.apply_widget_scaling(self._current_width),
+                                height=self.apply_widget_scaling(self._current_height))
         self.canvas.place(x=0, y=0, relwidth=1, relheight=1)
-        self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+        self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
         self.draw_engine = DrawEngine(self.canvas)
+        self._overwrite_preferred_drawing_method = overwrite_preferred_drawing_method
 
         self.bind('<Configure>', self.update_dimensions_event)
 
@@ -62,87 +65,68 @@ class CTkFrame(CTkBaseClass):
     def set_scaling(self, *args, **kwargs):
         super().set_scaling(*args, **kwargs)
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def set_dimensions(self, width=None, height=None):
         super().set_dimensions(width, height)
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width),
-                              height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def draw(self, no_color_updates=False):
 
-        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self.current_width),
-                                                                             self.apply_widget_scaling(self.current_height),
+        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self._current_width),
+                                                                             self.apply_widget_scaling(self._current_height),
                                                                              self.apply_widget_scaling(self.corner_radius),
-                                                                             self.apply_widget_scaling(self.border_width))
+                                                                             self.apply_widget_scaling(self.border_width),
+                                                                             overwrite_preferred_drawing_method=self._overwrite_preferred_drawing_method)
 
         if no_color_updates is False or requires_recoloring:
             if self.fg_color is None:
                 self.canvas.itemconfig("inner_parts",
-                                       fill=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.bg_color, self._appearance_mode))
             else:
                 self.canvas.itemconfig("inner_parts",
-                                       fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
 
             self.canvas.itemconfig("border_parts",
-                                   fill=ThemeManager.single_color(self.border_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.border_color, self.appearance_mode))
-            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                                   fill=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.border_color, self._appearance_mode))
+            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
         self.canvas.tag_lower("inner_parts")
         self.canvas.tag_lower("border_parts")
 
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
-
+    def configure(self, require_redraw=False, **kwargs):
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
-            del kwargs["fg_color"]
 
             # check if CTk widgets are children of the frame and change their bg_color to new frame fg_color
             for child in self.winfo_children():
                 if isinstance(child, CTkBaseClass):
                     child.configure(bg_color=self.fg_color)
 
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-
-            del kwargs["bg_color"]
-
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
-            del kwargs["border_color"]
 
         if "corner_radius" in kwargs:
-            self.corner_radius = kwargs["corner_radius"]
+            self.corner_radius = kwargs.pop("corner_radius")
             require_redraw = True
-            del kwargs["corner_radius"]
 
         if "border_width" in kwargs:
-            self.border_width = kwargs["border_width"]
+            self.border_width = kwargs.pop("border_width")
             require_redraw = True
-            del kwargs["border_width"]
 
         if "width" in kwargs:
-            self.set_dimensions(width=kwargs["width"])
-            del kwargs["width"]
+            self.set_dimensions(width=kwargs.pop("width"))
 
         if "height" in kwargs:
-            self.set_dimensions(height=kwargs["height"])
-            del kwargs["height"]
+            self.set_dimensions(height=kwargs.pop("height"))
 
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)

customtkinter/widgets/ctk_label.py

@@ -1,3 +1,4 @@
+import sys
 import tkinter
 
 from .ctk_canvas import CTkCanvas
@@ -12,16 +13,16 @@ class CTkLabel(CTkBaseClass):
                  fg_color="default_theme",
                  text_color="default_theme",
                  corner_radius="default_theme",
-                 width=120,
-                 height=25,
+                 width=140,
+                 height=28,
                  text="CTkLabel",
                  text_font="default_theme",
+                 anchor="center",  # label anchor: center, n, e, s, w
                  **kwargs):
 
-        # transfer basic functionality (bg_color, size, appearance_mode, scaling) to CTkBaseClass
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
         if "master" in kwargs:
-            super().__init__(*args, bg_color=bg_color, width=width, height=height, master=kwargs["master"])
-            del kwargs["master"]
+            super().__init__(*args, bg_color=bg_color, width=width, height=height, master=kwargs.pop("master"))
         else:
             super().__init__(*args, bg_color=bg_color, width=width, height=height)
 
@@ -35,6 +36,7 @@ class CTkLabel(CTkBaseClass):
         self.corner_radius = ThemeManager.theme["shape"]["label_corner_radius"] if corner_radius == "default_theme" else corner_radius
 
         # text
+        self.anchor = anchor
         self.text = text
         self.text_font = (ThemeManager.theme["text"]["font"], ThemeManager.theme["text"]["size"]) if text_font == "default_theme" else text_font
 
@@ -44,18 +46,21 @@ class CTkLabel(CTkBaseClass):
 
         self.canvas = CTkCanvas(master=self,
                                 highlightthickness=0,
-                                width=self.apply_widget_scaling(self.desired_width),
-                                height=self.apply_widget_scaling(self.desired_height))
+                                width=self.apply_widget_scaling(self._desired_width),
+                                height=self.apply_widget_scaling(self._desired_height))
         self.canvas.grid(row=0, column=0, sticky="nswe")
         self.draw_engine = DrawEngine(self.canvas)
 
         self.text_label = tkinter.Label(master=self,
                                         highlightthickness=0,
                                         bd=0,
+                                        anchor=self.anchor,
                                         text=self.text,
                                         font=self.apply_font_scaling(self.text_font),
                                         **kwargs)
-        self.text_label.grid(row=0, column=0, padx=self.apply_widget_scaling(self.corner_radius))
+        text_label_grid_sticky = self.anchor if self.anchor != "center" else ""
+        self.text_label.grid(row=0, column=0, padx=self.apply_widget_scaling(self.corner_radius),
+                             sticky=text_label_grid_sticky)
 
         self.bind('<Configure>', self.update_dimensions_event)
         self.draw()
@@ -63,63 +68,70 @@ class CTkLabel(CTkBaseClass):
     def set_scaling(self, *args, **kwargs):
         super().set_scaling(*args, **kwargs)
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
         self.text_label.configure(font=self.apply_font_scaling(self.text_font))
-        self.text_label.grid(row=0, column=0, padx=self.apply_widget_scaling(self.corner_radius))
+        text_label_grid_sticky = self.anchor if self.anchor != "center" else ""
+        self.text_label.grid(row=0, column=0, padx=self.apply_widget_scaling(self.corner_radius),
+                             sticky=text_label_grid_sticky)
 
         self.draw()
 
     def set_dimensions(self, width=None, height=None):
         super().set_dimensions(width, height)
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width),
-                              height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def draw(self, no_color_updates=False):
-        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self.current_width),
-                                                                             self.apply_widget_scaling(self.current_height),
+        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self._current_width),
+                                                                             self.apply_widget_scaling(self._current_height),
                                                                              self.apply_widget_scaling(self.corner_radius),
                                                                              0)
 
         if no_color_updates is False or requires_recoloring:
-            if ThemeManager.single_color(self.fg_color, self.appearance_mode) is not None:
+            if ThemeManager.single_color(self.fg_color, self._appearance_mode) is not None:
                 self.canvas.itemconfig("inner_parts",
-                                       fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
 
-                self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self.appearance_mode),
-                                          bg=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                                          bg=ThemeManager.single_color(self.fg_color, self._appearance_mode))
             else:
                 self.canvas.itemconfig("inner_parts",
-                                       fill=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
-                self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self.appearance_mode),
-                                          bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                                          bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
-            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
+    def config(self, **kwargs):
+        sys.stderr.write("Warning: Use .configure() instead of .config()")
+        self.configure(**kwargs)
+
+    def configure(self, require_redraw=False, **kwargs):
+        if "anchor" in kwargs:
+            self.anchor = kwargs.pop("anchor")
+            text_label_grid_sticky = self.anchor if self.anchor != "center" else ""
+            self.text_label.grid(row=0, column=0, padx=self.apply_widget_scaling(self.corner_radius),
+                                 sticky=text_label_grid_sticky)
 
         if "text" in kwargs:
-            self.set_text(kwargs["text"])
+            self.text = kwargs["text"]
+            self.text_label.configure(text=self.text)
             del kwargs["text"]
 
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.text_label.configure(font=self.apply_font_scaling(self.text_font))
+
         if "fg_color" in kwargs:
             self.fg_color = kwargs["fg_color"]
             require_redraw = True
             del kwargs["fg_color"]
 
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
-
         if "text_color" in kwargs:
             self.text_color = kwargs["text_color"]
             require_redraw = True
@@ -133,11 +145,15 @@ class CTkLabel(CTkBaseClass):
             self.set_dimensions(height=kwargs["height"])
             del kwargs["height"]
 
-        self.text_label.configure(*args, **kwargs)
+        if "bg_color" in kwargs:
+            super().configure(bg_color=kwargs.pop("bg_color"), require_redraw=require_redraw)
+        else:
+            super().configure(require_redraw=require_redraw)
 
-        if require_redraw:
-            self.draw()
+        self.text_label.configure(**kwargs)  # pass remaining kwargs to label
 
     def set_text(self, text):
+        """ Will be removed in the next major release """
+
         self.text = text
-        self.text_label.configure(text=self.text, width=len(self.text))
+        self.text_label.configure(text=self.text)

customtkinter/widgets/ctk_optionmenu.py

@@ -0,0 +1,311 @@
+import tkinter
+import sys
+
+from .dropdown_menu import DropdownMenu
+
+from .ctk_canvas import CTkCanvas
+from ..theme_manager import ThemeManager
+from ..settings import Settings
+from ..draw_engine import DrawEngine
+from .widget_base_class import CTkBaseClass
+
+
+class CTkOptionMenu(CTkBaseClass):
+    def __init__(self, *args,
+                 bg_color=None,
+                 fg_color="default_theme",
+                 button_color="default_theme",
+                 button_hover_color="default_theme",
+                 text_color="default_theme",
+                 text_color_disabled="default_theme",
+                 dropdown_color="default_theme",
+                 dropdown_hover_color="default_theme",
+                 dropdown_text_color="default_theme",
+                 variable=None,
+                 values=None,
+                 command=None,
+                 width=140,
+                 height=28,
+                 corner_radius="default_theme",
+                 text_font="default_theme",
+                 dropdown_text_font="default_theme",
+                 hover=True,
+                 state=tkinter.NORMAL,
+                 dynamic_resizing=True,
+                 **kwargs):
+
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
+        super().__init__(*args, bg_color=bg_color, width=width, height=height, **kwargs)
+
+        # color variables
+        self.fg_color = ThemeManager.theme["color"]["button"] if fg_color == "default_theme" else fg_color
+        self.button_color = ThemeManager.theme["color"]["optionmenu_button"] if button_color == "default_theme" else button_color
+        self.button_hover_color = ThemeManager.theme["color"]["optionmenu_button_hover"] if button_hover_color == "default_theme" else button_hover_color
+
+        # shape
+        self.corner_radius = ThemeManager.theme["shape"]["button_corner_radius"] if corner_radius == "default_theme" else corner_radius
+
+        # text and font
+        self.text_color = ThemeManager.theme["color"]["text"] if text_color == "default_theme" else text_color
+        self.text_color_disabled = ThemeManager.theme["color"]["text_button_disabled"] if text_color_disabled == "default_theme" else text_color_disabled
+        self.text_font = (ThemeManager.theme["text"]["font"], ThemeManager.theme["text"]["size"]) if text_font == "default_theme" else text_font
+        self.dropdown_text_font = dropdown_text_font
+
+        # callback and hover functionality
+        self.command = command
+        self.variable = variable
+        self.variable_callback_blocked = False
+        self.variable_callback_name = None
+        self.state = state
+        self.hover = hover
+        self.dynamic_resizing = dynamic_resizing
+
+        if values is None:
+            self.values = ["CTkOptionMenu"]
+        else:
+            self.values = values
+
+        if len(self.values) > 0:
+            self.current_value = self.values[0]
+        else:
+            self.current_value = "CTkOptionMenu"
+
+        self.dropdown_menu = DropdownMenu(master=self,
+                                          values=self.values,
+                                          command=self.dropdown_callback,
+                                          fg_color=dropdown_color,
+                                          hover_color=dropdown_hover_color,
+                                          text_color=dropdown_text_color,
+                                          text_font=dropdown_text_font)
+
+        # configure grid system (1x1)
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=1)
+
+        self.canvas = CTkCanvas(master=self,
+                                highlightthickness=0,
+                                width=self.apply_widget_scaling(self._desired_width),
+                                height=self.apply_widget_scaling(self._desired_height))
+        self.canvas.grid(row=0, column=0, rowspan=1, columnspan=1, sticky="nsew")
+        self.draw_engine = DrawEngine(self.canvas)
+
+        left_section_width = self._current_width - self._current_height
+        self.text_label = tkinter.Label(master=self,
+                                        font=self.apply_font_scaling(self.text_font),
+                                        anchor="w",
+                                        text=self.current_value)
+        self.text_label.grid(row=0, column=0, sticky="w",
+                             padx=(max(self.apply_widget_scaling(self.corner_radius), self.apply_widget_scaling(3)),
+                                   max(self.apply_widget_scaling(self._current_width - left_section_width + 3), self.apply_widget_scaling(3))))
+
+        if not self.dynamic_resizing:
+            self.grid_propagate(0)
+
+        if Settings.cursor_manipulation_enabled:
+            if sys.platform == "darwin":
+                self.configure(cursor="pointinghand")
+            elif sys.platform.startswith("win"):
+                self.configure(cursor="hand2")
+
+        # event bindings
+        self.canvas.bind("<Enter>", self.on_enter)
+        self.canvas.bind("<Leave>", self.on_leave)
+        self.canvas.bind("<Button-1>", self.clicked)
+        self.canvas.bind("<Button-1>", self.clicked)
+
+        self.text_label.bind("<Enter>", self.on_enter)
+        self.text_label.bind("<Leave>", self.on_leave)
+        self.text_label.bind("<Button-1>", self.clicked)
+        self.text_label.bind("<Button-1>", self.clicked)
+
+        self.bind('<Configure>', self.update_dimensions_event)
+
+        self.draw()  # initial draw
+
+        if self.variable is not None:
+            self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
+            self.current_value = self.variable.get()
+            self.text_label.configure(text=self.current_value)
+
+    def set_scaling(self, *args, **kwargs):
+        super().set_scaling(*args, **kwargs)
+
+        # change label text size and grid padding
+        left_section_width = self._current_width - self._current_height
+        self.text_label.configure(font=self.apply_font_scaling(self.text_font))
+        self.text_label.grid(row=0, column=0, sticky="w",
+                             padx=(max(self.apply_widget_scaling(self.corner_radius), self.apply_widget_scaling(3)),
+                                   max(self.apply_widget_scaling(self._current_width - left_section_width + 3), self.apply_widget_scaling(3))))
+
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
+        self.draw()
+
+    def set_dimensions(self, width: int = None, height: int = None):
+        super().set_dimensions(width, height)
+
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
+        self.draw()
+
+    def draw(self, no_color_updates=False):
+        left_section_width = self._current_width - self._current_height
+        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border_vertical_split(self.apply_widget_scaling(self._current_width),
+                                                                                            self.apply_widget_scaling(self._current_height),
+                                                                                            self.apply_widget_scaling(self.corner_radius),
+                                                                                            0,
+                                                                                            self.apply_widget_scaling(left_section_width))
+
+        requires_recoloring_2 = self.draw_engine.draw_dropdown_arrow(self.apply_widget_scaling(self._current_width - (self._current_height / 2)),
+                                                                     self.apply_widget_scaling(self._current_height / 2),
+                                                                     self.apply_widget_scaling(self._current_height / 3))
+
+        if no_color_updates is False or requires_recoloring or requires_recoloring_2:
+
+            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+
+            self.canvas.itemconfig("inner_parts_left",
+                                   outline=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.fg_color, self._appearance_mode))
+            self.canvas.itemconfig("inner_parts_right",
+                                   outline=ThemeManager.single_color(self.button_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.button_color, self._appearance_mode))
+
+            self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
+
+            if self.state == tkinter.DISABLED:
+                self.text_label.configure(fg=(ThemeManager.single_color(self.text_color_disabled, self._appearance_mode)))
+                self.canvas.itemconfig("dropdown_arrow",
+                                       fill=ThemeManager.single_color(self.text_color_disabled, self._appearance_mode))
+            else:
+                self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
+                self.canvas.itemconfig("dropdown_arrow",
+                                       fill=ThemeManager.single_color(self.text_color, self._appearance_mode))
+
+            self.text_label.configure(bg=ThemeManager.single_color(self.fg_color, self._appearance_mode))
+
+        self.canvas.update_idletasks()
+
+    def open_dropdown_menu(self):
+        self.dropdown_menu.open(self.winfo_rootx(),
+                                self.winfo_rooty() + self.apply_widget_scaling(self._current_height + 0))
+
+    def configure(self, require_redraw=False, **kwargs):
+        if "state" in kwargs:
+            self.state = kwargs.pop("state")
+            require_redraw = True
+
+        if "fg_color" in kwargs:
+            self.fg_color = kwargs.pop("fg_color")
+            require_redraw = True
+
+        if "button_color" in kwargs:
+            self.button_color = kwargs.pop("button_color")
+            require_redraw = True
+
+        if "button_hover_color" in kwargs:
+            self.button_hover_color = kwargs.pop("button_hover_color")
+            require_redraw = True
+
+        if "text_color" in kwargs:
+            self.text_color = kwargs.pop("text_color")
+            require_redraw = True
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.text_label.configure(font=self.apply_font_scaling(self.text_font))
+
+        if "command" in kwargs:
+            self.command = kwargs.pop("command")
+
+        if "variable" in kwargs:
+            if self.variable is not None:  # remove old callback
+                self.variable.trace_remove("write", self.variable_callback_name)
+
+            self.variable = kwargs.pop("variable")
+
+            if self.variable is not None and self.variable != "":
+                self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
+                self.current_value = self.variable.get()
+                self.text_label.configure(text=self.current_value)
+            else:
+                self.variable = None
+
+        if "width" in kwargs:
+            self.set_dimensions(width=kwargs.pop("width"))
+
+        if "height" in kwargs:
+            self.set_dimensions(height=kwargs.pop("height"))
+
+        if "values" in kwargs:
+            self.values = kwargs.pop("values")
+            self.dropdown_menu.configure(values=self.values)
+
+        if "dropdown_color" in kwargs:
+            self.dropdown_menu.configure(fg_color=kwargs.pop("dropdown_color"))
+
+        if "dropdown_hover_color" in kwargs:
+            self.dropdown_menu.configure(hover_color=kwargs.pop("dropdown_hover_color"))
+
+        if "dropdown_text_color" in kwargs:
+            self.dropdown_menu.configure(text_color=kwargs.pop("dropdown_text_color"))
+
+        if "dropdown_text_font" in kwargs:
+            self.dropdown_text_font = kwargs.pop("dropdown_text_font")
+            self.dropdown_menu.configure(text_font=self.dropdown_text_font)
+
+        if "dynamic_resizing" in kwargs:
+            self.dynamic_resizing = kwargs.pop("dynamic_resizing")
+            if not self.dynamic_resizing:
+                self.grid_propagate(0)
+            else:
+                self.grid_propagate(1)
+
+        super().configure(require_redraw=require_redraw, **kwargs)
+
+    def on_enter(self, event=0):
+        if self.hover is True and self.state == tkinter.NORMAL and len(self.values) > 0:
+            # set color of inner button parts to hover color
+            self.canvas.itemconfig("inner_parts_right",
+                                   outline=ThemeManager.single_color(self.button_hover_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.button_hover_color, self._appearance_mode))
+
+    def on_leave(self, event=0):
+        if self.hover is True:
+            # set color of inner button parts
+            self.canvas.itemconfig("inner_parts_right",
+                                   outline=ThemeManager.single_color(self.button_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.button_color, self._appearance_mode))
+
+    def variable_callback(self, var_name, index, mode):
+        if not self.variable_callback_blocked:
+            self.current_value = self.variable.get()
+            self.text_label.configure(text=self.current_value)
+
+    def dropdown_callback(self, value: str):
+        self.current_value = value
+        self.text_label.configure(text=self.current_value)
+
+        if self.variable is not None:
+            self.variable_callback_blocked = True
+            self.variable.set(self.current_value)
+            self.variable_callback_blocked = False
+
+        if self.command is not None:
+            self.command(self.current_value)
+
+    def set(self, value: str):
+        self.current_value = value
+        self.text_label.configure(text=self.current_value)
+
+        if self.variable is not None:
+            self.variable_callback_blocked = True
+            self.variable.set(self.current_value)
+            self.variable_callback_blocked = False
+
+    def get(self) -> str:
+        return self.current_value
+
+    def clicked(self, event=0):
+        if self.state is not tkinter.DISABLED and len(self.values) > 0:
+            self.open_dropdown_menu()

customtkinter/widgets/ctk_progressbar.py

@@ -1,14 +1,14 @@
 import tkinter
+import math
 
 from .ctk_canvas import CTkCanvas
 from ..theme_manager import ThemeManager
 from ..draw_engine import DrawEngine
-from ..settings import Settings
 from .widget_base_class import CTkBaseClass
 
 
 class CTkProgressBar(CTkBaseClass):
-    """ tkinter custom progressbar, always horizontal, values are from 0 to 1 """
+    """ tkinter custom progressbar, values from 0 to 1 """
 
     def __init__(self, *args,
                  variable=None,
@@ -21,6 +21,9 @@ class CTkProgressBar(CTkBaseClass):
                  height=None,
                  border_width="default_theme",
                  orient="horizontal",
+                 mode="determinate",
+                 determinate_speed=1,
+                 indeterminate_speed=1,
                  **kwargs):
 
         # set default dimensions according to orientation
@@ -35,7 +38,7 @@ class CTkProgressBar(CTkBaseClass):
             else:
                 height = 8
 
-        # transfer basic functionality (bg_color, size, appearance_mode, scaling) to CTkBaseClass
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
         super().__init__(*args, bg_color=bg_color, width=width, height=height, **kwargs)
 
         # color
@@ -51,16 +54,22 @@ class CTkProgressBar(CTkBaseClass):
         # shape
         self.corner_radius = ThemeManager.theme["shape"]["progressbar_corner_radius"] if corner_radius == "default_theme" else corner_radius
         self.border_width = ThemeManager.theme["shape"]["progressbar_border_width"] if border_width == "default_theme" else border_width
-        self.value = 0.5
+        self.determinate_value = 0.5  # range 0-1
+        self.determinate_speed = determinate_speed  # range 0-1
+        self.indeterminate_value = 0  # range 0-inf
+        self.indeterminate_width = 0.4  # range 0-1
+        self.indeterminate_speed = indeterminate_speed  # range 0-1 to travel in 50ms
+        self.loop_running = False
         self.orient = orient
+        self.mode = mode  # "determinate" or "indeterminate"
 
         self.grid_rowconfigure(0, weight=1)
         self.grid_columnconfigure(0, weight=1)
 
         self.canvas = CTkCanvas(master=self,
                                 highlightthickness=0,
-                                width=self.apply_widget_scaling(self.desired_width),
-                                height=self.apply_widget_scaling(self.desired_height))
+                                width=self.apply_widget_scaling(self._desired_width),
+                                height=self.apply_widget_scaling(self._desired_height))
         self.canvas.grid(row=0, column=0, rowspan=1, columnspan=1, sticky="nswe")
         self.draw_engine = DrawEngine(self.canvas)
 
@@ -78,14 +87,14 @@ class CTkProgressBar(CTkBaseClass):
     def set_scaling(self, *args, **kwargs):
         super().set_scaling(*args, **kwargs)
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def set_dimensions(self, width=None, height=None):
         super().set_dimensions(width, height)
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width),
-                              height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def destroy(self):
@@ -102,36 +111,40 @@ class CTkProgressBar(CTkBaseClass):
         else:
             orientation = "w"
 
-        requires_recoloring = self.draw_engine.draw_rounded_progress_bar_with_border(self.apply_widget_scaling(self.current_width),
-                                                                                     self.apply_widget_scaling(self.current_height),
-                                                                                     self.apply_widget_scaling(self.corner_radius),
-                                                                                     self.apply_widget_scaling(self.border_width),
-                                                                                     self.value,
-                                                                                     orientation)
+        if self.mode == "determinate":
+            requires_recoloring = self.draw_engine.draw_rounded_progress_bar_with_border(self.apply_widget_scaling(self._current_width),
+                                                                                         self.apply_widget_scaling(self._current_height),
+                                                                                         self.apply_widget_scaling(self.corner_radius),
+                                                                                         self.apply_widget_scaling(self.border_width),
+                                                                                         0,
+                                                                                         self.determinate_value,
+                                                                                         orientation)
+        else:  # indeterminate mode
+            progress_value = (math.sin(self.indeterminate_value * math.pi / 40) + 1) / 2
+            progress_value_1 = min(1.0, progress_value + (self.indeterminate_width / 2))
+            progress_value_2 = max(0.0, progress_value - (self.indeterminate_width / 2))
+
+            requires_recoloring = self.draw_engine.draw_rounded_progress_bar_with_border(self.apply_widget_scaling(self._current_width),
+                                                                                         self.apply_widget_scaling(self._current_height),
+                                                                                         self.apply_widget_scaling(self.corner_radius),
+                                                                                         self.apply_widget_scaling(self.border_width),
+                                                                                         progress_value_1,
+                                                                                         progress_value_2,
+                                                                                         orientation)
 
         if no_color_updates is False or requires_recoloring:
-            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
             self.canvas.itemconfig("border_parts",
-                                   fill=ThemeManager.single_color(self.border_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.border_color, self.appearance_mode))
+                                   fill=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.border_color, self._appearance_mode))
             self.canvas.itemconfig("inner_parts",
-                                   fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                                   fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
             self.canvas.itemconfig("progress_parts",
-                                   fill=ThemeManager.single_color(self.progress_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.progress_color, self.appearance_mode))
-
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
-
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
+                                   fill=ThemeManager.single_color(self.progress_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.progress_color, self._appearance_mode))
 
+    def configure(self, require_redraw=False, **kwargs):
         if "fg_color" in kwargs:
             self.fg_color = kwargs["fg_color"]
             del kwargs["fg_color"]
@@ -166,6 +179,16 @@ class CTkProgressBar(CTkBaseClass):
 
             del kwargs["variable"]
 
+        if "mode" in kwargs:
+            self.mode = kwargs.pop("mode")
+            require_redraw = True
+
+        if "determinate_speed" in kwargs:
+            self.determinate_speed = kwargs.pop("determinate_speed")
+
+        if "indeterminate_speed" in kwargs:
+            self.indeterminate_speed = kwargs.pop("indeterminate_speed")
+
         if "width" in kwargs:
             self.set_dimensions(width=kwargs["width"])
             del kwargs["width"]
@@ -174,26 +197,61 @@ class CTkProgressBar(CTkBaseClass):
             self.set_dimensions(height=kwargs["height"])
             del kwargs["height"]
 
-        super().configure(*args, **kwargs)
-
-        if require_redraw is True:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)
 
     def variable_callback(self, var_name, index, mode):
         if not self.variable_callback_blocked:
             self.set(self.variable.get(), from_variable_callback=True)
 
     def set(self, value, from_variable_callback=False):
-        self.value = value
+        """ set determinate value """
+        self.determinate_value = value
 
-        if self.value > 1:
-            self.value = 1
-        elif self.value < 0:
-            self.value = 0
+        if self.determinate_value > 1:
+            self.determinate_value = 1
+        elif self.determinate_value < 0:
+            self.determinate_value = 0
 
         self.draw(no_color_updates=True)
 
         if self.variable is not None and not from_variable_callback:
             self.variable_callback_blocked = True
-            self.variable.set(round(self.value) if isinstance(self.variable, tkinter.IntVar) else self.value)
+            self.variable.set(round(self.determinate_value) if isinstance(self.variable, tkinter.IntVar) else self.determinate_value)
             self.variable_callback_blocked = False
+
+    def get(self):
+        """ get determinate value """
+        return self.determinate_value
+
+    def start(self):
+        """ start indeterminate mode """
+        if not self.loop_running:
+            self.loop_running = True
+            self.internal_loop()
+
+    def stop(self):
+        """ stop indeterminate mode """
+        self.loop_running = False
+
+    def internal_loop(self):
+        if self.loop_running:
+            if self.mode == "determinate":
+                self.determinate_value += self.determinate_speed / 50
+                if self.determinate_value > 1:
+                    self.determinate_value -= 1
+                self.draw()
+                self.after(20, self.internal_loop)
+            else:
+                self.indeterminate_value += self.indeterminate_speed
+                self.draw()
+                self.after(20, self.internal_loop)
+
+    def step(self):
+        if self.mode == "determinate":
+            self.determinate_value += self.determinate_speed / 50
+            if self.determinate_value > 1:
+                self.determinate_value -= 1
+            self.draw()
+        else:
+            self.indeterminate_value += self.indeterminate_speed
+            self.draw()

customtkinter/widgets/ctk_radiobutton.py

@@ -1,5 +1,6 @@
 import tkinter
 import sys
+from typing import Union
 
 from .ctk_canvas import CTkCanvas
 from ..theme_manager import ThemeManager
@@ -31,7 +32,7 @@ class CTkRadioButton(CTkBaseClass):
                  textvariable=None,
                  **kwargs):
 
-        # transfer basic functionality (bg_color, size, appearance_mode, scaling) to CTkBaseClass
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
         super().__init__(*args, bg_color=bg_color, width=width, height=height, **kwargs)
 
         # color
@@ -47,13 +48,13 @@ class CTkRadioButton(CTkBaseClass):
 
         # text
         self.text = text
-        self.text_label = None
+        self.text_label: Union[tkinter.Label, None] = None
         self.text_color = ThemeManager.theme["color"]["text"] if text_color == "default_theme" else text_color
         self.text_color_disabled = ThemeManager.theme["color"]["text_disabled"] if text_color_disabled == "default_theme" else text_color_disabled
         self.text_font = (ThemeManager.theme["text"]["font"], ThemeManager.theme["text"]["size"]) if text_font == "default_theme" else text_font
 
         # callback and control variables
-        self.function = command
+        self.command = command
         self.state = state
         self.hover = hover
         self.check_state = False
@@ -70,31 +71,40 @@ class CTkRadioButton(CTkBaseClass):
 
         self.bg_canvas = CTkCanvas(master=self,
                                    highlightthickness=0,
-                                   width=self.apply_widget_scaling(self.current_width),
-                                   height=self.apply_widget_scaling(self.current_height))
+                                   width=self.apply_widget_scaling(self._current_width),
+                                   height=self.apply_widget_scaling(self._current_height))
         self.bg_canvas.grid(row=0, column=0, padx=0, pady=0, columnspan=3, rowspan=1, sticky="nswe")
 
         self.canvas = CTkCanvas(master=self,
                                 highlightthickness=0,
-                                width=self.apply_widget_scaling(self.current_width),
-                                height=self.apply_widget_scaling(self.current_height))
+                                width=self.apply_widget_scaling(self._current_width),
+                                height=self.apply_widget_scaling(self._current_height))
         self.canvas.grid(row=0, column=0, padx=0, pady=0, columnspan=1)
         self.draw_engine = DrawEngine(self.canvas)
 
         self.canvas.bind("<Enter>", self.on_enter)
         self.canvas.bind("<Leave>", self.on_leave)
         self.canvas.bind("<Button-1>", self.invoke)
-        self.canvas.bind("<Button-1>", self.invoke)
 
-        self.set_cursor()
-        self.draw()  # initial draw
+        self.text_label = tkinter.Label(master=self,
+                                        bd=0,
+                                        text=self.text,
+                                        justify=tkinter.LEFT,
+                                        font=self.apply_font_scaling(self.text_font),
+                                        textvariable=self.textvariable)
+        self.text_label.grid(row=0, column=2, padx=0, pady=0, sticky="w")
+        self.text_label["anchor"] = "w"
+
+        self.text_label.bind("<Enter>", self.on_enter)
+        self.text_label.bind("<Leave>", self.on_leave)
+        self.text_label.bind("<Button-1>", self.invoke)
 
         if self.variable is not None:
             self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
-            if self.variable.get() == self.value:
-                self.select(from_variable_callback=True)
-            else:
-                self.deselect(from_variable_callback=True)
+            self.check_state = True if self.variable.get() == self.value else False
+
+        self.draw()  # initial draw
+        self.set_cursor()
 
     def set_scaling(self, *args, **kwargs):
         super().set_scaling(*args, **kwargs)
@@ -102,8 +112,8 @@ class CTkRadioButton(CTkBaseClass):
         self.grid_columnconfigure(1, weight=0, minsize=self.apply_widget_scaling(6))
         self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
-        self.bg_canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
+        self.bg_canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def destroy(self):
@@ -113,154 +123,126 @@ class CTkRadioButton(CTkBaseClass):
         super().destroy()
 
     def draw(self, no_color_updates=False):
-        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self.current_width),
-                                                                             self.apply_widget_scaling(self.current_height),
+        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self._current_width),
+                                                                             self.apply_widget_scaling(self._current_height),
                                                                              self.apply_widget_scaling(self.corner_radius),
                                                                              self.apply_widget_scaling(self.border_width))
 
-        self.bg_canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
-        self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+        self.bg_canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+        self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
         if self.check_state is False:
             self.canvas.itemconfig("border_parts",
-                                   outline=ThemeManager.single_color(self.border_color, self.appearance_mode),
-                                   fill=ThemeManager.single_color(self.border_color, self.appearance_mode))
+                                   outline=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.border_color, self._appearance_mode))
         else:
             self.canvas.itemconfig("border_parts",
-                                   outline=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                   fill=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                                   outline=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.fg_color, self._appearance_mode))
 
         self.canvas.itemconfig("inner_parts",
-                               outline=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                               fill=ThemeManager.single_color(self.bg_color, self.appearance_mode))
-
-        if self.text_label is None:
-            self.text_label = tkinter.Label(master=self,
-                                            bd=0,
-                                            text=self.text,
-                                            justify=tkinter.LEFT,
-                                            font=self.apply_font_scaling(self.text_font))
-            self.text_label.grid(row=0, column=2, padx=0, pady=0, sticky="w")
-            self.text_label["anchor"] = "w"
+                               outline=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                               fill=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
         if self.state == tkinter.DISABLED:
-            self.text_label.configure(fg=ThemeManager.single_color(self.text_color_disabled, self.appearance_mode))
+            self.text_label.configure(fg=ThemeManager.single_color(self.text_color_disabled, self._appearance_mode))
         else:
-            self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self.appearance_mode))
+            self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
 
-        self.text_label.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
-
-        self.set_text(self.text)
-
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw()
+        self.text_label.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
+    def configure(self, require_redraw=False, **kwargs):
         if "text" in kwargs:
-            self.set_text(kwargs["text"])
-            del kwargs["text"]
+            self.text = kwargs.pop("text")
+            self.text_label.configure(text=self.text)
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
         if "state" in kwargs:
-            self.state = kwargs["state"]
+            self.state = kwargs.pop("state")
             self.set_cursor()
             require_redraw = True
-            del kwargs["state"]
 
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
-            del kwargs["fg_color"]
-
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
 
         if "hover_color" in kwargs:
-            self.hover_color = kwargs["hover_color"]
+            self.hover_color = kwargs.pop("hover_color")
             require_redraw = True
-            del kwargs["hover_color"]
 
         if "text_color" in kwargs:
-            self.text_color = kwargs["text_color"]
+            self.text_color = kwargs.pop("text_color")
             require_redraw = True
-            del kwargs["text_color"]
 
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
-            del kwargs["border_color"]
 
         if "border_width" in kwargs:
-            self.border_width = kwargs["border_width"]
+            self.border_width = kwargs.pop("border_width")
             require_redraw = True
-            del kwargs["border_width"]
 
         if "command" in kwargs:
-            self.function = kwargs["command"]
-            del kwargs["command"]
+            self.command = kwargs.pop("command")
+
+        if "textvariable" in kwargs:
+            self.textvariable = kwargs.pop("textvariable")
+            self.text_label.configure(textvariable=self.textvariable)
 
         if "variable" in kwargs:
             if self.variable is not None:
                 self.variable.trace_remove("write", self.variable_callback_name)
 
-            self.variable = kwargs["variable"]
+            self.variable = kwargs.pop("variable")
 
             if self.variable is not None and self.variable != "":
                 self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
-                if self.variable.get() == self.value:
-                    self.select(from_variable_callback=True)
-                else:
-                    self.deselect(from_variable_callback=True)
-            else:
-                self.variable = None
+                self.check_state = True if self.variable.get() == self.value else False
+                require_redraw = True
 
-            del kwargs["variable"]
-
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)
 
     def set_cursor(self):
         if Settings.cursor_manipulation_enabled:
             if self.state == tkinter.DISABLED:
                 if sys.platform == "darwin" and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="arrow")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="arrow")
                 elif sys.platform.startswith("win") and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="arrow")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="arrow")
 
             elif self.state == tkinter.NORMAL:
                 if sys.platform == "darwin" and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="pointinghand")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="pointinghand")
                 elif sys.platform.startswith("win") and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="hand2")
-
-    def set_text(self, text):
-        self.text = text
-        if self.text_label is not None:
-            self.text_label.configure(text=self.text)
-        else:
-            sys.stderr.write("ERROR (CTkButton): Cant change text because radiobutton has no text.")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="hand2")
 
     def on_enter(self, event=0):
         if self.hover is True and self.state == tkinter.NORMAL:
             self.canvas.itemconfig("border_parts",
-                                   fill=ThemeManager.single_color(self.hover_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.hover_color, self.appearance_mode))
+                                   fill=ThemeManager.single_color(self.hover_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.hover_color, self._appearance_mode))
 
     def on_leave(self, event=0):
         if self.hover is True:
             if self.check_state is True:
                 self.canvas.itemconfig("border_parts",
-                                       fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
             else:
                 self.canvas.itemconfig("border_parts",
-                                       fill=ThemeManager.single_color(self.border_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.border_color, self.appearance_mode))
+                                       fill=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.border_color, self._appearance_mode))
 
     def variable_callback(self, var_name, index, mode):
         if not self.variable_callback_blocked:
@@ -275,11 +257,8 @@ class CTkRadioButton(CTkBaseClass):
                 self.check_state = True
                 self.select()
 
-        if self.function is not None:
-            try:
-                self.function()
-            except:
-                pass
+        if self.command is not None:
+            self.command()
 
     def select(self, from_variable_callback=False):
         self.check_state = True

customtkinter/widgets/ctk_scrollbar.py

@@ -0,0 +1,225 @@
+import sys
+
+from .ctk_canvas import CTkCanvas
+from ..theme_manager import ThemeManager
+from ..draw_engine import DrawEngine
+from .widget_base_class import CTkBaseClass
+
+
+class CTkScrollbar(CTkBaseClass):
+    def __init__(self, *args,
+                 bg_color=None,
+                 fg_color="default_theme",
+                 scrollbar_color="default_theme",
+                 scrollbar_hover_color="default_theme",
+                 border_spacing="default_theme",
+                 corner_radius="default_theme",
+                 width=None,
+                 height=None,
+                 minimum_pixel_length=20,
+                 orientation="vertical",
+                 command=None,
+                 hover=True,
+                 **kwargs):
+
+        # set default dimensions according to orientation
+        if width is None:
+            if orientation.lower() == "vertical":
+                width = 16
+            else:
+                width = 200
+        if height is None:
+            if orientation.lower() == "horizontal":
+                height = 16
+            else:
+                height = 200
+
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
+        super().__init__(*args, bg_color=bg_color, width=width, height=height, **kwargs)
+
+        # color
+        self.fg_color = ThemeManager.theme["color"]["frame_high"] if fg_color == "default_theme" else fg_color
+        self.scrollbar_color = ThemeManager.theme["color"]["scrollbar_button"] if scrollbar_color == "default_theme" else scrollbar_color
+        self.scrollbar_hover_color = ThemeManager.theme["color"]["scrollbar_button_hover"] if scrollbar_hover_color == "default_theme" else scrollbar_hover_color
+
+        # shape
+        self.corner_radius = ThemeManager.theme["shape"]["scrollbar_corner_radius"] if corner_radius == "default_theme" else corner_radius
+        self.border_spacing = ThemeManager.theme["shape"]["scrollbar_border_spacing"] if border_spacing == "default_theme" else border_spacing
+
+        self.hover = hover
+        self.hover_state = False
+        self.command = command
+        self.orientation = orientation
+        self.start_value: float = 0  # 0 to 1
+        self.end_value: float = 1  # 0 to 1
+        self.minimum_pixel_length = minimum_pixel_length
+
+        self.canvas = CTkCanvas(master=self,
+                                highlightthickness=0,
+                                width=self.apply_widget_scaling(self._current_width),
+                                height=self.apply_widget_scaling(self._current_height))
+        self.canvas.place(x=0, y=0, relwidth=1, relheight=1)
+        self.draw_engine = DrawEngine(self.canvas)
+
+        self.canvas.bind("<Enter>", self.on_enter)
+        self.canvas.bind("<Leave>", self.on_leave)
+        self.canvas.tag_bind("border_parts", "<Button-1>", self.clicked)
+        self.canvas.bind("<B1-Motion>", self.clicked)
+        self.canvas.bind("<MouseWheel>", self.mouse_scroll_event)
+        self.bind('<Configure>', self.update_dimensions_event)
+
+        self.draw()
+
+    def set_scaling(self, *args, **kwargs):
+        super().set_scaling(*args, **kwargs)
+
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
+        self.draw(no_color_updates=True)
+
+    def set_dimensions(self, width=None, height=None):
+        super().set_dimensions(width, height)
+
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
+        self.draw(no_color_updates=True)
+
+    def get_scrollbar_values_for_minimum_pixel_size(self):
+        # correct scrollbar float values if scrollbar is too small
+        if self.orientation == "vertical":
+            scrollbar_pixel_length = (self.end_value - self.start_value) * self._current_height
+            if scrollbar_pixel_length < self.minimum_pixel_length and -scrollbar_pixel_length + self._current_height != 0:
+                # calculate how much to increase the float interval values so that the scrollbar width is self.minimum_pixel_length
+                interval_extend_factor = (-scrollbar_pixel_length + self.minimum_pixel_length) / (-scrollbar_pixel_length + self._current_height)
+                corrected_end_value = self.end_value + (1 - self.end_value) * interval_extend_factor
+                corrected_start_value = self.start_value - self.start_value * interval_extend_factor
+                return corrected_start_value, corrected_end_value
+            else:
+                return self.start_value, self.end_value
+
+        else:
+            scrollbar_pixel_length = (self.end_value - self.start_value) * self._current_width
+            if scrollbar_pixel_length < self.minimum_pixel_length and -scrollbar_pixel_length + self._current_width != 0:
+                # calculate how much to increase the float interval values so that the scrollbar width is self.minimum_pixel_length
+                interval_extend_factor = (-scrollbar_pixel_length + self.minimum_pixel_length) / (-scrollbar_pixel_length + self._current_width)
+                corrected_end_value = self.end_value + (1 - self.end_value) * interval_extend_factor
+                corrected_start_value = self.start_value - self.start_value * interval_extend_factor
+                return corrected_start_value, corrected_end_value
+            else:
+                return self.start_value, self.end_value
+
+    def draw(self, no_color_updates=False):
+        corrected_start_value, corrected_end_value = self.get_scrollbar_values_for_minimum_pixel_size()
+        requires_recoloring = self.draw_engine.draw_rounded_scrollbar(self.apply_widget_scaling(self._current_width),
+                                                                      self.apply_widget_scaling(self._current_height),
+                                                                      self.apply_widget_scaling(self.corner_radius),
+                                                                      self.apply_widget_scaling(self.border_spacing),
+                                                                      corrected_start_value,
+                                                                      corrected_end_value,
+                                                                      self.orientation)
+
+        if no_color_updates is False or requires_recoloring:
+            if self.hover_state is True:
+                self.canvas.itemconfig("scrollbar_parts",
+                                       fill=ThemeManager.single_color(self.scrollbar_hover_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.scrollbar_hover_color, self._appearance_mode))
+            else:
+                self.canvas.itemconfig("scrollbar_parts",
+                                       fill=ThemeManager.single_color(self.scrollbar_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.scrollbar_color, self._appearance_mode))
+
+            if self.fg_color is None:
+                self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+                self.canvas.itemconfig("border_parts",
+                                       fill=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+            else:
+                self.canvas.configure(bg=ThemeManager.single_color(self.fg_color, self._appearance_mode))
+                self.canvas.itemconfig("border_parts",
+                                       fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
+
+        self.canvas.update_idletasks()
+
+    def set(self, start_value: float, end_value: float):
+        self.start_value = float(start_value)
+        self.end_value = float(end_value)
+        self.draw()
+
+    def get(self):
+        return self.start_value, self.end_value
+
+    def configure(self, require_redraw=False, **kwargs):
+        if "fg_color" in kwargs:
+            self.fg_color = kwargs["fg_color"]
+            require_redraw = True
+            del kwargs["fg_color"]
+
+        if "scrollbar_color" in kwargs:
+            self.scrollbar_color = kwargs["scrollbar_color"]
+            require_redraw = True
+            del kwargs["scrollbar_color"]
+
+        if "scrollbar_hover_color" in kwargs:
+            self.scrollbar_hover_color = kwargs["scrollbar_hover_color"]
+            require_redraw = True
+            del kwargs["scrollbar_hover_color"]
+
+        if "command" in kwargs:
+            self.command = kwargs["command"]
+            del kwargs["command"]
+
+        if "corner_radius" in kwargs:
+            self.corner_radius = kwargs["corner_radius"]
+            require_redraw = True
+            del kwargs["corner_radius"]
+
+        if "border_spacing" in kwargs:
+            self.border_spacing = kwargs["border_spacing"]
+            require_redraw = True
+            del kwargs["border_spacing"]
+
+        if "width" in kwargs:
+            self.set_dimensions(width=kwargs["width"])
+            del kwargs["width"]
+
+        if "height" in kwargs:
+            self.set_dimensions(height=kwargs["height"])
+            del kwargs["height"]
+
+        super().configure(require_redraw=require_redraw, **kwargs)
+
+    def on_enter(self, event=0):
+        if self.hover is True:
+            self.hover_state = True
+            self.canvas.itemconfig("scrollbar_parts",
+                                   outline=ThemeManager.single_color(self.scrollbar_hover_color, self._appearance_mode),
+                                   fill=ThemeManager.single_color(self.scrollbar_hover_color, self._appearance_mode))
+
+    def on_leave(self, event=0):
+        self.hover_state = False
+        self.canvas.itemconfig("scrollbar_parts",
+                               outline=ThemeManager.single_color(self.scrollbar_color, self._appearance_mode),
+                               fill=ThemeManager.single_color(self.scrollbar_color, self._appearance_mode))
+
+    def clicked(self, event):
+        if self.orientation == "vertical":
+            value = ((event.y - self.border_spacing) / (self._current_height - 2 * self.border_spacing)) / self._widget_scaling
+        else:
+            value = ((event.x - self.border_spacing) / (self._current_width - 2 * self.border_spacing)) / self._widget_scaling
+
+        current_scrollbar_length = self.end_value - self.start_value
+        value = max(current_scrollbar_length / 2, min(value, 1 - (current_scrollbar_length / 2)))
+        self.start_value = value - (current_scrollbar_length / 2)
+        self.end_value = value + (current_scrollbar_length / 2)
+        self.draw()
+
+        if self.command is not None:
+            self.command('moveto', self.start_value)
+
+    def mouse_scroll_event(self, event=None):
+        if self.command is not None:
+            if sys.platform.startswith("win"):
+                self.command('scroll', -int(event.delta/40), 'units')
+            else:
+                self.command('scroll', -event.delta, 'units')
+

customtkinter/widgets/ctk_slider.py

@@ -9,7 +9,7 @@ from .widget_base_class import CTkBaseClass
 
 
 class CTkSlider(CTkBaseClass):
-    """ tkinter custom slider, always horizontal """
+    """ tkinter custom slider"""
 
     def __init__(self, *args,
                  bg_color=None,
@@ -30,6 +30,7 @@ class CTkSlider(CTkBaseClass):
                  command=None,
                  variable=None,
                  orient="horizontal",
+                 state="normal",
                  **kwargs):
 
         # set default dimensions according to orientation
@@ -44,7 +45,7 @@ class CTkSlider(CTkBaseClass):
             else:
                 height = 16
 
-        # transfer basic functionality (bg_color, size, appearance_mode, scaling) to CTkBaseClass
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
         super().__init__(*args, bg_color=bg_color, width=width, height=height, **kwargs)
 
         # color
@@ -60,7 +61,7 @@ class CTkSlider(CTkBaseClass):
         self.border_width = ThemeManager.theme["shape"]["slider_border_width"] if border_width == "default_theme" else border_width
         self.button_length = ThemeManager.theme["shape"]["slider_button_length"] if button_length == "default_theme" else button_length
         self.value = 0.5  # initial value of slider in percent
-        self.orient = orient
+        self.orientation = orient
         self.hover_state = False
         self.from_ = from_
         self.to = to
@@ -71,18 +72,19 @@ class CTkSlider(CTkBaseClass):
             self.corner_radius = self.button_corner_radius
 
         # callback and control variables
-        self.callback_function = command
+        self.command = command
         self.variable: tkinter.Variable = variable
         self.variable_callback_blocked = False
         self.variable_callback_name = None
+        self.state = state
 
         self.grid_rowconfigure(0, weight=1)
         self.grid_columnconfigure(0, weight=1)
 
         self.canvas = CTkCanvas(master=self,
                                 highlightthickness=0,
-                                width=self.apply_widget_scaling(self.desired_width),
-                                height=self.apply_widget_scaling(self.desired_height))
+                                width=self.apply_widget_scaling(self._desired_width),
+                                height=self.apply_widget_scaling(self._desired_height))
         self.canvas.grid(column=0, row=0, rowspan=1, columnspan=1, sticky="nswe")
         self.draw_engine = DrawEngine(self.canvas)
 
@@ -106,14 +108,14 @@ class CTkSlider(CTkBaseClass):
     def set_scaling(self, *args, **kwargs):
         super().set_scaling(*args, **kwargs)
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def set_dimensions(self, width=None, height=None):
         super().set_dimensions(width, height)
 
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width),
-                              height=self.apply_widget_scaling(self.desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def destroy(self):
@@ -124,22 +126,28 @@ class CTkSlider(CTkBaseClass):
         super().destroy()
 
     def set_cursor(self):
-        if Settings.cursor_manipulation_enabled:
+        if self.state == "normal" and Settings.cursor_manipulation_enabled:
             if sys.platform == "darwin":
                 self.configure(cursor="pointinghand")
             elif sys.platform.startswith("win"):
                 self.configure(cursor="hand2")
 
+        elif self.state == "disabled" and Settings.cursor_manipulation_enabled:
+            if sys.platform == "darwin":
+                self.configure(cursor="arrow")
+            elif sys.platform.startswith("win"):
+                self.configure(cursor="arrow")
+
     def draw(self, no_color_updates=False):
-        if self.orient.lower() == "horizontal":
+        if self.orientation.lower() == "horizontal":
             orientation = "w"
-        elif self.orient.lower() == "vertical":
+        elif self.orientation.lower() == "vertical":
             orientation = "s"
         else:
             orientation = "w"
 
-        requires_recoloring = self.draw_engine.draw_rounded_slider_with_border_and_button(self.apply_widget_scaling(self.current_width),
-                                                                                          self.apply_widget_scaling(self.current_height),
+        requires_recoloring = self.draw_engine.draw_rounded_slider_with_border_and_button(self.apply_widget_scaling(self._current_width),
+                                                                                          self.apply_widget_scaling(self._current_height),
                                                                                           self.apply_widget_scaling(self.corner_radius),
                                                                                           self.apply_widget_scaling(self.border_width),
                                                                                           self.apply_widget_scaling(self.button_length),
@@ -147,61 +155,71 @@ class CTkSlider(CTkBaseClass):
                                                                                           self.value, orientation)
 
         if no_color_updates is False or requires_recoloring:
-            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
             if self.border_color is None:
-                self.canvas.itemconfig("border_parts", fill=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                self.canvas.itemconfig("border_parts", fill=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.bg_color, self._appearance_mode))
             else:
-                self.canvas.itemconfig("border_parts", fill=ThemeManager.single_color(self.border_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.border_color, self.appearance_mode))
+                self.canvas.itemconfig("border_parts", fill=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.border_color, self._appearance_mode))
 
-            self.canvas.itemconfig("inner_parts", fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+            self.canvas.itemconfig("inner_parts", fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
 
             if self.progress_color is None:
-                self.canvas.itemconfig("progress_parts", fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                self.canvas.itemconfig("progress_parts", fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
             else:
-                self.canvas.itemconfig("progress_parts", fill=ThemeManager.single_color(self.progress_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.progress_color, self.appearance_mode))
+                self.canvas.itemconfig("progress_parts", fill=ThemeManager.single_color(self.progress_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.progress_color, self._appearance_mode))
 
-            self.canvas.itemconfig("slider_parts", fill=ThemeManager.single_color(self.button_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.button_color, self.appearance_mode))
+            if self.hover_state is True:
+                self.canvas.itemconfig("slider_parts",
+                                       fill=ThemeManager.single_color(self.button_hover_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.button_hover_color, self._appearance_mode))
+            else:
+                self.canvas.itemconfig("slider_parts",
+                                       fill=ThemeManager.single_color(self.button_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.button_color, self._appearance_mode))
 
     def clicked(self, event=None):
-        if self.orient.lower() == "horizontal":
-            self.value = (event.x / self.current_width) / self.widget_scaling
-        else:
-            self.value = 1 - (event.y / self.current_height) / self.widget_scaling
+        if self.state == "normal":
+            if self.orientation.lower() == "horizontal":
+                self.value = (event.x / self._current_width) / self._widget_scaling
+            else:
+                self.value = 1 - (event.y / self._current_height) / self._widget_scaling
 
-        if self.value > 1:
-            self.value = 1
-        if self.value < 0:
-            self.value = 0
+            if self.value > 1:
+                self.value = 1
+            if self.value < 0:
+                self.value = 0
 
-        self.output_value = self.round_to_step_size(self.from_ + (self.value * (self.to - self.from_)))
-        self.value = (self.output_value - self.from_) / (self.to - self.from_)
+            self.output_value = self.round_to_step_size(self.from_ + (self.value * (self.to - self.from_)))
+            self.value = (self.output_value - self.from_) / (self.to - self.from_)
 
-        self.draw(no_color_updates=False)
+            self.draw(no_color_updates=False)
 
-        if self.callback_function is not None:
-            self.callback_function(self.output_value)
+            if self.variable is not None:
+                self.variable_callback_blocked = True
+                self.variable.set(round(self.output_value) if isinstance(self.variable, tkinter.IntVar) else self.output_value)
+                self.variable_callback_blocked = False
 
-        if self.variable is not None:
-            self.variable_callback_blocked = True
-            self.variable.set(round(self.output_value) if isinstance(self.variable, tkinter.IntVar) else self.output_value)
-            self.variable_callback_blocked = False
+            if self.command is not None:
+                self.command(self.output_value)
 
     def on_enter(self, event=0):
-        self.hover_state = True
-        self.canvas.itemconfig("slider_parts", fill=ThemeManager.single_color(self.button_hover_color, self.appearance_mode),
-                               outline=ThemeManager.single_color(self.button_hover_color, self.appearance_mode))
+        if self.state == "normal":
+            self.hover_state = True
+            self.canvas.itemconfig("slider_parts",
+                                   fill=ThemeManager.single_color(self.button_hover_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.button_hover_color, self._appearance_mode))
 
     def on_leave(self, event=0):
         self.hover_state = False
-        self.canvas.itemconfig("slider_parts", fill=ThemeManager.single_color(self.button_color, self.appearance_mode),
-                               outline=ThemeManager.single_color(self.button_color, self.appearance_mode))
+        self.canvas.itemconfig("slider_parts",
+                               fill=ThemeManager.single_color(self.button_color, self._appearance_mode),
+                               outline=ThemeManager.single_color(self.button_color, self._appearance_mode))
 
     def round_to_step_size(self, value):
         if self.number_of_steps is not None:
@@ -231,9 +249,6 @@ class CTkSlider(CTkBaseClass):
 
         self.draw(no_color_updates=False)
 
-        if self.callback_function is not None:
-            self.callback_function(self.output_value)
-
         if self.variable is not None and not from_variable_callback:
             self.variable_callback_blocked = True
             self.variable.set(round(self.output_value) if isinstance(self.variable, tkinter.IntVar) else self.output_value)
@@ -243,22 +258,18 @@ class CTkSlider(CTkBaseClass):
         if not self.variable_callback_blocked:
             self.set(self.variable.get(), from_variable_callback=True)
 
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
+    def configure(self, require_redraw=False, **kwargs):
+        if "state" in kwargs:
+            self.state = kwargs["state"]
+            self.set_cursor()
+            require_redraw = True
+            del kwargs["state"]
 
         if "fg_color" in kwargs:
             self.fg_color = kwargs["fg_color"]
             require_redraw = True
             del kwargs["fg_color"]
 
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
-
         if "progress_color" in kwargs:
             if kwargs["progress_color"] is None:
                 self.progress_color = self.fg_color
@@ -300,7 +311,7 @@ class CTkSlider(CTkBaseClass):
             del kwargs["number_of_steps"]
 
         if "command" in kwargs:
-            self.callback_function = kwargs["command"]
+            self.command = kwargs["command"]
             del kwargs["command"]
 
         if "variable" in kwargs:
@@ -325,7 +336,4 @@ class CTkSlider(CTkBaseClass):
             self.set_dimensions(height=kwargs["height"])
             del kwargs["height"]
 
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)

customtkinter/widgets/ctk_switch.py

@@ -34,7 +34,7 @@ class CTkSwitch(CTkBaseClass):
                  state=tkinter.NORMAL,
                  **kwargs):
 
-        # transfer basic functionality (bg_color, size, appearance_mode, scaling) to CTkBaseClass
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
         super().__init__(*args, bg_color=bg_color, width=width, height=height, **kwargs)
 
         # color
@@ -44,7 +44,7 @@ class CTkSwitch(CTkBaseClass):
         self.button_color = ThemeManager.theme["color"]["switch_button"] if button_color == "default_theme" else button_color
         self.button_hover_color = ThemeManager.theme["color"]["switch_button_hover"] if button_hover_color == "default_theme" else button_hover_color
         self.text_color = ThemeManager.theme["color"]["text"] if text_color == "default_theme" else text_color
-        self.text_color_disabled = ThemeManager.theme["color"]["text_button_disabled"] if text_color_disabled == "default_theme" else text_color_disabled
+        self.text_color_disabled = ThemeManager.theme["color"]["text_disabled"] if text_color_disabled == "default_theme" else text_color_disabled
 
         # text
         self.text = text
@@ -62,11 +62,8 @@ class CTkSwitch(CTkBaseClass):
         self.onvalue = onvalue
         self.offvalue = offvalue
 
-        # if self.corner_radius < self.button_corner_radius:
-        #     self.corner_radius = self.button_corner_radius
-
         # callback and control variables
-        self.callback_function = command
+        self.command = command
         self.variable: tkinter.Variable = variable
         self.variable_callback_blocked = False
         self.variable_callback_name = None
@@ -79,14 +76,14 @@ class CTkSwitch(CTkBaseClass):
 
         self.bg_canvas = CTkCanvas(master=self,
                                    highlightthickness=0,
-                                   width=self.apply_widget_scaling(self.current_width),
-                                   height=self.apply_widget_scaling(self.current_height))
+                                   width=self.apply_widget_scaling(self._current_width),
+                                   height=self.apply_widget_scaling(self._current_height))
         self.bg_canvas.grid(row=0, column=0, padx=0, pady=0, columnspan=3, rowspan=1, sticky="nswe")
 
         self.canvas = CTkCanvas(master=self,
                                 highlightthickness=0,
-                                width=self.apply_widget_scaling(self.current_width),
-                                height=self.apply_widget_scaling(self.current_height))
+                                width=self.apply_widget_scaling(self._current_width),
+                                height=self.apply_widget_scaling(self._current_height))
         self.canvas.grid(row=0, column=0, padx=0, pady=0, columnspan=1, sticky="nswe")
         self.draw_engine = DrawEngine(self.canvas)
 
@@ -94,15 +91,25 @@ class CTkSwitch(CTkBaseClass):
         self.canvas.bind("<Leave>", self.on_leave)
         self.canvas.bind("<Button-1>", self.toggle)
 
-        self.set_cursor()
-        self.draw()  # initial draw
+        self.text_label = tkinter.Label(master=self,
+                                        bd=0,
+                                        text=self.text,
+                                        justify=tkinter.LEFT,
+                                        font=self.apply_font_scaling(self.text_font),
+                                        textvariable=self.textvariable)
+        self.text_label.grid(row=0, column=2, padx=0, pady=0, sticky="w")
+        self.text_label["anchor"] = "w"
 
-        if self.variable is not None:
+        self.text_label.bind("<Enter>", self.on_enter)
+        self.text_label.bind("<Leave>", self.on_leave)
+        self.text_label.bind("<Button-1>", self.toggle)
+
+        if self.variable is not None and self.variable != "":
             self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
-            if self.variable.get() == self.onvalue:
-                self.select(from_variable_callback=True)
-            elif self.variable.get() == self.offvalue:
-                self.deselect(from_variable_callback=True)
+            self.check_state = True if self.variable.get() == self.onvalue else False
+
+        self.draw()  # initial draw
+        self.set_cursor()
 
     def set_scaling(self, *args, **kwargs):
         super().set_scaling(*args, **kwargs)
@@ -110,8 +117,8 @@ class CTkSwitch(CTkBaseClass):
         self.grid_columnconfigure(1, weight=0, minsize=self.apply_widget_scaling(6))
         self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
-        self.bg_canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
-        self.canvas.configure(width=self.apply_widget_scaling(self.desired_width), height=self.apply_widget_scaling(self.desired_height))
+        self.bg_canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
     def destroy(self):
@@ -126,27 +133,36 @@ class CTkSwitch(CTkBaseClass):
             if self.state == tkinter.DISABLED:
                 if sys.platform == "darwin" and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="arrow")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="arrow")
                 elif sys.platform.startswith("win") and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="arrow")
-            else:
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="arrow")
+
+            elif self.state == tkinter.NORMAL:
                 if sys.platform == "darwin" and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="pointinghand")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="pointinghand")
                 elif sys.platform.startswith("win") and Settings.cursor_manipulation_enabled:
                     self.canvas.configure(cursor="hand2")
+                    if self.text_label is not None:
+                        self.text_label.configure(cursor="hand2")
 
     def draw(self, no_color_updates=False):
 
         if self.check_state is True:
-            requires_recoloring = self.draw_engine.draw_rounded_slider_with_border_and_button(self.apply_widget_scaling(self.current_width),
-                                                                                              self.apply_widget_scaling(self.current_height),
+            requires_recoloring = self.draw_engine.draw_rounded_slider_with_border_and_button(self.apply_widget_scaling(self._current_width),
+                                                                                              self.apply_widget_scaling(self._current_height),
                                                                                               self.apply_widget_scaling(self.corner_radius),
                                                                                               self.apply_widget_scaling(self.border_width),
                                                                                               self.apply_widget_scaling(self.button_length),
                                                                                               self.apply_widget_scaling(self.corner_radius),
                                                                                               1, "w")
         else:
-            requires_recoloring = self.draw_engine.draw_rounded_slider_with_border_and_button(self.apply_widget_scaling(self.current_width),
-                                                                                              self.apply_widget_scaling(self.current_height),
+            requires_recoloring = self.draw_engine.draw_rounded_slider_with_border_and_button(self.apply_widget_scaling(self._current_width),
+                                                                                              self.apply_widget_scaling(self._current_height),
                                                                                               self.apply_widget_scaling(self.corner_radius),
                                                                                               self.apply_widget_scaling(self.border_width),
                                                                                               self.apply_widget_scaling(self.button_length),
@@ -154,53 +170,35 @@ class CTkSwitch(CTkBaseClass):
                                                                                               0, "w")
 
         if no_color_updates is False or requires_recoloring:
-            self.bg_canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
-            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+            self.bg_canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
             if self.border_color is None:
-                self.canvas.itemconfig("border_parts", fill=ThemeManager.single_color(self.bg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+                self.canvas.itemconfig("border_parts", fill=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.bg_color, self._appearance_mode))
             else:
-                self.canvas.itemconfig("border_parts", fill=ThemeManager.single_color(self.border_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.border_color, self.appearance_mode))
+                self.canvas.itemconfig("border_parts", fill=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.border_color, self._appearance_mode))
 
-            self.canvas.itemconfig("inner_parts", fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+            self.canvas.itemconfig("inner_parts", fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
 
             if self.progress_color is None:
-                self.canvas.itemconfig("progress_parts", fill=ThemeManager.single_color(self.fg_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.fg_color, self.appearance_mode))
+                self.canvas.itemconfig("progress_parts", fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
             else:
-                self.canvas.itemconfig("progress_parts", fill=ThemeManager.single_color(self.progress_color, self.appearance_mode),
-                                       outline=ThemeManager.single_color(self.progress_color, self.appearance_mode))
+                self.canvas.itemconfig("progress_parts", fill=ThemeManager.single_color(self.progress_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.progress_color, self._appearance_mode))
 
-            self.canvas.itemconfig("slider_parts", fill=ThemeManager.single_color(self.button_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.button_color, self.appearance_mode))
-
-        if self.text_label is None:
-            self.text_label = tkinter.Label(master=self,
-                                            bd=0,
-                                            text=self.text,
-                                            justify=tkinter.LEFT,
-                                            font=self.apply_font_scaling(self.text_font))
-            self.text_label.grid(row=0, column=2, padx=0, pady=0, sticky="w")
-            self.text_label["anchor"] = "w"
-            if self.textvariable is not None:
-                self.text_label.configure(textvariable=self.textvariable)
+            self.canvas.itemconfig("slider_parts", fill=ThemeManager.single_color(self.button_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.button_color, self._appearance_mode))
 
         if self.state == tkinter.DISABLED:
-            self.text_label.configure(fg=(ThemeManager.single_color(self.text_color_disabled, self.appearance_mode)))
+            self.text_label.configure(fg=(ThemeManager.single_color(self.text_color_disabled, self._appearance_mode)))
         else:
-            self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self.appearance_mode))
+            self.text_label.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
 
-        self.text_label.configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
-
-        self.set_text(self.text)
-
-    def set_text(self, text):
-        self.text = text
-        if self.text_label is not None:
-            self.text_label.configure(text=self.text)
+        self.text_label.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
     def toggle(self, event=None):
         if self.state is not tkinter.DISABLED:
@@ -211,23 +209,20 @@ class CTkSwitch(CTkBaseClass):
 
             self.draw(no_color_updates=True)
 
-            if self.callback_function is not None:
-                self.callback_function()
-
             if self.variable is not None:
                 self.variable_callback_blocked = True
                 self.variable.set(self.onvalue if self.check_state is True else self.offvalue)
                 self.variable_callback_blocked = False
 
+            if self.command is not None:
+                self.command()
+
     def select(self, from_variable_callback=False):
         if self.state is not tkinter.DISABLED or from_variable_callback:
             self.check_state = True
 
             self.draw(no_color_updates=True)
 
-            if self.callback_function is not None:
-                self.callback_function()
-
             if self.variable is not None and not from_variable_callback:
                 self.variable_callback_blocked = True
                 self.variable.set(self.onvalue)
@@ -239,9 +234,6 @@ class CTkSwitch(CTkBaseClass):
 
             self.draw(no_color_updates=True)
 
-            if self.callback_function is not None:
-                self.callback_function()
-
             if self.variable is not None and not from_variable_callback:
                 self.variable_callback_blocked = True
                 self.variable.set(self.offvalue)
@@ -254,13 +246,13 @@ class CTkSwitch(CTkBaseClass):
         self.hover_state = True
 
         if self.state is not tkinter.DISABLED:
-            self.canvas.itemconfig("slider_parts", fill=ThemeManager.single_color(self.button_hover_color, self.appearance_mode),
-                                   outline=ThemeManager.single_color(self.button_hover_color, self.appearance_mode))
+            self.canvas.itemconfig("slider_parts", fill=ThemeManager.single_color(self.button_hover_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.button_hover_color, self._appearance_mode))
 
     def on_leave(self, event=0):
         self.hover_state = False
-        self.canvas.itemconfig("slider_parts", fill=ThemeManager.single_color(self.button_color, self.appearance_mode),
-                               outline=ThemeManager.single_color(self.button_color, self.appearance_mode))
+        self.canvas.itemconfig("slider_parts", fill=ThemeManager.single_color(self.button_color, self._appearance_mode),
+                               outline=ThemeManager.single_color(self.button_color, self._appearance_mode))
 
     def variable_callback(self, var_name, index, mode):
         if not self.variable_callback_blocked:
@@ -269,82 +261,64 @@ class CTkSwitch(CTkBaseClass):
             elif self.variable.get() == self.offvalue:
                 self.deselect(from_variable_callback=True)
 
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
+    def configure(self, require_redraw=False, **kwargs):
+        if "text" in kwargs:
+            self.text = kwargs.pop("text")
+            self.text_label.configure(text=self.text)
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
         if "state" in kwargs:
-            self.state = kwargs["state"]
+            self.state = kwargs.pop("state")
             self.set_cursor()
             require_redraw = True
-            del kwargs["state"]
 
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
-            del kwargs["fg_color"]
-
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
 
         if "progress_color" in kwargs:
-            if kwargs["progress_color"] is None:
+            new_progress_color = kwargs.pop("progress_color")
+            if new_progress_color is None:
                 self.progress_color = self.fg_color
             else:
-                self.progress_color = kwargs["progress_color"]
+                self.progress_color = new_progress_color
             require_redraw = True
-            del kwargs["progress_color"]
 
         if "button_color" in kwargs:
-            self.button_color = kwargs["button_color"]
+            self.button_color = kwargs.pop("button_color")
             require_redraw = True
-            del kwargs["button_color"]
 
         if "button_hover_color" in kwargs:
-            self.button_hover_color = kwargs["button_hover_color"]
+            self.button_hover_color = kwargs.pop("button_hover_color")
             require_redraw = True
-            del kwargs["button_hover_color"]
 
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
-            del kwargs["border_color"]
 
         if "border_width" in kwargs:
-            self.border_width = kwargs["border_width"]
+            self.border_width = kwargs.pop("border_width")
             require_redraw = True
-            del kwargs["border_width"]
 
         if "command" in kwargs:
-            self.callback_function = kwargs["command"]
-            del kwargs["command"]
+            self.command = kwargs.pop("command")
 
         if "textvariable" in kwargs:
-            self.text_label.configure(textvariable=kwargs["textvariable"])
-            del kwargs["textvariable"]
+            self.textvariable = kwargs.pop("textvariable")
+            self.text_label.configure(textvariable=self.textvariable)
 
         if "variable" in kwargs:
-            if self.variable is not None:
+            if self.variable is not None and self.variable != "":
                 self.variable.trace_remove("write", self.variable_callback_name)
 
-            self.variable = kwargs["variable"]
+            self.variable = kwargs.pop("variable")
 
             if self.variable is not None and self.variable != "":
                 self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
-                if self.variable.get() == self.onvalue:
-                    self.select(from_variable_callback=True)
-                elif self.variable.get() == self.offvalue:
-                    self.deselect(from_variable_callback=True)
-            else:
-                self.variable = None
+                self.check_state = True if self.variable.get() == self.onvalue else False
+                require_redraw = True
 
-            del kwargs["variable"]
-
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)

customtkinter/widgets/ctk_textbox.py

@@ -0,0 +1,176 @@
+import tkinter
+
+from .ctk_canvas import CTkCanvas
+from ..theme_manager import ThemeManager
+from ..draw_engine import DrawEngine
+from .widget_base_class import CTkBaseClass
+
+
+class CTkTextbox(CTkBaseClass):
+    def __init__(self, *args,
+                 bg_color=None,
+                 fg_color="default_theme",
+                 border_color="default_theme",
+                 border_width="default_theme",
+                 corner_radius="default_theme",
+                 text_font="default_theme",
+                 text_color="default_theme",
+                 width=200,
+                 height=200,
+                 **kwargs):
+
+        # transfer basic functionality (bg_color, size, _appearance_mode, scaling) to CTkBaseClass
+        if "master" in kwargs:
+            super().__init__(*args, bg_color=bg_color, width=width, height=height, master=kwargs.pop("master"))
+        else:
+            super().__init__(*args, bg_color=bg_color, width=width, height=height)
+
+        # color
+        self.fg_color = ThemeManager.theme["color"]["entry"] if fg_color == "default_theme" else fg_color
+        self.border_color = ThemeManager.theme["color"]["frame_border"] if border_color == "default_theme" else border_color
+        self.text_color = ThemeManager.theme["color"]["text"] if text_color == "default_theme" else text_color
+
+        # shape
+        self.corner_radius = ThemeManager.theme["shape"]["frame_corner_radius"] if corner_radius == "default_theme" else corner_radius
+        self.border_width = ThemeManager.theme["shape"]["frame_border_width"] if border_width == "default_theme" else border_width
+
+        # text
+        self.text_font = (ThemeManager.theme["text"]["font"], ThemeManager.theme["text"]["size"]) if text_font == "default_theme" else text_font
+
+        # configure 1x1 grid
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=1)
+
+        self.canvas = CTkCanvas(master=self,
+                                highlightthickness=0,
+                                width=self.apply_widget_scaling(self._current_width),
+                                height=self.apply_widget_scaling(self._current_height))
+        self.canvas.grid(row=0, column=0, padx=0, pady=0, rowspan=1, columnspan=1, sticky="nsew")
+        self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+        self.draw_engine = DrawEngine(self.canvas)
+
+        for arg in ["highlightthickness", "fg", "bg", "font", "width", "height"]:
+            kwargs.pop(arg, None)
+        self.textbox = tkinter.Text(self,
+                                    fg=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                                    width=0,
+                                    height=0,
+                                    font=self.text_font,
+                                    highlightthickness=0,
+                                    relief="flat",
+                                    insertbackground=ThemeManager.single_color(("black", "white"), self._appearance_mode),
+                                    bg=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                    **kwargs)
+        self.textbox.grid(row=0, column=0, padx=self.corner_radius, pady=self.corner_radius, rowspan=1, columnspan=1, sticky="nsew")
+
+        self.bind('<Configure>', self.update_dimensions_event)
+        self.draw()
+
+    def set_scaling(self, *args, **kwargs):
+        super().set_scaling(*args, **kwargs)
+
+        self.textbox.configure(font=self.apply_font_scaling(self.text_font))
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
+        self.draw()
+
+    def set_dimensions(self, width=None, height=None):
+        super().set_dimensions(width, height)
+
+        self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
+                              height=self.apply_widget_scaling(self._desired_height))
+        self.draw()
+
+    def draw(self, no_color_updates=False):
+
+        requires_recoloring = self.draw_engine.draw_rounded_rect_with_border(self.apply_widget_scaling(self._current_width),
+                                                                             self.apply_widget_scaling(self._current_height),
+                                                                             self.apply_widget_scaling(self.corner_radius),
+                                                                             self.apply_widget_scaling(self.border_width))
+
+        if no_color_updates is False or requires_recoloring:
+            if self.fg_color is None:
+                self.canvas.itemconfig("inner_parts",
+                                       fill=ThemeManager.single_color(self.bg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+            else:
+                self.canvas.itemconfig("inner_parts",
+                                       fill=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                       outline=ThemeManager.single_color(self.fg_color, self._appearance_mode))
+
+            self.canvas.itemconfig("border_parts",
+                                   fill=ThemeManager.single_color(self.border_color, self._appearance_mode),
+                                   outline=ThemeManager.single_color(self.border_color, self._appearance_mode))
+            self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+
+            self.textbox.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                                   bg=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                                   insertbackground=ThemeManager.single_color(("black", "white"), self._appearance_mode))
+
+        self.canvas.tag_lower("inner_parts")
+        self.canvas.tag_lower("border_parts")
+
+    def yview(self, *args):
+        return self.textbox.yview(*args)
+
+    def xview(self, *args):
+        return self.textbox.xview(*args)
+
+    def insert(self, *args, **kwargs):
+        return self.textbox.insert(*args, **kwargs)
+
+    def focus(self):
+        return self.textbox.focus()
+
+    def tag_add(self, *args, **kwargs):
+        return self.textbox.tag_add(*args, **kwargs)
+
+    def tag_config(self, *args, **kwargs):
+        return self.textbox.tag_config(*args, **kwargs)
+
+    def tag_configure(self, *args, **kwargs):
+        return self.textbox.tag_configure(*args, **kwargs)
+
+    def tag_remove(self, *args, **kwargs):
+        return self.textbox.tag_remove(*args, **kwargs)
+
+    def configure(self, require_redraw=False, **kwargs):
+        if "fg_color" in kwargs:
+            self.fg_color = kwargs.pop("fg_color")
+            require_redraw = True
+
+            # check if CTk widgets are children of the frame and change their bg_color to new frame fg_color
+            for child in self.winfo_children():
+                if isinstance(child, CTkBaseClass):
+                    child.configure(bg_color=self.fg_color)
+
+        if "border_color" in kwargs:
+            self.border_color = kwargs.pop("border_color")
+            require_redraw = True
+
+        if "corner_radius" in kwargs:
+            self.corner_radius = kwargs.pop("corner_radius")
+            require_redraw = True
+
+        if "border_width" in kwargs:
+            self.border_width = kwargs.pop("border_width")
+            require_redraw = True
+
+        if "width" in kwargs:
+            self.set_dimensions(width=kwargs.pop("width"))
+
+        if "height" in kwargs:
+            self.set_dimensions(height=kwargs.pop("height"))
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.textbox.configure(font=self.apply_font_scaling(self.text_font))
+
+        if "font" in kwargs:
+            raise ValueError("No attribute named font. Use text_font instead of font for CTk widgets")
+
+        if "bg_color" in kwargs:
+            super().configure(bg_color=kwargs.pop("bg_color"), require_redraw=require_redraw)
+        else:
+            super().configure(require_redraw=require_redraw)
+
+        self.textbox.configure(**kwargs)

customtkinter/widgets/dropdown_menu.py

@@ -0,0 +1,170 @@
+import tkinter
+import sys
+import copy
+import re
+from typing import Union
+
+from ..theme_manager import ThemeManager
+from ..appearance_mode_tracker import AppearanceModeTracker
+from ..scaling_tracker import ScalingTracker
+
+
+class DropdownMenu(tkinter.Menu):
+    def __init__(self, *args,
+                 min_character_width=18,
+                 fg_color="default_theme",
+                 hover_color="default_theme",
+                 text_color="default_theme",
+                 text_font="default_theme",
+                 command=None,
+                 values=None,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+
+        ScalingTracker.add_widget(self.set_scaling, self)
+        self._widget_scaling = ScalingTracker.get_widget_scaling(self)
+        self._spacing_scaling = ScalingTracker.get_spacing_scaling(self)
+
+        AppearanceModeTracker.add(self.set_appearance_mode, self)
+        self._appearance_mode = AppearanceModeTracker.get_mode()  # 0: "Light" 1: "Dark"
+
+        self.min_character_width = min_character_width
+        self.fg_color = ThemeManager.theme["color"]["dropdown_color"] if fg_color == "default_theme" else fg_color
+        self.hover_color = ThemeManager.theme["color"]["dropdown_hover"] if hover_color == "default_theme" else hover_color
+        self.text_color = ThemeManager.theme["color"]["text"] if text_color == "default_theme" else text_color
+        self.text_font = (ThemeManager.theme["text"]["font"], ThemeManager.theme["text"]["size"]) if text_font == "default_theme" else text_font
+
+        self.configure_menu_for_platforms()
+
+        self.values = values
+        self.command = command
+
+        self.add_menu_commands()
+
+    def configure_menu_for_platforms(self):
+        """ apply platform specific appearance attributes """
+
+        if sys.platform == "darwin":
+            self.configure(tearoff=False,
+                           font=self.apply_font_scaling(self.text_font))
+
+        elif sys.platform.startswith("win"):
+            self.configure(tearoff=False,
+                           relief="flat",
+                           activebackground=ThemeManager.single_color(self.hover_color, self._appearance_mode),
+                           borderwidth=0,
+                           activeborderwidth=self.apply_widget_scaling(4),
+                           bg=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                           fg=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                           activeforeground=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                           font=self.apply_font_scaling(self.text_font),
+                           cursor="hand2")
+
+        else:
+            self.configure(tearoff=False,
+                           relief="flat",
+                           activebackground=ThemeManager.single_color(self.hover_color, self._appearance_mode),
+                           borderwidth=0,
+                           activeborderwidth=0,
+                           bg=ThemeManager.single_color(self.fg_color, self._appearance_mode),
+                           fg=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                           activeforeground=ThemeManager.single_color(self.text_color, self._appearance_mode),
+                           font=self.apply_font_scaling(self.text_font))
+
+    def add_menu_commands(self):
+        if sys.platform.startswith("linux"):
+            for value in self.values:
+                self.add_command(label="  " + value.ljust(self.min_character_width) + "  ",
+                                 command=lambda v=value: self.button_callback(v),
+                                 compound="left")
+        else:
+            for value in self.values:
+                self.add_command(label=value.ljust(self.min_character_width),
+                                 command=lambda v=value: self.button_callback(v),
+                                 compound="left")
+
+    def open(self, x: Union[int, float], y: Union[int, float]):
+        if sys.platform == "darwin":
+            y += self.apply_widget_scaling(8)
+        else:
+            y += self.apply_widget_scaling(3)
+
+        if sys.platform == "darwin" or sys.platform.startswith("win"):
+            self.post(int(x), int(y))
+        else:  # Linux
+            self.tk_popup(int(x), int(y))
+
+    def button_callback(self, value):
+        if self.command is not None:
+            self.command(value)
+
+    def configure(self, **kwargs):
+        if "values" in kwargs:
+            self.values = kwargs.pop("values")
+            self.delete(0, "end")  # delete all old commands
+            self.add_menu_commands()
+
+        if "fg_color" in kwargs:
+            self.fg_color = kwargs.pop("fg_color")
+            self.configure(bg=ThemeManager.single_color(self.fg_color, self._appearance_mode))
+
+        if "hover_color" in kwargs:
+            self.hover_color = kwargs.pop("hover_color")
+            self.configure(activebackground=ThemeManager.single_color(self.hover_color, self._appearance_mode))
+
+        if "text_color" in kwargs:
+            self.text_color = kwargs.pop("text_color")
+            self.configure(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.configure(font=self.apply_font_scaling(self.text_font))
+
+        super().configure(**kwargs)
+
+    def apply_widget_scaling(self, value: Union[int, float, str]) -> Union[float, str]:
+        if isinstance(value, (int, float)):
+            return value * self._widget_scaling
+        else:
+            return value
+
+    def apply_font_scaling(self, font):
+        if type(font) == tuple or type(font) == list:
+            font_list = list(font)
+            for i in range(len(font_list)):
+                if (type(font_list[i]) == int or type(font_list[i]) == float) and font_list[i] < 0:
+                    font_list[i] = int(font_list[i] * self._widget_scaling)
+            return tuple(font_list)
+
+        elif type(font) == str:
+            for negative_number in re.findall(r" -\d* ", font):
+                font = font.replace(negative_number, f" {int(int(negative_number) * self._widget_scaling)} ")
+            return font
+
+        elif isinstance(font, tkinter.font.Font):
+            new_font_object = copy.copy(font)
+            if font.cget("size") < 0:
+                new_font_object.config(size=int(font.cget("size") * self._widget_scaling))
+            return new_font_object
+
+        else:
+            return font
+
+    def set_scaling(self, new_widget_scaling, new_spacing_scaling, new_window_scaling):
+        self._widget_scaling = new_widget_scaling
+        self._spacing_scaling = new_spacing_scaling
+
+        self.configure(font=self.apply_font_scaling(self.text_font))
+
+        if sys.platform.startswith("win"):
+            self.configure(activeborderwidth=self.apply_widget_scaling(4))
+
+    def set_appearance_mode(self, mode_string):
+        """ colors won't update on appearance mode change when dropdown is open, because it's not necessary """
+
+        if mode_string.lower() == "dark":
+            self._appearance_mode = 1
+        elif mode_string.lower() == "light":
+            self._appearance_mode = 0
+
+        self.configure_menu_for_platforms()

customtkinter/widgets/widget_base_class.py

@@ -17,38 +17,49 @@ from ..theme_manager import ThemeManager
 
 
 class CTkBaseClass(tkinter.Frame):
-    def __init__(self, *args, bg_color=None, width, height, **kwargs):
+    """ Base class of every CTk widget, handles the dimensions, bg_color,
+        appearance_mode changes, scaling, bg changes of master if master is not a CTk widget """
+
+    def __init__(self,
+                 *args,
+                 bg_color: Union[str, tuple] = None,
+                 width: int,
+                 height: int,
+                 **kwargs):
+
         super().__init__(*args, width=width, height=height, **kwargs)  # set desired size of underlying tkinter.Frame
 
-        self.bg_color = self.detect_color_of_master() if bg_color is None else bg_color
+        # dimensions
+        self._current_width = width  # _current_width and _current_height in pixel, represent current size of the widget
+        self._current_height = height  # _current_width and _current_height are independent of the scale
+        self._desired_width = width  # _desired_width and _desired_height, represent desired size set by width and height
+        self._desired_height = height
 
-        self.current_width = width  # current_width and current_height in pixel, represent current size of the widget (not the desired size by init)
-        self.current_height = height  # current_width and current_height are independent of the scale
-        self.desired_width = width
-        self.desired_height = height
+        # scaling
+        ScalingTracker.add_widget(self.set_scaling, self)  # add callback for automatic scaling changes
+        self._widget_scaling = ScalingTracker.get_widget_scaling(self)
+        self._spacing_scaling = ScalingTracker.get_spacing_scaling(self)
 
-        # add set_scaling method to callback list of ScalingTracker for automatic scaling changes
-        ScalingTracker.add_widget(self.set_scaling, self)
-        self.widget_scaling = ScalingTracker.get_widget_scaling(self)
-        self.spacing_scaling = ScalingTracker.get_spacing_scaling(self)
-
-        super().configure(width=self.apply_widget_scaling(self.desired_width),
-                          height=self.apply_widget_scaling(self.desired_height))
+        super().configure(width=self.apply_widget_scaling(self._desired_width),
+                          height=self.apply_widget_scaling(self._desired_height))
 
         # save latest geometry function and kwargs
         class GeometryCallDict(TypedDict):
             function: Callable
             kwargs: dict
 
-        self.last_geometry_manager_call: Union[GeometryCallDict, None] = None
+        self._last_geometry_manager_call: Union[GeometryCallDict, None] = None
 
         # add set_appearance_mode method to callback list of AppearanceModeTracker for appearance mode changes
         AppearanceModeTracker.add(self.set_appearance_mode, self)
-        self.appearance_mode = AppearanceModeTracker.get_mode()  # 0: "Light" 1: "Dark"
+        self._appearance_mode = AppearanceModeTracker.get_mode()  # 0: "Light" 1: "Dark"
 
-        super().configure(bg=ThemeManager.single_color(self.bg_color, self.appearance_mode))
+        # background color
+        self.bg_color = self.detect_color_of_master() if bg_color is None else bg_color
 
-        # overwrite configure methods of master when master is tkinter widget, so that bg changes get applied on child CTk widget too
+        super().configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
+
+        # overwrite configure methods of master when master is tkinter widget, so that bg changes get applied on child CTk widget as well
         if isinstance(self.master, (tkinter.Tk, tkinter.Toplevel, tkinter.Frame)) and not isinstance(self.master, (CTkBaseClass, CTk, CTkToplevel)):
             master_old_configure = self.master.config
 
@@ -74,15 +85,15 @@ class CTkBaseClass(tkinter.Frame):
         super().destroy()
 
     def place(self, **kwargs):
-        self.last_geometry_manager_call = {"function": super().place, "kwargs": kwargs}
+        self._last_geometry_manager_call = {"function": super().place, "kwargs": kwargs}
         super().place(**self.apply_argument_scaling(kwargs))
 
     def pack(self, **kwargs):
-        self.last_geometry_manager_call = {"function": super().pack, "kwargs": kwargs}
+        self._last_geometry_manager_call = {"function": super().pack, "kwargs": kwargs}
         super().pack(**self.apply_argument_scaling(kwargs))
 
     def grid(self, **kwargs):
-        self.last_geometry_manager_call = {"function": super().grid, "kwargs": kwargs}
+        self._last_geometry_manager_call = {"function": super().grid, "kwargs": kwargs}
         super().grid(**self.apply_argument_scaling(kwargs))
 
     def apply_argument_scaling(self, kwargs: dict) -> dict:
@@ -106,32 +117,27 @@ class CTkBaseClass(tkinter.Frame):
 
         return scaled_kwargs
 
-    def config(self, *args, **kwargs):
-        self.configure(*args, **kwargs)
-
-    def configure(self, *args, **kwargs):
+    def configure(self, require_redraw=False, **kwargs):
         """ basic configure with bg_color support, to be overridden """
 
-        require_redraw = False
-
         if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
+            new_bg_color = kwargs.pop("bg_color")
+            if new_bg_color is None:
                 self.bg_color = self.detect_color_of_master()
             else:
-                self.bg_color = kwargs["bg_color"]
+                self.bg_color = new_bg_color
             require_redraw = True
-            del kwargs["bg_color"]
 
-        super().configure(*args, **kwargs)
+        super().configure(**kwargs)
 
         if require_redraw:
             self.draw()
 
     def update_dimensions_event(self, event):
-        # only redraw if dimensions changed (for performance)
-        if round(self.current_width) != round(event.width / self.widget_scaling) or round(self.current_height) != round(event.height / self.widget_scaling):
-            self.current_width = (event.width / self.widget_scaling)  # adjust current size according to new size given by event
-            self.current_height = (event.height / self.widget_scaling)  # current_width and current_height are independent of the scale
+        # only redraw if dimensions changed (for performance), independent of scaling
+        if round(self._current_width) != round(event.width / self._widget_scaling) or round(self._current_height) != round(event.height / self._widget_scaling):
+            self._current_width = (event.width / self._widget_scaling)  # adjust current size according to new size given by event
+            self._current_height = (event.height / self._widget_scaling)  # _current_width and _current_height are independent of the scale
 
             self.draw(no_color_updates=True)  # faster drawing without color changes
 
@@ -141,15 +147,15 @@ class CTkBaseClass(tkinter.Frame):
         if master_widget is None:
             master_widget = self.master
 
-        if isinstance(master_widget, CTkBaseClass) and hasattr(master_widget, "fg_color"):  # master is CTkFrame
+        if isinstance(master_widget, (CTkBaseClass, CTk, CTkToplevel)) and hasattr(master_widget, "fg_color"):
             if master_widget.fg_color is not None:
                 return master_widget.fg_color
 
             # if fg_color of master is None, try to retrieve fg_color from master of master
             elif hasattr(master_widget.master, "master"):
-                return self.detect_color_of_master(self.master.master)
+                return self.detect_color_of_master(master_widget.master)
 
-        elif isinstance(master_widget, (ttk.Frame, ttk.LabelFrame, ttk.Notebook)):  # master is ttk widget
+        elif isinstance(master_widget, (ttk.Frame, ttk.LabelFrame, ttk.Notebook, ttk.Label)):  # master is ttk widget
             try:
                 ttk_style = ttk.Style()
                 return ttk_style.lookup(master_widget.winfo_class(), 'background')
@@ -164,45 +170,40 @@ class CTkBaseClass(tkinter.Frame):
 
     def set_appearance_mode(self, mode_string):
         if mode_string.lower() == "dark":
-            self.appearance_mode = 1
+            self._appearance_mode = 1
         elif mode_string.lower() == "light":
-            self.appearance_mode = 0
-
-        if isinstance(self.master, (CTkBaseClass, CTk)) and hasattr(self.master, "fg_color"):
-            self.bg_color = self.master.fg_color
-        else:
-            self.bg_color = self.master.cget("bg")
+            self._appearance_mode = 0
 
         self.draw()
 
     def set_scaling(self, new_widget_scaling, new_spacing_scaling, new_window_scaling):
-        self.widget_scaling = new_widget_scaling
-        self.spacing_scaling = new_spacing_scaling
+        self._widget_scaling = new_widget_scaling
+        self._spacing_scaling = new_spacing_scaling
 
-        super().configure(width=self.apply_widget_scaling(self.desired_width),
-                          height=self.apply_widget_scaling(self.desired_height))
+        super().configure(width=self.apply_widget_scaling(self._desired_width),
+                          height=self.apply_widget_scaling(self._desired_height))
 
-        if self.last_geometry_manager_call is not None:
-            self.last_geometry_manager_call["function"](**self.apply_argument_scaling(self.last_geometry_manager_call["kwargs"]))
+        if self._last_geometry_manager_call is not None:
+            self._last_geometry_manager_call["function"](**self.apply_argument_scaling(self._last_geometry_manager_call["kwargs"]))
 
     def set_dimensions(self, width=None, height=None):
         if width is not None:
-            self.desired_width = width
+            self._desired_width = width
         if height is not None:
-            self.desired_height = height
+            self._desired_height = height
 
-        super().configure(width=self.apply_widget_scaling(self.desired_width),
-                          height=self.apply_widget_scaling(self.desired_height))
+        super().configure(width=self.apply_widget_scaling(self._desired_width),
+                          height=self.apply_widget_scaling(self._desired_height))
 
-    def apply_widget_scaling(self, value):
+    def apply_widget_scaling(self, value: Union[int, float, str]) -> Union[float, str]:
         if isinstance(value, (int, float)):
-            return value * self.widget_scaling
+            return value * self._widget_scaling
         else:
             return value
 
-    def apply_spacing_scaling(self, value):
+    def apply_spacing_scaling(self, value: Union[int, float, str]) -> Union[float, str]:
         if isinstance(value, (int, float)):
-            return value * self.spacing_scaling
+            return value * self._spacing_scaling
         else:
             return value
 
@@ -211,25 +212,23 @@ class CTkBaseClass(tkinter.Frame):
             font_list = list(font)
             for i in range(len(font_list)):
                 if (type(font_list[i]) == int or type(font_list[i]) == float) and font_list[i] < 0:
-                    font_list[i] = int(font_list[i] * self.widget_scaling)
+                    font_list[i] = int(font_list[i] * self._widget_scaling)
             return tuple(font_list)
 
         elif type(font) == str:
             for negative_number in re.findall(r" -\d* ", font):
-                font = font.replace(negative_number, f" {int(int(negative_number) * self.widget_scaling)} ")
+                font = font.replace(negative_number, f" {int(int(negative_number) * self._widget_scaling)} ")
             return font
 
         elif isinstance(font, tkinter.font.Font):
             new_font_object = copy.copy(font)
             if font.cget("size") < 0:
-                new_font_object.config(size=int(font.cget("size") * self.widget_scaling))
+                new_font_object.config(size=int(font.cget("size") * self._widget_scaling))
             return new_font_object
 
         else:
             return font
 
-    def draw(self, no_color_updates=False):
+    def draw(self, no_color_updates: bool = False):
         """ abstract of draw method to be overridden """
         pass
-
-

customtkinter/windows/ctk_input_dialog.py

@@ -42,6 +42,8 @@ class CTkInputDialog:
         self.top.focus_force()
         self.top.grab_set()
 
+        self.top.protocol("WM_DELETE_WINDOW", self.on_closing)
+
         self.top.after(10, self.create_widgets)  # create widgets with slight delay, to avoid white flickering of background
 
     def create_widgets(self):
@@ -95,6 +97,9 @@ class CTkInputDialog:
         self.user_input = self.entry.get()
         self.running = False
 
+    def on_closing(self):
+        self.running = False
+
     def cancel_event(self):
         self.running = False
 
@@ -102,8 +107,12 @@ class CTkInputDialog:
         self.running = True
 
         while self.running:
-            self.top.update()
-            time.sleep(0.01)
+            try:
+                self.top.update()
+            except Exception:
+                return self.user_input
+            finally:
+                time.sleep(0.01)
 
         time.sleep(0.05)
         self.top.destroy()

customtkinter/windows/ctk_tk.py

@@ -52,7 +52,10 @@ class CTk(tkinter.Tk):
         super().title("CTk")
         self.geometry(f"{self.current_width}x{self.current_height}")
 
-        self.window_exists = False  # indicates if the window is already shown through .update or .mainloop
+        self.state_before_windows_set_titlebar_color = None
+        self.window_exists = False  # indicates if the window is already shown through update() or mainloop() after init
+        self.withdraw_called_before_window_exists = False  # indicates if withdraw() was called before window is first shown through update() or mainloop()
+        self.iconify_called_before_window_exists = False  # indicates if iconify() was called before window is first shown through update() or mainloop()
 
         if sys.platform.startswith("win"):
             if self.appearance_mode == 1:
@@ -62,17 +65,23 @@ class CTk(tkinter.Tk):
 
         self.bind('<Configure>', self.update_dimensions_event)
 
-    def update_dimensions_event(self, event=None):
-        detected_width = self.winfo_width()  # detect current window size
-        detected_height = self.winfo_height()
+        self.block_update_dimensions_event = False
 
-        if self.current_width != round(detected_width / self.window_scaling) or self.current_height != round(detected_height / self.window_scaling):
-            self.current_width = round(detected_width / self.window_scaling)  # adjust current size according to new size given by event
-            self.current_height = round(detected_height / self.window_scaling)  # current_width and current_height are independent of the scale
+    def update_dimensions_event(self, event=None):
+        if not self.block_update_dimensions_event:
+            detected_width = self.winfo_width()  # detect current window size
+            detected_height = self.winfo_height()
+
+            if self.current_width != round(detected_width / self.window_scaling) or self.current_height != round(detected_height / self.window_scaling):
+                self.current_width = round(detected_width / self.window_scaling)  # adjust current size according to new size given by event
+                self.current_height = round(detected_height / self.window_scaling)  # _current_width and _current_height are independent of the scale
 
     def set_scaling(self, new_widget_scaling, new_spacing_scaling, new_window_scaling):
         self.window_scaling = new_window_scaling
 
+        # block update_dimensions_event to prevent current_width and current_height to get updated
+        self.block_update_dimensions_event = True
+
         # force new dimensions on window by using min, max, and geometry
         super().minsize(self.apply_window_scaling(self.current_width), self.apply_window_scaling(self.current_height))
         super().maxsize(self.apply_window_scaling(self.current_width), self.apply_window_scaling(self.current_height))
@@ -81,6 +90,11 @@ class CTk(tkinter.Tk):
         # set new scaled min and max with 400ms delay (otherwise it won't work for some reason)
         self.after(400, self.set_scaled_min_max)
 
+        # release the blocking of update_dimensions_event after a small amount of time (slight delay is necessary)
+        def set_block_update_dimensions_event_false():
+            self.block_update_dimensions_event = False
+        self.after(100, lambda: set_block_update_dimensions_event_false())
+
     def set_scaled_min_max(self):
         if self.min_width is not None or self.min_height is not None:
             super().minsize(self.apply_window_scaling(self.min_width), self.apply_window_scaling(self.min_height))
@@ -93,16 +107,36 @@ class CTk(tkinter.Tk):
         self.disable_macos_dark_title_bar()
         super().destroy()
 
+    def withdraw(self):
+        if self.window_exists is False:
+            self.withdraw_called_before_window_exists = True
+        super().withdraw()
+
+    def iconify(self):
+        if self.window_exists is False:
+            self.iconify_called_before_window_exists = True
+        super().iconify()
+
     def update(self):
         if self.window_exists is False:
-            self.deiconify()
             self.window_exists = True
+
+            if sys.platform.startswith("win"):
+                if not self.withdraw_called_before_window_exists and not self.iconify_called_before_window_exists:
+                    # print("window dont exists -> deiconify in update")
+                    self.deiconify()
+
         super().update()
 
     def mainloop(self, *args, **kwargs):
         if not self.window_exists:
-            self.deiconify()
             self.window_exists = True
+
+            if sys.platform.startswith("win"):
+                if not self.withdraw_called_before_window_exists and not self.iconify_called_before_window_exists:
+                    # print("window dont exists -> deiconify in mainloop")
+                    self.deiconify()
+
         super().mainloop(*args, **kwargs)
 
     def resizable(self, *args, **kwargs):
@@ -129,27 +163,54 @@ class CTk(tkinter.Tk):
         if self.current_height > height: self.current_height = height
         super().maxsize(self.apply_window_scaling(self.max_width), self.apply_window_scaling(self.max_height))
 
-    def geometry(self, geometry_string):
-        super().geometry(self.apply_geometry_scaling(geometry_string))
+    def geometry(self, geometry_string: str = None):
+        if geometry_string is not None:
+            super().geometry(self.apply_geometry_scaling(geometry_string))
 
-        # update width and height attributes
-        numbers = list(map(int, re.split(r"[x+]", geometry_string)))  # split geometry string into list of numbers
-        self.current_width = max(self.min_width, min(numbers[0], self.max_width))  # bound value between min and max
-        self.current_height = max(self.min_height, min(numbers[1], self.max_height))
-
-    def apply_geometry_scaling(self, geometry_string):
-        numbers = list(map(int, re.split(r"[x+]", geometry_string)))  # split geometry string into list of numbers
-
-        if len(numbers) == 2:
-            return f"{self.apply_window_scaling(numbers[0]):.0f}x" +\
-                   f"{self.apply_window_scaling(numbers[1]):.0f}"
-        elif len(numbers) == 4:
-            return f"{self.apply_window_scaling(numbers[0]):.0f}x" +\
-                   f"{self.apply_window_scaling(numbers[1]):.0f}+" +\
-                   f"{self.apply_window_scaling(numbers[2]):.0f}+" +\
-                   f"{self.apply_window_scaling(numbers[3]):.0f}"
+            # update width and height attributes
+            width, height, x, y = self.parse_geometry_string(geometry_string)
+            if width is not None and height is not None:
+                self.current_width = max(self.min_width, min(width, self.max_width))  # bound value between min and max
+                self.current_height = max(self.min_height, min(height, self.max_height))
         else:
-            return geometry_string
+            return self.reverse_geometry_scaling(super().geometry())
+
+    @staticmethod
+    def parse_geometry_string(geometry_string: str) -> tuple:
+        #                 index:   1                   2           3          4             5       6
+        # regex group structure: ('<width>x<height>', '<width>', '<height>', '+-<x>+-<y>', '-<x>', '-<y>')
+        result = re.search(r"((\d+)x(\d+)){0,1}(\+{0,1}([+-]{0,1}\d+)\+{0,1}([+-]{0,1}\d+)){0,1}", geometry_string)
+
+        width = int(result.group(2)) if result.group(2) is not None else None
+        height = int(result.group(3)) if result.group(3) is not None else None
+        x = int(result.group(5)) if result.group(5) is not None else None
+        y = int(result.group(6)) if result.group(6) is not None else None
+
+        return width, height, x, y
+
+    def apply_geometry_scaling(self, geometry_string: str) -> str:
+        width, height, x, y = self.parse_geometry_string(geometry_string)
+
+        if x is None and y is None:  # no <x> and <y> in geometry_string
+            return f"{round(width * self.window_scaling)}x{round(height * self.window_scaling)}"
+
+        elif width is None and height is None:  # no <width> and <height> in geometry_string
+            return f"+{x}+{y}"
+
+        else:
+            return f"{round(width * self.window_scaling)}x{round(height * self.window_scaling)}+{x}+{y}"
+
+    def reverse_geometry_scaling(self, scaled_geometry_string: str) -> str:
+        width, height, x, y = self.parse_geometry_string(scaled_geometry_string)
+
+        if x is None and y is None:  # no <x> and <y> in geometry_string
+            return f"{round(width / self.window_scaling)}x{round(height / self.window_scaling)}"
+
+        elif width is None and height is None:  # no <width> and <height> in geometry_string
+            return f"+{x}+{y}"
+
+        else:
+            return f"{round(width / self.window_scaling)}x{round(height / self.window_scaling)}+{x}+{y}"
 
     def apply_window_scaling(self, value):
         if isinstance(value, (int, float)):
@@ -225,8 +286,15 @@ class CTk(tkinter.Tk):
 
         if sys.platform.startswith("win") and not Settings.deactivate_windows_window_header_manipulation:
 
-            super().withdraw()  # hide window so that it can be redrawn after the titlebar change so that the color change is visible
-            if not self.window_exists:
+            if self.window_exists:
+                self.state_before_windows_set_titlebar_color = self.state()
+                # print("window_exists -> state_before_windows_set_titlebar_color: ", self.state_before_windows_set_titlebar_color)
+
+                if self.state_before_windows_set_titlebar_color != "iconic" or self.state_before_windows_set_titlebar_color != "withdrawn":
+                    super().withdraw()  # hide window so that it can be redrawn after the titlebar change so that the color change is visible
+            else:
+                # print("window dont exists -> withdraw and update")
+                super().withdraw()
                 super().update()
 
             if color_mode.lower() == "dark":
@@ -255,7 +323,17 @@ class CTk(tkinter.Tk):
                 print(err)
 
             if self.window_exists:
-                self.deiconify()
+                # print("window_exists -> return to original state: ", self.state_before_windows_set_titlebar_color)
+                if self.state_before_windows_set_titlebar_color == "normal":
+                    self.deiconify()
+                elif self.state_before_windows_set_titlebar_color == "iconic":
+                    self.iconify()
+                elif self.state_before_windows_set_titlebar_color == "zoomed":
+                    self.state("zoomed")
+                else:
+                    self.state(self.state_before_windows_set_titlebar_color)  # other states
+            else:
+                pass  # wait for update or mainloop to be called
 
     def set_appearance_mode(self, mode_string):
         if mode_string.lower() == "dark":

customtkinter/windows/ctk_toplevel.py

@@ -47,7 +47,11 @@ class CTkToplevel(tkinter.Toplevel):
         AppearanceModeTracker.add(self.set_appearance_mode, self)
         super().configure(bg=ThemeManager.single_color(self.fg_color, self.appearance_mode))
         super().title("CTkToplevel")
-        # self.geometry(f"{self.current_width}x{self.current_height}")
+
+        self.state_before_windows_set_titlebar_color = None
+        self.windows_set_titlebar_color_called = False  # indicates if windows_set_titlebar_color was called, stays True until revert_withdraw_after_windows_set_titlebar_color is called
+        self.withdraw_called_after_windows_set_titlebar_color = False  # indicates if withdraw() was called after windows_set_titlebar_color
+        self.iconify_called_after_windows_set_titlebar_color = False  # indicates if iconify() was called after windows_set_titlebar_color
 
         if sys.platform.startswith("win"):
             if self.appearance_mode == 1:
@@ -63,7 +67,7 @@ class CTkToplevel(tkinter.Toplevel):
 
         if self.current_width != round(detected_width / self.window_scaling) or self.current_height != round(detected_height / self.window_scaling):
             self.current_width = round(detected_width / self.window_scaling)  # adjust current size according to new size given by event
-            self.current_height = round(detected_height / self.window_scaling)  # current_width and current_height are independent of the scale
+            self.current_height = round(detected_height / self.window_scaling)  # _current_width and _current_height are independent of the scale
 
     def set_scaling(self, new_widget_scaling, new_spacing_scaling, new_window_scaling):
         self.window_scaling = new_window_scaling
@@ -83,19 +87,54 @@ class CTkToplevel(tkinter.Toplevel):
         if self.max_width is not None or self.max_height is not None:
             super().maxsize(self.apply_window_scaling(self.max_width), self.apply_window_scaling(self.max_height))
 
-    def apply_geometry_scaling(self, geometry_string):
-        numbers = list(map(int, re.split(r"[x+]", geometry_string)))  # split geometry string into list of numbers
+    def geometry(self, geometry_string: str = None):
+        if geometry_string is not None:
+            super().geometry(self.apply_geometry_scaling(geometry_string))
 
-        if len(numbers) == 2:
-            return f"{self.apply_window_scaling(numbers[0]):.0f}x" +\
-                   f"{self.apply_window_scaling(numbers[1]):.0f}"
-        elif len(numbers) == 4:
-            return f"{self.apply_window_scaling(numbers[0]):.0f}x" +\
-                   f"{self.apply_window_scaling(numbers[1]):.0f}+" +\
-                   f"{self.apply_window_scaling(numbers[2]):.0f}+" +\
-                   f"{self.apply_window_scaling(numbers[3]):.0f}"
+            # update width and height attributes
+            width, height, x, y = self.parse_geometry_string(geometry_string)
+            if width is not None and height is not None:
+                self.current_width = max(self.min_width, min(width, self.max_width))  # bound value between min and max
+                self.current_height = max(self.min_height, min(height, self.max_height))
         else:
-            return geometry_string
+            return self.reverse_geometry_scaling(super().geometry())
+
+    @staticmethod
+    def parse_geometry_string(geometry_string: str) -> tuple:
+        #                 index:   1                   2           3          4             5       6
+        # regex group structure: ('<width>x<height>', '<width>', '<height>', '+-<x>+-<y>', '-<x>', '-<y>')
+        result = re.search(r"((\d+)x(\d+)){0,1}(\+{0,1}([+-]{0,1}\d+)\+{0,1}([+-]{0,1}\d+)){0,1}", geometry_string)
+
+        width = int(result.group(2)) if result.group(2) is not None else None
+        height = int(result.group(3)) if result.group(3) is not None else None
+        x = int(result.group(5)) if result.group(5) is not None else None
+        y = int(result.group(6)) if result.group(6) is not None else None
+
+        return width, height, x, y
+
+    def apply_geometry_scaling(self, geometry_string: str) -> str:
+        width, height, x, y = self.parse_geometry_string(geometry_string)
+
+        if x is None and y is None:  # no <x> and <y> in geometry_string
+            return f"{round(width * self.window_scaling)}x{round(height * self.window_scaling)}"
+
+        elif width is None and height is None:  # no <width> and <height> in geometry_string
+            return f"+{x}+{y}"
+
+        else:
+            return f"{round(width * self.window_scaling)}x{round(height * self.window_scaling)}+{x}+{y}"
+
+    def reverse_geometry_scaling(self, scaled_geometry_string: str) -> str:
+        width, height, x, y = self.parse_geometry_string(scaled_geometry_string)
+
+        if x is None and y is None:  # no <x> and <y> in geometry_string
+            return f"{round(width / self.window_scaling)}x{round(height / self.window_scaling)}"
+
+        elif width is None and height is None:  # no <width> and <height> in geometry_string
+            return f"+{x}+{y}"
+
+        else:
+            return f"{round(width / self.window_scaling)}x{round(height / self.window_scaling)}+{x}+{y}"
 
     def apply_window_scaling(self, value):
         if isinstance(value, (int, float)):
@@ -103,20 +142,22 @@ class CTkToplevel(tkinter.Toplevel):
         else:
             return value
 
-    def geometry(self, geometry_string):
-        super().geometry(self.apply_geometry_scaling(geometry_string))
-
-        # update width and height attributes
-        numbers = list(map(int, re.split(r"[x+]", geometry_string)))  # split geometry string into list of numbers
-        self.current_width = max(self.min_width, min(numbers[0], self.max_width))  # bound value between min and max
-        self.current_height = max(self.min_height, min(numbers[1], self.max_height))
-
     def destroy(self):
         AppearanceModeTracker.remove(self.set_appearance_mode)
         ScalingTracker.remove_window(self.set_scaling, self)
         self.disable_macos_dark_title_bar()
         super().destroy()
 
+    def withdraw(self):
+        if self.windows_set_titlebar_color_called:
+            self.withdraw_called_after_windows_set_titlebar_color = True
+        super().withdraw()
+
+    def iconify(self):
+        if self.windows_set_titlebar_color_called:
+            self.iconify_called_after_windows_set_titlebar_color = True
+        super().iconify()
+
     def resizable(self, *args, **kwargs):
         super().resizable(*args, **kwargs)
         self.last_resizable_args = (args, kwargs)
@@ -208,6 +249,7 @@ class CTkToplevel(tkinter.Toplevel):
 
         if sys.platform.startswith("win") and not Settings.deactivate_windows_window_header_manipulation:
 
+            self.state_before_windows_set_titlebar_color = self.state()
             super().withdraw()  # hide window so that it can be redrawn after the titlebar change so that the color change is visible
             super().update()
 
@@ -235,7 +277,30 @@ class CTkToplevel(tkinter.Toplevel):
             except Exception as err:
                 print(err)
 
-            self.deiconify()
+            self.windows_set_titlebar_color_called = True
+            self.after(5, self.revert_withdraw_after_windows_set_titlebar_color)
+
+    def revert_withdraw_after_windows_set_titlebar_color(self):
+        """ if in a short time (5ms) after """
+        if self.windows_set_titlebar_color_called:
+
+            if self.withdraw_called_after_windows_set_titlebar_color:
+                pass  # leave it withdrawed
+            elif self.iconify_called_after_windows_set_titlebar_color:
+                super().iconify()
+            else:
+                if self.state_before_windows_set_titlebar_color == "normal":
+                    self.deiconify()
+                elif self.state_before_windows_set_titlebar_color == "iconic":
+                    self.iconify()
+                elif self.state_before_windows_set_titlebar_color == "zoomed":
+                    self.state("zoomed")
+                else:
+                    self.state(self.state_before_windows_set_titlebar_color)  # other states
+
+            self.windows_set_titlebar_color_called = False
+            self.withdraw_called_after_windows_set_titlebar_color = False
+            self.iconify_called_after_windows_set_titlebar_color = False
 
     def set_appearance_mode(self, mode_string):
         if mode_string.lower() == "dark":

examples/complex_example.py

@@ -16,7 +16,6 @@ class App(customtkinter.CTk):
 
         self.title("CustomTkinter complex_example.py")
         self.geometry(f"{App.WIDTH}x{App.HEIGHT}")
-
         self.protocol("WM_DELETE_WINDOW", self.on_closing)  # call .on_closing() when app gets closed
 
         # ============ create two frames ============
@@ -47,30 +46,27 @@ class App(customtkinter.CTk):
         self.label_1.grid(row=1, column=0, pady=10, padx=10)
 
         self.button_1 = customtkinter.CTkButton(master=self.frame_left,
-                                                text="CTkButton 1",
-                                                fg_color=("gray75", "gray30"),  # <- custom tuple-color
+                                                text="CTkButton",
                                                 command=self.button_event)
         self.button_1.grid(row=2, column=0, pady=10, padx=20)
 
         self.button_2 = customtkinter.CTkButton(master=self.frame_left,
-                                                text="CTkButton 2",
-                                                fg_color=("gray75", "gray30"),  # <- custom tuple-color
+                                                text="CTkButton",
                                                 command=self.button_event)
         self.button_2.grid(row=3, column=0, pady=10, padx=20)
 
         self.button_3 = customtkinter.CTkButton(master=self.frame_left,
-                                                text="CTkButton 3",
-                                                fg_color=("gray75", "gray30"),  # <- custom tuple-color
+                                                text="CTkButton",
                                                 command=self.button_event)
         self.button_3.grid(row=4, column=0, pady=10, padx=20)
 
-        self.switch_1 = customtkinter.CTkSwitch(master=self.frame_left)
-        self.switch_1.grid(row=9, column=0, pady=10, padx=20, sticky="w")
+        self.label_mode = customtkinter.CTkLabel(master=self.frame_left, text="Appearance Mode:")
+        self.label_mode.grid(row=9, column=0, pady=0, padx=20, sticky="w")
 
-        self.switch_2 = customtkinter.CTkSwitch(master=self.frame_left,
-                                                text="Dark Mode",
-                                                command=self.change_mode)
-        self.switch_2.grid(row=10, column=0, pady=10, padx=20, sticky="w")
+        self.optionmenu_1 = customtkinter.CTkOptionMenu(master=self.frame_left,
+                                                        values=["Light", "Dark", "System"],
+                                                        command=self.change_appearance_mode)
+        self.optionmenu_1.grid(row=10, column=0, pady=10, padx=20, sticky="w")
 
         # ============ frame_right ============
 
@@ -94,6 +90,7 @@ class App(customtkinter.CTk):
                                                         "amet consetetur sadipscing elitr,\n" +
                                                         "sed diam nonumy eirmod tempor" ,
                                                    height=100,
+                                                   corner_radius=6,  # <- custom corner radius
                                                    fg_color=("white", "gray38"),  # <- custom tuple-color
                                                    justify=tkinter.LEFT)
         self.label_info_1.grid(column=0, row=0, sticky="nwe", padx=15, pady=15)
@@ -135,25 +132,17 @@ class App(customtkinter.CTk):
                                                 command=self.progressbar.set)
         self.slider_2.grid(row=5, column=0, columnspan=2, pady=10, padx=20, sticky="we")
 
-        self.slider_button_1 = customtkinter.CTkButton(master=self.frame_right,
-                                                       height=25,
-                                                       text="CTkButton",
-                                                       command=self.button_event)
-        self.slider_button_1.grid(row=4, column=2, columnspan=1, pady=10, padx=20, sticky="we")
+        self.switch_1 = customtkinter.CTkSwitch(master=self.frame_right,
+                                                text="CTkSwitch")
+        self.switch_1.grid(row=4, column=2, columnspan=1, pady=10, padx=20, sticky="we")
 
-        self.slider_button_2 = customtkinter.CTkButton(master=self.frame_right,
-                                                       height=25,
-                                                       text="CTkButton",
-                                                       command=self.button_event)
-        self.slider_button_2.grid(row=5, column=2, columnspan=1, pady=10, padx=20, sticky="we")
+        self.switch_2 = customtkinter.CTkSwitch(master=self.frame_right,
+                                                text="CTkSwitch")
+        self.switch_2.grid(row=5, column=2, columnspan=1, pady=10, padx=20, sticky="we")
 
-        self.checkbox_button_1 = customtkinter.CTkButton(master=self.frame_right,
-                                                         height=25,
-                                                         text="CTkButton",
-                                                         border_width=3,   # <- custom border_width
-                                                         fg_color=None,   # <- no fg_color
-                                                         command=self.button_event)
-        self.checkbox_button_1.grid(row=6, column=2, columnspan=1, pady=10, padx=20, sticky="we")
+        self.combobox_1 = customtkinter.CTkComboBox(master=self.frame_right,
+                                                    values=["Value 1", "Value 2"])
+        self.combobox_1.grid(row=6, column=2, columnspan=1, pady=10, padx=20, sticky="we")
 
         self.check_box_1 = customtkinter.CTkCheckBox(master=self.frame_right,
                                                      text="CTkCheckBox")
@@ -170,16 +159,20 @@ class App(customtkinter.CTk):
 
         self.button_5 = customtkinter.CTkButton(master=self.frame_right,
                                                 text="CTkButton",
+                                                border_width=2,  # <- custom border_width
+                                                fg_color=None,  # <- no fg_color
                                                 command=self.button_event)
         self.button_5.grid(row=8, column=2, columnspan=1, pady=20, padx=20, sticky="we")
 
         # set default values
+        self.optionmenu_1.set("Dark")
+        self.button_3.configure(state="disabled", text="Disabled CTkButton")
+        self.combobox_1.set("CTkCombobox")
         self.radio_button_1.select()
-        self.switch_2.select()
         self.slider_1.set(0.2)
         self.slider_2.set(0.7)
         self.progressbar.set(0.5)
-        self.slider_button_1.configure(state=tkinter.DISABLED, text="Disabled Button")
+        self.switch_2.select()
         self.radio_button_3.configure(state=tkinter.DISABLED)
         self.check_box_1.configure(state=tkinter.DISABLED, text="CheckBox disabled")
         self.check_box_2.select()
@@ -187,19 +180,13 @@ class App(customtkinter.CTk):
     def button_event(self):
         print("Button pressed")
 
-    def change_mode(self):
-        if self.switch_2.get() == 1:
-            customtkinter.set_appearance_mode("dark")
-        else:
-            customtkinter.set_appearance_mode("light")
+    def change_appearance_mode(self, new_appearance_mode):
+        customtkinter.set_appearance_mode(new_appearance_mode)
 
     def on_closing(self, event=0):
         self.destroy()
 
-    def start(self):
-        self.mainloop()
-
 
 if __name__ == "__main__":
     app = App()
-    app.start()
+    app.mainloop()

examples/example_background_image.py

@@ -23,6 +23,7 @@ class App(customtkinter.CTk):
         self.geometry(f"{App.WIDTH}x{App.HEIGHT}")
         self.minsize(App.WIDTH, App.HEIGHT)
         self.maxsize(App.WIDTH, App.HEIGHT)
+        self.resizable(False, False)
 
         self.protocol("WM_DELETE_WINDOW", self.on_closing)
 

examples/example_button_images.py

@@ -1,6 +1,5 @@
-import tkinter
 import customtkinter
-from PIL import Image, ImageTk  # <- import PIL for the images
+from PIL import Image, ImageTk
 import os
 
 PATH = os.path.dirname(os.path.realpath(__file__))
@@ -8,57 +7,61 @@ PATH = os.path.dirname(os.path.realpath(__file__))
 customtkinter.set_appearance_mode("System")  # Modes: "System" (standard), "Dark", "Light"
 customtkinter.set_default_color_theme("blue")  # Themes: "blue" (standard), "green", "dark-blue"
 
-app = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
-app.geometry("450x260")
-app.title("CustomTkinter example_button_images.py")
+
+class App(customtkinter.CTk):
+    def __init__(self):
+        super().__init__()
+        self.geometry("450x260")
+        self.title("CustomTkinter example_button_images.py")
+
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=1, minsize=200)
+
+        self.frame_1 = customtkinter.CTkFrame(master=self, width=250, height=240, corner_radius=15)
+        self.frame_1.grid(row=0, column=0, padx=20, pady=20, sticky="nsew")
+        self.frame_1.grid_columnconfigure(0, weight=1)
+        self.frame_1.grid_columnconfigure(1, weight=1)
+
+        self.settings_image = self.load_image("/test_images/settings.png", 20)
+        self.bell_image = self.load_image("/test_images/bell.png", 20)
+        self.add_folder_image = self.load_image("/test_images/add-folder.png", 20)
+        self.add_list_image = self.load_image("/test_images/add-folder.png", 20)
+        self.add_user_image = self.load_image("/test_images/add-user.png", 20)
+        self.chat_image = self.load_image("/test_images/chat.png", 20)
+        self.home_image = self.load_image("/test_images/home.png", 20)
+
+        self.button_1 = customtkinter.CTkButton(master=self.frame_1, image=self.add_folder_image, text="Add Folder", height=32,
+                                                compound="right", command=self.button_function)
+        self.button_1.grid(row=1, column=0, columnspan=2, padx=20, pady=(20, 10), sticky="ew")
+
+        self.button_2 = customtkinter.CTkButton(master=self.frame_1, image=self.add_list_image, text="Add Item", height=32,
+                                                compound="right", fg_color="#D35B58", hover_color="#C77C78",
+                                                command=self.button_function)
+        self.button_2.grid(row=2, column=0, columnspan=2, padx=20, pady=10, sticky="ew")
+
+        self.button_3 = customtkinter.CTkButton(master=self.frame_1, image=self.chat_image, text="", width=40, height=40,
+                                                corner_radius=10, fg_color="gray40", hover_color="gray25",
+                                                command=self.button_function)
+        self.button_3.grid(row=3, column=0, columnspan=1, padx=20, pady=10, sticky="w")
+
+        self.button_4 = customtkinter.CTkButton(master=self.frame_1, image=self.home_image, text="", width=40, height=40,
+                                                corner_radius=10, fg_color="gray40", hover_color="gray25",
+                                                command=self.button_function)
+        self.button_4.grid(row=3, column=1, columnspan=1, padx=20, pady=10, sticky="e")
+
+        self.button_5 = customtkinter.CTkButton(master=self, image=self.add_user_image, text="Add User", width=130, height=60, border_width=2,
+                                                corner_radius=10, compound="bottom", border_color="#D35B58", fg_color=("gray84", "gray25"),
+                                                hover_color="#C77C78", command=self.button_function)
+        self.button_5.grid(row=0, column=1, padx=20, pady=20)
+
+    def load_image(self, path, image_size):
+        """ load rectangular image with path relative to PATH """
+        return ImageTk.PhotoImage(Image.open(PATH + path).resize((image_size, image_size)))
+
+    def button_function(self):
+        print("button pressed")
 
 
-def button_function():
-    print("button pressed")
-
-
-# load images as PhotoImage
-image_size = 20
-
-settings_image = ImageTk.PhotoImage(Image.open(PATH + "/test_images/settings.png").resize((image_size, image_size)))
-bell_image = ImageTk.PhotoImage(Image.open(PATH + "/test_images/bell.png").resize((image_size, image_size)))
-
-add_folder_image = ImageTk.PhotoImage(Image.open(PATH + "/test_images/add-folder.png").resize((image_size, image_size), Image.ANTIALIAS))
-add_list_image = ImageTk.PhotoImage(Image.open(PATH + "/test_images/add-list.png").resize((image_size, image_size), Image.ANTIALIAS))
-add_user_image = ImageTk.PhotoImage(Image.open(PATH + "/test_images/add-user.png").resize((image_size, image_size), Image.ANTIALIAS))
-chat_image = ImageTk.PhotoImage(Image.open(PATH + "/test_images/chat.png").resize((image_size, image_size), Image.ANTIALIAS))
-home_image = ImageTk.PhotoImage(Image.open(PATH + "/test_images/home.png").resize((image_size, image_size), Image.ANTIALIAS))
-
-app.grid_rowconfigure(0, weight=1)
-app.grid_columnconfigure(0, weight=1, minsize=200)
-
-frame_1 = customtkinter.CTkFrame(master=app, width=250, height=240, corner_radius=15)
-frame_1.grid(row=0, column=0, padx=20, pady=20, sticky="nsew")
-
-frame_1.grid_columnconfigure(0, weight=1)
-frame_1.grid_columnconfigure(1, weight=1)
-frame_1.grid_rowconfigure(0, minsize=10)  # add empty row for spacing
-
-button_1 = customtkinter.CTkButton(master=frame_1, image=add_folder_image, text="Add Folder", width=190, height=40,
-                                   compound="right", command=button_function)
-button_1.grid(row=1, column=0, columnspan=2, padx=20, pady=10, sticky="ew")
-
-button_2 = customtkinter.CTkButton(master=frame_1, image=add_list_image, text="Add Item", width=190, height=40,
-                                   compound="right", fg_color="#D35B58", hover_color="#C77C78",
-                                   command=button_function)
-button_2.grid(row=2, column=0, columnspan=2, padx=20, pady=10, sticky="ew")
-
-button_3 = customtkinter.CTkButton(master=frame_1, image=chat_image, text="", width=50, height=50,
-                                   corner_radius=10, fg_color="gray40", hover_color="gray25", command=button_function)
-button_3.grid(row=3, column=0, columnspan=1, padx=20, pady=10, sticky="w")
-
-button_4 = customtkinter.CTkButton(master=frame_1, image=home_image, text="", width=50, height=50,
-                                   corner_radius=10, fg_color="gray40", hover_color="gray25", command=button_function)
-button_4.grid(row=3, column=1, columnspan=1, padx=20, pady=10, sticky="e")
-
-button_5 = customtkinter.CTkButton(master=app, image=add_user_image, text="Add User", width=130, height=70, border_width=3,
-                                   corner_radius=10, compound="bottom", border_color="#D35B58", fg_color=("gray84", "gray25"), hover_color="#C77C78",
-                                   command=button_function)
-button_5.grid(row=0, column=1, padx=20, pady=20)
-
-app.mainloop()
+if __name__ == "__main__":
+    app = App()
+    app.mainloop()

examples/simple_example.py

@@ -4,58 +4,58 @@ import customtkinter
 customtkinter.set_appearance_mode("dark")  # Modes: "System" (standard), "Dark", "Light"
 customtkinter.set_default_color_theme("blue")  # Themes: "blue" (standard), "green", "dark-blue"
 
-app = customtkinter.CTk()  # create CTk window like you do with the Tk window
-app.geometry("400x480")
+app = customtkinter.CTk()
+app.geometry("400x580")
 app.title("CustomTkinter simple_example.py")
 
 
-def button_function():
-    print("Button click", label_1.text_label.cget("text"))
+def button_callback():
+    print("Button click", combobox_1.get())
 
 
-def slider_function(value):
+def slider_callback(value):
     progressbar_1.set(value)
 
 
-def check_box_function():
-    print("checkbox_1:", checkbox_1.get())
-
-
-y_padding = 13
-
-frame_1 = customtkinter.CTkFrame(master=app, corner_radius=15)
+frame_1 = customtkinter.CTkFrame(master=app)
 frame_1.pack(pady=20, padx=60, fill="both", expand=True)
 
 label_1 = customtkinter.CTkLabel(master=frame_1, justify=tkinter.LEFT)
-label_1.pack(pady=y_padding, padx=10)
+label_1.pack(pady=12, padx=10)
 
 progressbar_1 = customtkinter.CTkProgressBar(master=frame_1)
-progressbar_1.pack(pady=y_padding, padx=10)
+progressbar_1.pack(pady=12, padx=10)
 
-button_1 = customtkinter.CTkButton(master=frame_1, corner_radius=8, command=button_function)
-button_1.pack(pady=y_padding, padx=10)
+button_1 = customtkinter.CTkButton(master=frame_1, command=button_callback)
+button_1.pack(pady=12, padx=10)
 
-slider_1 = customtkinter.CTkSlider(master=frame_1, command=slider_function, from_=0, to=1)
-slider_1.pack(pady=y_padding, padx=10)
+slider_1 = customtkinter.CTkSlider(master=frame_1, command=slider_callback, from_=0, to=1)
+slider_1.pack(pady=12, padx=10)
 slider_1.set(0.5)
 
 entry_1 = customtkinter.CTkEntry(master=frame_1, placeholder_text="CTkEntry")
-entry_1.pack(pady=y_padding, padx=10)
+entry_1.pack(pady=12, padx=10)
 
-checkbox_1 = customtkinter.CTkCheckBox(master=frame_1, command=check_box_function)
-checkbox_1.pack(pady=y_padding, padx=10)
+optionmenu_1 = customtkinter.CTkOptionMenu(frame_1, values=["Option 1", "Option 2", "Option 42 long long long..."])
+optionmenu_1.pack(pady=12, padx=10)
+optionmenu_1.set("CTkOptionMenu")
+
+combobox_1 = customtkinter.CTkComboBox(frame_1, values=["Option 1", "Option 2", "Option 42 long long long..."])
+combobox_1.pack(pady=12, padx=10)
+optionmenu_1.set("CTkComboBox")
+
+checkbox_1 = customtkinter.CTkCheckBox(master=frame_1)
+checkbox_1.pack(pady=12, padx=10)
 
 radiobutton_var = tkinter.IntVar(value=1)
 
 radiobutton_1 = customtkinter.CTkRadioButton(master=frame_1, variable=radiobutton_var, value=1)
-radiobutton_1.pack(pady=y_padding, padx=10)
+radiobutton_1.pack(pady=12, padx=10)
 
 radiobutton_2 = customtkinter.CTkRadioButton(master=frame_1, variable=radiobutton_var, value=2)
-radiobutton_2.pack(pady=y_padding, padx=10)
-
-s_var = tkinter.StringVar(value="on")
+radiobutton_2.pack(pady=12, padx=10)
 
 switch_1 = customtkinter.CTkSwitch(master=frame_1)
-switch_1.pack(pady=y_padding, padx=10)
+switch_1.pack(pady=12, padx=10)
 
 app.mainloop()

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 github_url = "https://github.com/TomSchimansky/CustomTkinter"
 
 [tool.tbump.version]
-current = "4.1.0"
+current = "4.6.3"
 
 # Example of a semver regexp.
 # Make sure this matches current_version before

setup.cfg

@@ -1,8 +1,8 @@
 [metadata]
 name = customtkinter
-version = 4.1.0
+version = 4.6.3
 description = Create modern looking GUIs with Python
-long_description = file: README.md
+long_description = CustomTkinter UI-Library\n\n[](https://github.com/TomSchimansky/CustomTkinter/blob/master/documentation_images/Windows_dark.png)\n\nMore Information: https://github.com/TomSchimansky/CustomTkinter
 long_description_content_type = text/markdown
 url = https://github.com/TomSchimansky/CustomTkinter
 author = Tom Schimansky

test/manual_integration_tests/complex_example_new.py

@@ -0,0 +1,149 @@
+import tkinter
+import tkinter.messagebox
+import customtkinter
+
+customtkinter.set_appearance_mode("System")  # Modes: "System" (standard), "Dark", "Light"
+customtkinter.set_default_color_theme("blue")  # Themes: "blue" (standard), "green", "dark-blue"
+
+
+class App(customtkinter.CTk):
+
+    def __init__(self):
+        super().__init__()
+
+        self.title("CustomTkinter complex_example.py")
+        self.geometry(f"{920}x{500}")
+        self.protocol("WM_DELETE_WINDOW", self.on_closing)  # call .on_closing() when app gets closed
+
+        # configure grid layout (4x4)
+        self.grid_columnconfigure(1, weight=1)
+        self.grid_columnconfigure((2, 3), weight=0, minsize=200)
+        self.grid_rowconfigure((0, 1, 2), weight=1)
+
+        # create sidebar frame with widgets
+        self.sidebar_frame = customtkinter.CTkFrame(self, width=140)
+        self.sidebar_frame.grid(row=0, column=0, rowspan=4, sticky="nsew")
+        self.sidebar_frame.grid_rowconfigure(4, weight=1)
+        self.logo_label = customtkinter.CTkLabel(self.sidebar_frame, text="CustomTkinter", text_font=("Roboto", -16))
+        self.logo_label.grid(row=0, column=0, padx=20, pady=(20, 10))
+        self.sidebar_button_1 = customtkinter.CTkButton(self.sidebar_frame, command=self.sidebar_button_callback)
+        self.sidebar_button_1.grid(row=1, column=0, padx=20, pady=10)
+        self.sidebar_button_2 = customtkinter.CTkButton(self.sidebar_frame, command=self.sidebar_button_callback)
+        self.sidebar_button_2.grid(row=2, column=0, padx=20, pady=10)
+        self.sidebar_button_3 = customtkinter.CTkButton(self.sidebar_frame, command=self.sidebar_button_callback)
+        self.sidebar_button_3.grid(row=3, column=0, padx=20, pady=10)
+        self.appearance_mode_label = customtkinter.CTkLabel(self.sidebar_frame, text="Appearance Mode:", anchor="w")
+        self.appearance_mode_label.grid(row=5, column=0, padx=20, pady=(10, 0))
+        self.appearance_mode_optionemenu = customtkinter.CTkOptionMenu(self.sidebar_frame, values=["Light", "Dark", "System"],
+                                                                       command=self.change_appearance_mode)
+        self.appearance_mode_optionemenu.grid(row=6, column=0, padx=20, pady=(10, 10))
+        self.scaling_label = customtkinter.CTkLabel(self.sidebar_frame, text="UI Scaling:", anchor="w")
+        self.scaling_label.grid(row=7, column=0, padx=20, pady=(10, 0))
+        self.scaling_optionemenu = customtkinter.CTkOptionMenu(self.sidebar_frame, values=["80%", "90%", "100%", "110%", "120%"],
+                                                               command=self.change_scaling)
+        self.scaling_optionemenu.grid(row=8, column=0, padx=20, pady=(10, 20))
+
+        # create main entry and button
+        self.entry = customtkinter.CTkEntry(self, placeholder_text="CTkEntry")
+        self.entry.grid(row=3, column=1, columnspan=2, padx=(20, 10), pady=(10, 20), sticky="nsew")
+
+        self.main_button_1 = customtkinter.CTkButton(self, fg_color=None, border_width=2)
+        self.main_button_1.grid(row=3, column=3, padx=(10, 20), pady=(10, 20), sticky="nsew")
+
+        self.textbox = customtkinter.CTkTextbox(self)
+        self.textbox.grid(row=0, column=1, padx=(20, 10), pady=(20, 10), sticky="nsew")
+
+        # create radiobutton frame
+        self.radiobutton_frame = customtkinter.CTkFrame(self)
+        self.radiobutton_frame.grid(row=0, column=3, padx=(10, 20), pady=(20, 10), sticky="nsew")
+        self.radio_var = tkinter.IntVar(value=0)
+        self.label_radio_group = customtkinter.CTkLabel(master=self.radiobutton_frame, text="CTkRadioButton Group:")
+        self.label_radio_group.grid(row=0, column=2, columnspan=1, padx=10, pady=10, sticky="")
+        self.radio_button_1 = customtkinter.CTkRadioButton(master=self.radiobutton_frame, variable=self.radio_var, value=0)
+        self.radio_button_1.grid(row=1, column=2, pady=10, padx=20, sticky="n")
+        self.radio_button_2 = customtkinter.CTkRadioButton(master=self.radiobutton_frame, variable=self.radio_var, value=1)
+        self.radio_button_2.grid(row=2, column=2, pady=10, padx=20, sticky="n")
+        self.radio_button_3 = customtkinter.CTkRadioButton(master=self.radiobutton_frame, variable=self.radio_var, value=2)
+        self.radio_button_3.grid(row=3, column=2, pady=10, padx=20, sticky="n")
+
+        # create optionemnu and combobox frame
+        self.optionemnu_combobox_frame = customtkinter.CTkFrame(self)
+        self.optionemnu_combobox_frame.grid(row=0, column=2, padx=(10, 10), pady=(20, 10), sticky="nsew")
+        self.optionmenu_1 = customtkinter.CTkOptionMenu(self.optionemnu_combobox_frame,
+                                                        dynamic_resizing=False,
+                                                        values=["Value 1", "Value 2", "Value Long Long Long"])
+        self.optionmenu_1.grid(row=0, column=0, padx=20, pady=(20, 10), sticky="ew")
+        self.combobox_1 = customtkinter.CTkComboBox(self.optionemnu_combobox_frame,
+                                                    values=["Value 1", "Value 2", "Value Long....."])
+        self.combobox_1.grid(row=1, column=0, padx=20, pady=(10, 10), sticky="ew")
+        self.string_input_button = customtkinter.CTkButton(self.optionemnu_combobox_frame, text="Open CTkInputDialog",
+                                                           command=self.open_input_dialog)
+        self.string_input_button.grid(row=2, column=0, padx=20, pady=(10, 10), sticky="ew")
+
+        # create checkbox and switch frame
+        self.checkbox_slider_frame = customtkinter.CTkFrame(self)
+        self.checkbox_slider_frame.grid(row=1, column=3, padx=(10, 20), pady=(10, 10), sticky="nsew")
+        self.checkbox_1 = customtkinter.CTkCheckBox(master=self.checkbox_slider_frame)
+        self.checkbox_1.grid(row=1, column=0, pady=(20, 10), padx=20, sticky="n")
+        self.checkbox_2 = customtkinter.CTkCheckBox(master=self.checkbox_slider_frame)
+        self.checkbox_2.grid(row=2, column=0, pady=10, padx=20, sticky="n")
+        self.switch_1 = customtkinter.CTkSwitch(master=self.checkbox_slider_frame, command=lambda: print("switch 1 toggle"))
+        self.switch_1.grid(row=3, column=0, pady=10, padx=20, sticky="n")
+        self.switch_2 = customtkinter.CTkSwitch(master=self.checkbox_slider_frame)
+        self.switch_2.grid(row=4, column=0, pady=(10, 20), padx=20, sticky="n")
+
+        # create slider and progressbar frame
+        self.slider_progressbar_frame = customtkinter.CTkFrame(self, fg_color=None)
+        self.slider_progressbar_frame.grid(row=1, column=1, columnspan=2, padx=(20, 10), pady=(10, 10), sticky="nsew")
+        self.slider_progressbar_frame.grid_columnconfigure(0, weight=1)
+        self.slider_progressbar_frame.grid_rowconfigure(3, weight=1)
+        self.progressbar_1 = customtkinter.CTkProgressBar(self.slider_progressbar_frame)
+        self.progressbar_1.grid(row=0, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+        self.progressbar_2 = customtkinter.CTkProgressBar(self.slider_progressbar_frame)
+        self.progressbar_2.grid(row=1, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+        self.slider_1 = customtkinter.CTkSlider(self.slider_progressbar_frame, from_=0, to=1, number_of_steps=4)
+        self.slider_1.grid(row=2, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+        self.slider_2 = customtkinter.CTkSlider(self.slider_progressbar_frame, orient="vertical")
+        self.slider_2.grid(row=0, column=1, rowspan=4, padx=(10, 10), pady=(10, 10), sticky="ns")
+        self.progressbar_3 = customtkinter.CTkProgressBar(self.slider_progressbar_frame, orient="vertical")
+        self.progressbar_3.grid(row=0, column=2, rowspan=4, padx=(10, 20), pady=(10, 10), sticky="ns")
+
+        # set default values
+        self.sidebar_button_3.configure(state="disabled", text="Disabled CTkButton")
+        self.checkbox_2.configure(state="disabled")
+        self.switch_2.configure(state="disabled")
+        self.checkbox_1.select()
+        self.switch_1.select()
+        self.radio_button_3.configure(state="disabled")
+        self.appearance_mode_optionemenu.set("Dark")
+        self.scaling_optionemenu.set("100%")
+        self.optionmenu_1.set("CTkOptionmenu")
+        self.combobox_1.set("CTkComboBox")
+        self.textbox.insert("1.0", "CTkTextbox\n\nLorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.")
+        self.slider_1.configure(command=self.progressbar_2.set)
+        self.slider_2.configure(command=self.progressbar_3.set)
+        self.progressbar_1.configure(mode="indeterminnate")
+        self.progressbar_1.start()
+
+    def open_input_dialog(self):
+        dialog = customtkinter.CTkInputDialog(master=None, text="Type in a number:", title="CTkInputDialog")
+        print("CTkInputDialog:", dialog.get_input())
+
+    def change_appearance_mode(self, new_appearance_mode: str):
+        customtkinter.set_appearance_mode(new_appearance_mode)
+
+    def change_scaling(self, new_scaling: str):
+        new_scaling_float = int(new_scaling.replace("%", "")) / 100
+        customtkinter.set_spacing_scaling(new_scaling_float)
+        customtkinter.set_widget_scaling(new_scaling_float)
+
+    def sidebar_button_callback(self):
+        print("sidebar_button click")
+
+    def on_closing(self, event=0):
+        self.destroy()
+
+
+if __name__ == "__main__":
+    app = App()
+    app.mainloop()

test/manual_integration_tests/test_button_antialiasing.py

@@ -27,21 +27,21 @@ f4 = customtkinter.CTkFrame(app, fg_color="gray90", corner_radius=0)
 f4.grid(row=0, column=3, rowspan=1, columnspan=1, sticky="nsew")
 f4.grid_columnconfigure(0, weight=1)
 
-for i in range(0, 21, 1):
-    b = customtkinter.CTkButton(f1, corner_radius=i, height=34, border_width=2, text=f"{i} {i-2}",
+for i in range(0, 16, 1):
+    b = customtkinter.CTkButton(f1, corner_radius=i, height=30, border_width=1, text=f"{i} {i-1}",
                                 border_color="white", fg_color=None, text_color="white")
     # b = tkinter.Button(f1,  text=f"{i} {i-2}", width=20)
     b.grid(row=i, column=0, pady=5, padx=15, sticky="nsew")
 
-    b = customtkinter.CTkButton(f2, corner_radius=i, height=34, border_width=0, text=f"{i}",
+    b = customtkinter.CTkButton(f2, corner_radius=i, height=30, border_width=0, text=f"{i}",
                                 fg_color="#228da8")
     b.grid(row=i, column=0, pady=5, padx=15, sticky="nsew")
 
-    b = customtkinter.CTkButton(f3, corner_radius=i, height=34, border_width=2, text=f"{i} {i-2}",
+    b = customtkinter.CTkButton(f3, corner_radius=i, height=30, border_width=1, text=f"{i} {i-1}",
                                 fg_color=None, border_color="gray20", text_color="black")
     b.grid(row=i, column=0, pady=5, padx=15, sticky="nsew")
 
-    b = customtkinter.CTkButton(f4, corner_radius=i, height=34, border_width=0, text=f"{i}",
+    b = customtkinter.CTkButton(f4, corner_radius=i, height=30, border_width=0, text=f"{i}",
                                 border_color="gray10", fg_color="#228da8")
     b.grid(row=i, column=0, pady=5, padx=15, sticky="nsew")
 

test/manual_integration_tests/test_ctk_behavior/test_ctk_appearance_mode_change.py

@@ -0,0 +1,32 @@
+import customtkinter
+import sys
+
+customtkinter.set_appearance_mode("dark")
+
+
+app = customtkinter.CTk()
+app.geometry("400x240")
+
+
+def change_appearance_mode():
+    # test appearance mode change while withdrawn
+    app.after(500, app.withdraw)
+    app.after(1500, lambda: customtkinter.set_appearance_mode("light"))
+    app.after(2500, app.deiconify)
+
+    # test appearance mode change while iconified
+    app.after(3500, app.iconify)
+    app.after(4500, lambda: customtkinter.set_appearance_mode("dark"))
+    app.after(5500, app.deiconify)
+
+    if sys.platform.startswith("win"):
+        # test appearance mode change while zoomed
+        app.after(6500, lambda: app.state("zoomed"))
+        app.after(7500, lambda: customtkinter.set_appearance_mode("light"))
+        app.after(8500, lambda: app.state("normal"))
+
+
+button_1 = customtkinter.CTkButton(app, text="start test", command=change_appearance_mode)
+button_1.pack(pady=20, padx=20)
+
+app.mainloop()

test/manual_integration_tests/test_ctk_behavior/test_ctk_iconify_at_beginning.py

@@ -0,0 +1,9 @@
+import customtkinter
+
+app = customtkinter.CTk()
+app.geometry("400x240")
+
+app.iconify()
+app.after(2000, app.deiconify)
+
+app.mainloop()

test/manual_integration_tests/test_ctk_behavior/test_ctk_withdraw_at_beginning.py

@@ -0,0 +1,9 @@
+import customtkinter
+
+app = customtkinter.CTk()
+app.geometry("400x240")
+
+app.withdraw()
+app.after(2000, app.deiconify)
+
+app.mainloop()

test/manual_integration_tests/test_ctk_behavior/test_ctk_zoomed_state.py

@@ -0,0 +1,27 @@
+import customtkinter
+
+customtkinter.set_appearance_mode("dark")
+
+
+app = customtkinter.CTk()
+app.geometry("400x240")
+
+
+def change_appearance_mode():
+    # test zoom with withdraw
+    app.after(1000, lambda: app.state("zoomed"))
+    app.after(2000, app.withdraw)
+    app.after(3000, app.deiconify)
+    app.after(4000, lambda: app.state("normal"))
+
+    # test zoom with iconify
+    app.after(5000, lambda: app.state("zoomed"))
+    app.after(6000, app.iconify)
+    app.after(7000, app.deiconify)
+    app.after(8000, lambda: app.state("normal"))
+
+
+button_1 = customtkinter.CTkButton(app, text="start test", command=change_appearance_mode)
+button_1.pack(pady=20, padx=20)
+
+app.mainloop()

test/manual_integration_tests/test_ctk_toplevel.py

@@ -1,22 +1,49 @@
 import customtkinter
 
+customtkinter.set_appearance_mode("dark")
 
-class ExampleApp(customtkinter.CTk):
-    def __init__(self, *args, **kwargs):
+
+class ToplevelWindow(customtkinter.CTkToplevel):
+    def __init__(self, *args, closing_event=None, **kwargs):
         super().__init__(*args, **kwargs)
+        self.protocol("WM_DELETE_WINDOW", self.closing)
+        self.geometry("500x300")
+        self.closing_event = closing_event
 
-        self.geometry("500x400")
+        self.label = customtkinter.CTkLabel(self, text="ToplevelWindow")
+        self.label.pack(padx=20, pady=20)
 
-        self.button_1 = customtkinter.CTkButton(self, text="Create CTkToplevel", command=self.create_toplevel)
+        self.button_1 = customtkinter.CTkButton(self, text="set dark", command=lambda: customtkinter.set_appearance_mode("dark"))
         self.button_1.pack(side="top", padx=40, pady=40)
 
-    def create_toplevel(self):
-        window = customtkinter.CTkToplevel(self)
-        window.geometry("400x200")
-
-        label = customtkinter.CTkLabel(window, text="CTkToplevel window")
-        label.pack(side="top", fill="both", expand=True, padx=40, pady=40)
+    def closing(self):
+        self.destroy()
+        if self.closing_event is not None:
+            self.closing_event()
 
 
-app = ExampleApp()
-app.mainloop()
+class App(customtkinter.CTk):
+    def __init__(self):
+        super().__init__()
+        self.geometry("500x400")
+
+        self.button_1 = customtkinter.CTkButton(self, text="Open CTkToplevel", command=self.open_toplevel)
+        self.button_1.pack(side="top", padx=40, pady=40)
+        self.button_2 = customtkinter.CTkButton(self, text="iconify toplevel", command=lambda: self.toplevel_window.iconify())
+        self.button_2.pack(side="top", padx=40, pady=40)
+        self.button_3 = customtkinter.CTkButton(self, text="set light", command=lambda: customtkinter.set_appearance_mode("light"))
+        self.button_3.pack(side="top", padx=40, pady=40)
+
+        self.toplevel_window = None
+
+    def open_toplevel(self):
+        if self.toplevel_window is None:  # create toplevel window only if not already open
+            self.toplevel_window = ToplevelWindow(self, closing_event=self.toplevel_close_event)
+
+    def toplevel_close_event(self):
+        self.toplevel_window = None
+
+
+if __name__ == "__main__":
+    app = App()
+    app.mainloop()

test/manual_integration_tests/test_ctk_toplevel_behavior/test_ctk_toplevel_appearance_mode_change.py

@@ -0,0 +1,35 @@
+import customtkinter
+import sys
+
+customtkinter.set_appearance_mode("dark")
+
+
+app = customtkinter.CTk()
+app.geometry("400x400+300+300")
+
+toplevel = customtkinter.CTkToplevel(app)
+toplevel.geometry("350x240+800+300")
+
+
+def change_appearance_mode():
+    # test appearance mode change while withdrawn
+    app.after(500, toplevel.withdraw)
+    app.after(1500, lambda: customtkinter.set_appearance_mode("light"))
+    app.after(2500, toplevel.deiconify)
+
+    # test appearance mode change while iconified
+    app.after(3500, toplevel.iconify)
+    app.after(4500, lambda: customtkinter.set_appearance_mode("dark"))
+    app.after(5500, toplevel.deiconify)
+
+    if sys.platform.startswith("win"):
+        # test appearance mode change while zoomed
+        app.after(6500, lambda: toplevel.state("zoomed"))
+        app.after(7500, lambda: customtkinter.set_appearance_mode("light"))
+        app.after(8500, lambda: toplevel.state("normal"))
+
+
+button_1 = customtkinter.CTkButton(app, text="start test", command=change_appearance_mode)
+button_1.pack(pady=20, padx=20)
+
+app.mainloop()

test/manual_integration_tests/test_ctk_toplevel_behavior/test_ctk_toplevel_iconify_at_beginning.py

@@ -0,0 +1,12 @@
+import customtkinter
+
+app = customtkinter.CTk()
+app.geometry("400x400+300+300")
+
+toplevel = customtkinter.CTkToplevel(app)
+toplevel.geometry("350x240+800+300")
+
+toplevel.iconify()
+toplevel.after(2000, toplevel.deiconify)
+
+app.mainloop()

test/manual_integration_tests/test_ctk_toplevel_behavior/test_ctk_toplevel_withdraw_at_beginning.py

@@ -0,0 +1,12 @@
+import customtkinter
+
+app = customtkinter.CTk()
+app.geometry("400x400+300+300")
+
+toplevel = customtkinter.CTkToplevel(app)
+toplevel.geometry("350x240+800+300")
+
+toplevel.withdraw()
+toplevel.after(2000, toplevel.deiconify)
+
+app.mainloop()

test/manual_integration_tests/test_ctk_toplevel_behavior/test_ctk_toplevel_zoomed_state.py

@@ -0,0 +1,29 @@
+import customtkinter
+
+customtkinter.set_appearance_mode("dark")
+
+app = customtkinter.CTk()
+app.geometry("400x400+300+300")
+
+toplevel = customtkinter.CTkToplevel(app)
+toplevel.geometry("350x240+800+300")
+
+
+def change_appearance_mode():
+    # test zoom with withdraw
+    app.after(1000, lambda: toplevel.state("zoomed"))
+    app.after(2000, toplevel.withdraw)
+    app.after(3000, toplevel.deiconify)
+    app.after(4000, lambda: toplevel.state("normal"))
+
+    # test zoom with iconify
+    app.after(5000, lambda: toplevel.state("zoomed"))
+    app.after(6000, toplevel.iconify)
+    app.after(7000, toplevel.deiconify)
+    app.after(8000, lambda: toplevel.state("normal"))
+
+
+button_1 = customtkinter.CTkButton(app, text="start test", command=change_appearance_mode)
+button_1.pack(pady=20, padx=20)
+
+app.mainloop()

test/manual_integration_tests/test_iconify_destroy.py

@@ -1,21 +0,0 @@
-import customtkinter
-
-app = customtkinter.CTk()
-app.geometry("400x240")
-
-
-def button_function():
-
-    top = customtkinter.CTkToplevel(app)
-
-    app.after(1000, top.iconify)  # hide toplevel
-    app.after(1500, top.deiconify)  # show toplevel
-    app.after(2500, app.iconify)  # hide app
-    app.after(3000, app.deiconify)  # show app
-    app.after(4000, app.destroy)  # destroy everything
-
-
-button = customtkinter.CTkButton(app, command=button_function)
-button.pack(pady=20, padx=20)
-
-app.mainloop()

test/manual_integration_tests/test_new_menu_design.py

@@ -1,53 +0,0 @@
-import customtkinter
-import tkinter
-
-# customtkinter.set_appearance_mode("light")
-
-app = customtkinter.CTk()
-app.geometry("600x500")
-
-menu = tkinter.Menu(tearoff=0, bd=0, relief=tkinter.FLAT, activeforeground="red")
-menu.add_command(label="System")
-menu.add_command(label="Light")
-menu.add_command(label="Dark")
-
-
-class CTkMenu(tkinter.Toplevel):
-    def __init__(self, master, x, y, options):
-        super().__init__(bg="black")
-        super().overrideredirect(True)
-        #self.wm_attributes("-transparentcolor", "black")
-        super().geometry(f"120x{len(options) * (25 + 4) + 4}+{x}+{y}")
-        super().lift()
-        super().transient(master)
-        self.resizable(False, False)
-        super().focus_force()
-        self.focus()
-
-        self.frame = customtkinter.CTkFrame(self, border_width=0, width=120, corner_radius=10, border_color="gray4", fg_color="#333740")
-        self.frame.grid(row=0, column=0, sticky="nsew", rowspan=len(options) + 2, columnspan=1)
-
-        self.frame.grid_rowconfigure(0, minsize=2)
-        self.frame.grid_rowconfigure(len(options) + 1, minsize=2)
-
-        self.grid_columnconfigure(0, weight=1)
-
-        self.buttons = []
-        for index, option in enumerate(options):
-            button = customtkinter.CTkButton(self.frame, height=25, width=108, fg_color="#333740", text_color="gray74", hover_color="#272A2E", corner_radius=8)
-            button.text_label.grid(row=0, column=0, rowspan=2, columnspan=2, sticky="w")
-            button.grid(row=index + 1, column=0, padx=4, pady=2)
-            self.buttons.append(button)
-
-        # master.bind("<Configure>", self.window_drag())
-
-
-
-
-def open_menu():
-    menu = CTkMenu(app, button.winfo_rootx(), button.winfo_rooty() + button.winfo_height() + 4, ["Option 1", "Option 2", "Point 3"])
-
-button = customtkinter.CTkButton(command=open_menu, height=50)
-button.pack(pady=20)
-
-app.mainloop()

test/manual_integration_tests/test_optionmenu_combobox.py

@@ -0,0 +1,44 @@
+import tkinter
+import tkinter.ttk as ttk
+import customtkinter
+
+app = customtkinter.CTk()
+app.title('Test OptionMenu ComboBox.py')
+app.geometry('400x500')
+
+
+def select_callback(choice):
+    choice = variable.get()
+    print("display_selected", choice)
+
+
+countries = ['Bahamas', 'Canada', 'Cuba', 'United States', "long sdhfhjgdshjafghdgshfhjdsfj"]
+
+variable = tkinter.StringVar()
+variable.set("test")
+
+optionmenu_tk = tkinter.OptionMenu(app, variable, *countries, command=select_callback)
+optionmenu_tk.pack(pady=10, padx=10)
+
+optionmenu_1 = customtkinter.CTkOptionMenu(app, variable=variable, values=countries, command=select_callback)
+optionmenu_1.pack(pady=20, padx=10)
+
+optionmenu_2 = customtkinter.CTkOptionMenu(app, variable=variable, values=countries, command=select_callback,
+                                           dynamic_resizing=False)
+optionmenu_2.pack(pady=20, padx=10)
+
+combobox_tk = ttk.Combobox(app, values=countries, textvariable=variable)
+combobox_tk.pack(pady=10, padx=10)
+
+combobox_1 = customtkinter.CTkComboBox(app, variable=variable, values=countries, command=select_callback, width=300)
+combobox_1.pack(pady=20, padx=10)
+
+def set_new_scaling(scaling):
+    customtkinter.set_spacing_scaling(scaling)
+    customtkinter.set_window_scaling(scaling)
+    customtkinter.set_widget_scaling(scaling)
+
+scaling_slider = customtkinter.CTkSlider(app, command=set_new_scaling, from_=0, to=2)
+scaling_slider.pack(pady=20, padx=10)
+
+app.mainloop()

test/manual_integration_tests/test_progressbar_intermediate_mode.py

@@ -0,0 +1,47 @@
+import customtkinter
+import tkinter.ttk as ttk
+
+app = customtkinter.CTk()
+app.geometry("400x600")
+
+p1 = customtkinter.CTkProgressBar(app)
+p1.pack(pady=20)
+p2 = ttk.Progressbar(app)
+p2.pack(pady=20)
+
+s1 = customtkinter.CTkSlider(app, command=p1.set)
+s1.pack(pady=20)
+
+
+def switch_func():
+    if sw1.get() == 1:
+        p1.configure(mode="indeterminate")
+        p2.configure(mode="indeterminate")
+    else:
+        p1.configure(mode="determinate")
+        p2.configure(mode="determinate")
+
+def start():
+    p1.start()
+    p2.start()
+
+def stop():
+    p1.stop()
+    p2.stop()
+
+def step():
+    p1.step()
+    p2.step(10)
+
+
+sw1 = customtkinter.CTkSwitch(app, text="intermediate mode", command=switch_func)
+sw1.pack(pady=20)
+
+b1 = customtkinter.CTkButton(app, text="start", command=start)
+b1.pack(pady=20)
+b2 = customtkinter.CTkButton(app, text="stop", command=stop)
+b2.pack(pady=20)
+b3 = customtkinter.CTkButton(app, text="step", command=step)
+b3.pack(pady=20)
+
+app.mainloop()

test/manual_integration_tests/test_scrollbar.py

@@ -0,0 +1,54 @@
+import tkinter
+import customtkinter
+
+# test with scaling
+# customtkinter.set_widget_scaling(2)
+# customtkinter.set_window_scaling(2)
+# customtkinter.set_spacing_scaling(2)
+
+customtkinter.set_appearance_mode("dark")
+
+app = customtkinter.CTk()
+app.title("test_scrollbar.py")
+app.grid_rowconfigure(0, weight=1)
+app.grid_columnconfigure((0, 2), weight=1)
+
+tk_textbox = tkinter.Text(app, highlightthickness=0, padx=5, pady=5)
+tk_textbox.grid(row=0, column=0, sticky="nsew")
+ctk_textbox_scrollbar = customtkinter.CTkScrollbar(app, command=tk_textbox.yview)
+ctk_textbox_scrollbar.grid(row=0, column=1, padx=0, sticky="ns")
+tk_textbox.configure(yscrollcommand=ctk_textbox_scrollbar.set)
+
+frame_1 = customtkinter.CTkFrame(app)
+frame_1.grid(row=0, column=2, padx=10, pady=10, sticky="nsew")
+frame_1.grid_rowconfigure((0, 1), weight=1)
+frame_1.grid_columnconfigure((0, ), weight=1)
+tk_textbox_1 = tkinter.Text(frame_1, highlightthickness=0, padx=5, pady=5)
+tk_textbox_1.grid(row=0, column=0, sticky="nsew", padx=(5, 0), pady=5)
+ctk_textbox_scrollbar_1 = customtkinter.CTkScrollbar(frame_1, command=tk_textbox_1.yview)
+ctk_textbox_scrollbar_1.grid(row=0, column=1, sticky="ns", padx=(0, 5), pady=5)
+tk_textbox_1.configure(yscrollcommand=ctk_textbox_scrollbar_1.set)
+ctk_textbox_scrollbar_1.configure(scrollbar_color="red", scrollbar_hover_color="darkred",
+                                  border_spacing=0, width=12, fg_color="green", corner_radius=4)
+
+frame_2 = customtkinter.CTkFrame(frame_1)
+frame_2.grid(row=1, column=0, columnspan=2, padx=20, pady=20, sticky="nsew")
+frame_2.grid_rowconfigure((0, ), weight=1)
+frame_2.grid_columnconfigure((0, ), weight=1)
+tk_textbox_2 = tkinter.Text(frame_2, highlightthickness=0, padx=5, pady=5, wrap="none")
+tk_textbox_2.grid(row=0, column=0, sticky="nsew", padx=(5, 0), pady=5)
+ctk_textbox_scrollbar_2 = customtkinter.CTkScrollbar(frame_2, command=tk_textbox_2.yview)
+ctk_textbox_scrollbar_2.grid(row=0, column=1, sticky="ns", padx=(0, 5), pady=5)
+ctk_textbox_scrollbar_2_horizontal = customtkinter.CTkScrollbar(frame_2, command=tk_textbox_2.xview, orientation="horizontal")
+ctk_textbox_scrollbar_2_horizontal.grid(row=1, column=0, sticky="ew", padx=(5, 0), pady=(0, 5))
+tk_textbox_2.configure(yscrollcommand=ctk_textbox_scrollbar_2.set, xscrollcommand=ctk_textbox_scrollbar_2_horizontal.set)
+
+tk_textbox.configure(font=(customtkinter.ThemeManager.theme["text"]["font"], customtkinter.ThemeManager.theme["text"]["size"]))
+tk_textbox_1.configure(font=(customtkinter.ThemeManager.theme["text"]["font"], customtkinter.ThemeManager.theme["text"]["size"]))
+tk_textbox_2.configure(font=(customtkinter.ThemeManager.theme["text"]["font"], customtkinter.ThemeManager.theme["text"]["size"]))
+
+tk_textbox.insert("insert", "\n".join([str(i) for i in range(100)]))
+tk_textbox_1.insert("insert", "\n".join([str(i) for i in range(1000)]))
+tk_textbox_2.insert("insert", "\n".join([str(i) + " - "*30 for i in range(10000)]))
+
+app.mainloop()

test/manual_integration_tests/test_states.py

@@ -3,7 +3,7 @@ import customtkinter
 
 
 app = customtkinter.CTk()
-app.geometry("400x800")
+app.geometry("400x900")
 app.title("CustomTkinter Test")
 
 
@@ -40,8 +40,23 @@ button_4.pack(padx=20, pady=(10, 20))
 
 radiobutton_1 = customtkinter.CTkRadioButton(master=app, text="radiobutton_1")
 radiobutton_1.pack(padx=20, pady=(20, 10))
-button_5 = customtkinter.CTkButton(master=app, text="Disable/Enable entry_1", command=lambda: change_state(radiobutton_1))
+button_5 = customtkinter.CTkButton(master=app, text="Disable/Enable radiobutton_1", command=lambda: change_state(radiobutton_1))
 button_5.pack(padx=20, pady=(10, 20))
 
+optionmenu_1 = customtkinter.CTkOptionMenu(app, values=["test 1", "test 2"])
+optionmenu_1.pack(pady=10, padx=10)
+button_6 = customtkinter.CTkButton(master=app, text="Disable/Enable optionmenu_1", command=lambda: change_state(optionmenu_1))
+button_6.pack(padx=20, pady=(10, 20))
+
+combobox_1 = customtkinter.CTkComboBox(app, values=["test 1", "test 2"])
+combobox_1.pack(pady=10, padx=10)
+button_7 = customtkinter.CTkButton(master=app, text="Disable/Enable combobox_1", command=lambda: change_state(combobox_1))
+button_7.pack(padx=20, pady=(10, 20))
+
+slider_1 = customtkinter.CTkSlider(app)
+slider_1.pack(pady=10, padx=10)
+button_8 = customtkinter.CTkButton(master=app, text="Disable/Enable slider_1", command=lambda: change_state(slider_1))
+button_8.pack(padx=20, pady=(10, 20))
+
 
 app.mainloop()

test/manual_integration_tests/test_textbox.py

@@ -0,0 +1,54 @@
+import tkinter
+import customtkinter
+
+# test with scaling
+# customtkinter.set_widget_scaling(2)
+# customtkinter.set_window_scaling(2)
+# customtkinter.set_spacing_scaling(2)
+
+customtkinter.set_appearance_mode("dark")
+
+app = customtkinter.CTk()
+app.title("test_scrollbar.py")
+app.grid_rowconfigure(0, weight=1)
+app.grid_columnconfigure((0, 2), weight=1)
+
+tk_textbox = customtkinter.CTkTextbox(app, highlightthickness=0, padx=5, pady=5)
+tk_textbox.grid(row=0, column=0, sticky="nsew")
+ctk_textbox_scrollbar = customtkinter.CTkScrollbar(app, command=tk_textbox.yview)
+ctk_textbox_scrollbar.grid(row=0, column=1, padx=0, sticky="ns")
+tk_textbox.configure(yscrollcommand=ctk_textbox_scrollbar.set)
+
+frame_1 = customtkinter.CTkFrame(app)
+frame_1.grid(row=0, column=2, padx=10, pady=10, sticky="nsew")
+frame_1.grid_rowconfigure((0, 1), weight=1)
+frame_1.grid_columnconfigure((0, ), weight=1)
+tk_textbox_1 = customtkinter.CTkTextbox(frame_1, highlightthickness=0, padx=5, pady=5)
+tk_textbox_1.grid(row=0, column=0, sticky="nsew", padx=(5, 0), pady=5)
+ctk_textbox_scrollbar_1 = customtkinter.CTkScrollbar(frame_1, command=tk_textbox_1.yview)
+ctk_textbox_scrollbar_1.grid(row=0, column=1, sticky="ns", padx=(0, 5), pady=5)
+tk_textbox_1.configure(yscrollcommand=ctk_textbox_scrollbar_1.set)
+ctk_textbox_scrollbar_1.configure(scrollbar_color="red", scrollbar_hover_color="darkred",
+                                  border_spacing=0, width=12, fg_color="green", corner_radius=4)
+
+frame_2 = customtkinter.CTkFrame(frame_1)
+frame_2.grid(row=1, column=0, columnspan=2, padx=20, pady=20, sticky="nsew")
+frame_2.grid_rowconfigure((0, ), weight=1)
+frame_2.grid_columnconfigure((0, ), weight=1)
+tk_textbox_2 = customtkinter.CTkTextbox(frame_2, highlightthickness=0, padx=5, pady=5, wrap="none")
+tk_textbox_2.grid(row=0, column=0, sticky="nsew", padx=(5, 0), pady=5)
+ctk_textbox_scrollbar_2 = customtkinter.CTkScrollbar(frame_2, command=tk_textbox_2.yview)
+ctk_textbox_scrollbar_2.grid(row=0, column=1, sticky="ns", padx=(0, 5), pady=5)
+ctk_textbox_scrollbar_2_horizontal = customtkinter.CTkScrollbar(frame_2, command=tk_textbox_2.xview, orientation="horizontal")
+ctk_textbox_scrollbar_2_horizontal.grid(row=1, column=0, sticky="ew", padx=(5, 0), pady=(0, 5))
+tk_textbox_2.configure(yscrollcommand=ctk_textbox_scrollbar_2.set, xscrollcommand=ctk_textbox_scrollbar_2_horizontal.set)
+
+tk_textbox.configure(font=(customtkinter.ThemeManager.theme["text"]["font"], customtkinter.ThemeManager.theme["text"]["size"]))
+tk_textbox_1.configure(font=(customtkinter.ThemeManager.theme["text"]["font"], customtkinter.ThemeManager.theme["text"]["size"]))
+tk_textbox_2.configure(font=(customtkinter.ThemeManager.theme["text"]["font"], customtkinter.ThemeManager.theme["text"]["size"]))
+
+tk_textbox.insert("insert", "\n".join([str(i) for i in range(100)]))
+tk_textbox_1.insert("insert", "\n".join([str(i) for i in range(1000)]))
+tk_textbox_2.insert("insert", "\n".join([str(i) + " - "*30 for i in range(10000)]))
+
+app.mainloop()

test/manual_integration_tests/test_variables.py

@@ -5,15 +5,20 @@ TEST_CONFIGURE = True
 TEST_REMOVING = False
 
 app = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
-app.geometry("400x600")
+app.geometry("400x900")
 app.title("Tkinter Variable Test")
 
+def checkbox_event():
+    print("checkbox_event")
+
 txt_var = tkinter.StringVar(value="")
-entry_1 = customtkinter.CTkEntry(app, width=200, textvariable=txt_var)
+entry_1 = customtkinter.CTkEntry(app, width=200, textvariable=txt_var, placeholder_text="placeholder")
 entry_1.pack(pady=15)
-txt_var.set("new text wjkfjdshkjfb")
+txt_var.set("new text test")
 if TEST_CONFIGURE: entry_1.configure(textvariable=txt_var)
 if TEST_REMOVING: entry_1.configure(textvariable="")
+#entry_1.delete(0, "end")
+#entry_1.insert(0, "sadsad")
 
 label_1 = customtkinter.CTkLabel(app, width=200, textvariable=txt_var)
 label_1.pack(pady=15)
@@ -46,11 +51,13 @@ if TEST_CONFIGURE: progress_1.configure(variable=int_var)
 if TEST_REMOVING: progress_1.configure(variable="")
 
 check_var = tkinter.StringVar(value="on")
-check_1 = customtkinter.CTkCheckBox(app, text="check 1", variable=check_var, onvalue="on", offvalue="off")
+check_1 = customtkinter.CTkCheckBox(app, text="check 1", variable=check_var, onvalue="on", offvalue="off", textvariable=txt_var,
+                                    command=checkbox_event)
 check_1.pack(pady=15)
 if TEST_CONFIGURE: check_1.configure(variable=check_var)
 if TEST_REMOVING: check_1.configure(variable="")
-print("check_1", check_1.get())
+
+print("check 1 created")
 
 check_2 = customtkinter.CTkCheckBox(app, text="check 2", variable=check_var, onvalue="on", offvalue="off")
 check_2.pack(pady=15)
@@ -67,8 +74,18 @@ def switch_event():
 s_var = tkinter.StringVar(value="on")
 switch_1 = customtkinter.CTkSwitch(master=app, variable=s_var, textvariable=s_var, onvalue="on", offvalue="off", command=switch_event)
 switch_1.pack(pady=20, padx=10)
-switch_1 = customtkinter.CTkSwitch(master=app, variable=s_var, textvariable=s_var, onvalue="on", offvalue="off")
-switch_1.pack(pady=20, padx=10)
-#switch_1.toggle()
+switch_2 = customtkinter.CTkSwitch(master=app, variable=s_var, textvariable=s_var, onvalue="on", offvalue="off")
+switch_2.pack(pady=20, padx=10)
+
+optionmenu_var = tkinter.StringVar(value="test")
+optionmenu_1 = customtkinter.CTkOptionMenu(master=app, variable=None, values=["Option 1", "Option 2", "Option 3"])
+optionmenu_1.pack(pady=20, padx=10)
+optionmenu_1.configure(variable=optionmenu_var)
+combobox_1 = customtkinter.CTkComboBox(master=app, values=["Option 1", "Option 2", "Option 3"])
+combobox_1.pack(pady=20, padx=10)
+combobox_1.configure(variable=optionmenu_var)
+
+radio_1 = customtkinter.CTkRadioButton(app, textvariable=txt_var)
+radio_1.pack(pady=20, padx=10)
 
 app.mainloop()

test/manual_integration_tests/test_window_geometry.py

@@ -0,0 +1,37 @@
+import customtkinter
+
+customtkinter.set_window_scaling(1.3)
+
+app = customtkinter.CTk()
+toplevel = customtkinter.CTkToplevel(app)
+
+
+app.after(1000, lambda: app.geometry("300x300"))
+app.after(2000, lambda: app.geometry("-100-100"))
+app.after(3000, lambda: app.geometry("+-100+-100"))
+app.after(4000, lambda: app.geometry("+100+100"))
+app.after(5000, lambda: app.geometry("300x300-100-100"))
+app.after(6000, lambda: app.geometry("300x300+-100+-100"))
+app.after(7000, lambda: app.geometry("300x300+100+100"))
+
+app.after(8000, lambda: app.geometry("400x400"))
+app.after(9000, lambda: app.geometry("+400+400"))
+
+
+app.after(10000, lambda: toplevel.geometry("300x300"))
+app.after(11000, lambda: toplevel.geometry("-100-100"))
+app.after(12000, lambda: toplevel.geometry("+-100+-100"))
+app.after(13000, lambda: toplevel.geometry("+100+100"))
+app.after(14000, lambda: toplevel.geometry("300x300-100-100"))
+app.after(15000, lambda: toplevel.geometry("300x300+-100+-100"))
+app.after(16000, lambda: toplevel.geometry("300x300+100+100"))
+
+app.after(17000, lambda: toplevel.geometry("300x300"))
+app.after(18000, lambda: toplevel.geometry("+500+500"))
+
+
+app.after(19000, lambda: print("app:", app.geometry()))
+app.after(19000, lambda: print("toplevel:", toplevel.geometry()))
+
+
+app.mainloop()

test/manual_integration_tests/text_entry_placeholder.py

@@ -0,0 +1,27 @@
+import customtkinter
+
+app = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
+app.geometry("400x400")
+app.title("test_entry_placeholder.py")
+
+str_var = customtkinter.StringVar(value="test")
+
+entry_1 = customtkinter.CTkEntry(app, placeholder_text="placeholder", textvariable=str_var)
+entry_1.pack(pady=20)
+
+entry_2 = customtkinter.CTkEntry(app, placeholder_text="placeholder", textvariable=str_var)
+entry_2.pack(pady=20)
+entry_2.insert(0, "sdfjk ")
+entry_2.delete(0, 2)
+
+entry_3 = customtkinter.CTkEntry(app, placeholder_text="placeholder")
+entry_3.pack(pady=(40, 20))
+entry_3.insert(0, "sdfjk")
+entry_3.delete(0, "end")
+
+entry_4 = customtkinter.CTkEntry(app, placeholder_text="password", show="*")
+entry_4.pack(pady=(20, 20))
+entry_4.insert(0, "sdfjk")
+entry_4.delete(0, 2)
+
+app.mainloop()