Bump to 4.5.9

Add scrollbar default values in .json theme files

CHANGELOG.md

@@ -4,14 +4,35 @@ 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.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).
 
 
@@ -41,17 +42,17 @@ import customtkinter
 customtkinter.set_appearance_mode("System")  # Modes: system (default), light, dark
 customtkinter.set_default_color_theme("blue")  # Themes: blue (default), dark-blue, green
 
-root_tk = customtkinter.CTk()  # create CTk window like you do with the Tk window
-root_tk.geometry("400x240")
+app = customtkinter.CTk()  # create CTk window like you do with the Tk window
+app.geometry("400x240")
 
 def button_function():
     print("button pressed")
 
 # Use CTkButton instead of tkinter Button
-button = customtkinter.CTkButton(master=root_tk, text="CTkButton", command=button_function)
+button = customtkinter.CTkButton(master=app, text="CTkButton", command=button_function)
 button.place(relx=0.5, rely=0.5, anchor=tkinter.CENTER)
 
-root_tk.mainloop()
+app.mainloop()
 ```
 which gives the following (macOS dark mode on):
 

customtkinter/__init__.py

@@ -1,7 +1,9 @@
-__version__ = "4.0.1"
+__version__ = "4.5.9"
 
 import os
 import sys
+from tkinter.constants import *
+from tkinter import StringVar, IntVar, DoubleVar, BooleanVar
 
 # import manager classes
 from .settings import Settings
@@ -12,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
@@ -21,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: " +
@@ -36,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
@@ -46,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

@@ -19,7 +19,7 @@ except Exception:
 class AppearanceModeTracker:
 
     callback_list = []
-    root_tk_list = []
+    app_list = []
     update_loop_running = False
     update_loop_interval = 500  # milliseconds
 
@@ -40,17 +40,20 @@ class AppearanceModeTracker:
         cls.callback_list.append(callback)
 
         if widget is not None:
-            root_tk = cls.get_tk_root_of_widget(widget)
-            if root_tk not in cls.root_tk_list:
-                cls.root_tk_list.append(root_tk)
+            app = cls.get_tk_root_of_widget(widget)
+            if app not in cls.app_list:
+                cls.app_list.append(app)
 
                 if not cls.update_loop_running:
-                    root_tk.after(500, cls.update)
+                    app.after(500, 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:
@@ -97,9 +100,9 @@ class AppearanceModeTracker:
                 cls.update_callbacks()
 
         # find an existing tkinter.Tk object for the next call of .after()
-        for root_tk in cls.root_tk_list:
+        for app in cls.app_list:
             try:
-                root_tk.after(cls.update_loop_interval, cls.update)
+                app.after(cls.update_loop_interval, cls.update)
                 return
             except Exception:
                 continue

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": ["white", "#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

@@ -27,7 +27,15 @@
     "switch_progress": ["#00e6c3", "#00e6c3"],
     "switch_button": ["#2e324a", "#2e324a"],
     "switch_button_hover": ["#2e324a", "#2e324a"],
-    "darken_factor": 0.1
+    "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": {
@@ -54,7 +62,7 @@
     "entry_border_width": 2,
     "frame_corner_radius": 10,
     "frame_border_width": 2,
-    "label_corner_radius": 8,
+    "label_corner_radius": 0,
     "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:
+    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: float, orientation: str) -> bool:
         """ Draws a rounded bar on the canvas, which is split in half according to the argument 'progress_value' (0 - 1).
             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, 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, 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: 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
@@ -417,8 +715,8 @@ class DrawEngine:
 
         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: float, orientation: str) -> bool:
 
         requires_recoloring, requires_recoloring_2 = False, False
 
@@ -452,8 +750,8 @@ 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,
+                                                                                     ("inner_oval_1", "inner_oval_4"))
 
             # 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)
@@ -483,8 +781,8 @@ class DrawEngine:
 
         # 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,
+                                                                                     ("inner_oval_3", "inner_oval_4"))
 
             # set positions of progress corner parts
             self._canvas.coords("progress_oval_1_a", border_width + inner_corner_radius,
@@ -514,11 +812,11 @@ class DrawEngine:
 
         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 +828,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 +836,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,
+                                                                                          slider_value, orientation)
 
         # create slider button part
         if not self._canvas.find_withtag("slider_parts"):
@@ -583,12 +881,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,
+                                                                                       slider_value, orientation)
 
         # create 4 circles (if not needed, then less)
         if not self._canvas.find_withtag("slider_oval_1_a"):
@@ -672,7 +970,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 +1139,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

@@ -51,7 +51,7 @@ class FontManager:
             return cls.windows_load_font(font_path, private=True, enumerable=False)
 
         # Linux
-        elif sys.platform.startswith("win"):
+        elif sys.platform.startswith("linux"):
             try:
                 shutil.copy(font_path, os.path.expanduser("~/.fonts/"))
                 return True

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,42 +135,45 @@ 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 root_tk in cls.window_widgets_dict.keys():
+        for app in cls.window_widgets_dict.keys():
             try:
-                root_tk.after(cls.update_loop_interval, cls.check_dpi_scaling)
+                app.after(cls.update_loop_interval, cls.check_dpi_scaling)
                 return
             except Exception:
                 continue

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,34 +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: 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):
-        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 != "":
@@ -133,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)
@@ -142,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
@@ -176,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
 
@@ -230,94 +235,86 @@ 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 "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"]
 
-        super().configure(*args, **kwargs)
+        if "width" in kwargs:
+            self.set_dimensions(width=kwargs.pop("width"))
 
-        if require_redraw:
-            self.draw()
+        if "height" in kwargs:
+            self.set_dimensions(height=kwargs.pop("height"))
+
+        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
@@ -326,18 +323,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:
@@ -348,23 +345,23 @@ 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:
+    def clicked(self, event=None):
+        if self.command is not None:
             if self.state is not tkinter.DISABLED:
 
                 # click animation: change color with .on_leave() and back to normal after 100ms with click_animation()
@@ -372,4 +369,4 @@ class CTkButton(CTkBaseClass):
                 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
@@ -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,8 @@ 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.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 +129,146 @@ 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 "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 +286,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,11 +303,8 @@ class CTkCheckBox(CTkBaseClass):
             self.variable.set(self.onvalue)
             self.variable_callback_blocked = False
 
-        if self.function is not None:
-            try:
-                self.function()
-            except:
-                pass
+        if self.command is not None:
+            self.command()
 
     def deselect(self, from_variable_callback=False):
         self.check_state = False
@@ -339,11 +315,8 @@ class CTkCheckBox(CTkBaseClass):
             self.variable.set(self.offvalue)
             self.variable_callback_blocked = False
 
-        if self.function is not None:
-            try:
-                self.function()
-            except:
-                pass
+        if self.command is not None:
+            self.command()
 
     def get(self):
         return self.onvalue if self.check_state is True else self.offvalue

customtkinter/widgets/ctk_combobox.py

@@ -0,0 +1,288 @@
+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
+
+        if len(self.values) > 0:
+            self.current_value = self.values[0]
+        else:
+            self.current_value = "CTkComboBox"
+
+        self.dropdown_menu = DropdownMenu(master=self,
+                                          values=self.values,
+                                          command=self.set,
+                                          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))))
+
+        self.entry.delete(0, tkinter.END)
+        self.entry.insert(0, self.current_value)
+
+        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 "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 set(self, value: str, from_variable_callback: bool = False):
+        self.current_value = value
+
+        if self.state == "readonly":
+            self.entry.configure(state="normal")
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, self.current_value)
+            self.entry.configure(state="readonly")
+        else:
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, self.current_value)
+
+        if not from_variable_callback:
+            if self.command is not None:
+                self.command(self.current_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.draw()
         self.set_placeholder()
+        self.draw()
 
     def set_scaling(self, *args, **kwargs):
         super().set_scaling( *args, **kwargs)
@@ -78,123 +87,150 @@ 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_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 set_dimensions(self, width=None, height=None):
+        super().set_dimensions(width, height)
 
-    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
+        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):
-        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.pop("width"))
+
+        if "height" in kwargs:
+            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)
 
-        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 "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 set_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 clear_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.set_placeholder()
+
+    def entry_focus_in(self, event=None):
+        self.clear_placeholder()
 
     def delete(self, *args, **kwargs):
         self.entry.delete(*args, **kwargs)
-        self.set_placeholder()
+
+        if self.entry.get() == "":
+            self.set_placeholder()
 
     def insert(self, *args, **kwargs):
         self.clear_placeholder()
+
         return self.entry.insert(*args, **kwargs)
 
     def get(self):
@@ -202,3 +238,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

@@ -1,8 +1,5 @@
-import tkinter
-
 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
 
@@ -16,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"]:
@@ -41,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)
 
@@ -65,62 +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.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"]
+        if "border_color" in kwargs:
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
 
-            del kwargs["bg_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"]
 
-        super().configure(*args, **kwargs)
+        if "border_width" in kwargs:
+            self.border_width = kwargs.pop("border_width")
+            require_redraw = True
 
-        if require_redraw:
-            self.draw()
+        if "width" in kwargs:
+            self.set_dimensions(width=kwargs.pop("width"))
+
+        if "height" in kwargs:
+            self.set_dimensions(height=kwargs.pop("height"))
+
+        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,38 +68,55 @@ 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.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"])
@@ -105,23 +127,25 @@ class CTkLabel(CTkBaseClass):
             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
             del kwargs["text_color"]
 
-        self.text_label.configure(*args, **kwargs)
+        if "width" in kwargs:
+            self.set_dimensions(width=kwargs["width"])
+            del kwargs["width"]
 
-        if require_redraw:
-            self.draw()
+        if "height" in kwargs:
+            self.set_dimensions(height=kwargs["height"])
+            del kwargs["height"]
+
+        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.text_label.configure(**kwargs)  # pass remaining kwargs to label
 
     def set_text(self, text):
         self.text = text

customtkinter/widgets/ctk_optionmenu.py

@@ -0,0 +1,296 @@
+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.set,
+                                          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.set(self.variable.get(), from_variable_callback=True)
+
+    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 "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.set(self.variable.get(), from_variable_callback=True)
+            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_menu.configure(text_font=kwargs.pop("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.set(self.variable.get(), from_variable_callback=True)
+
+    def set(self, value: str, from_variable_callback: bool = False):
+        self.current_value = value
+
+        self.text_label.configure(text=self.current_value)
+
+        if self.variable is not None and not from_variable_callback:
+            self.variable_callback_blocked = True
+            self.variable.set(self.current_value)
+            self.variable_callback_blocked = False
+
+        if not from_variable_callback:
+            if self.command is not None:
+                self.command(self.current_value)
+
+    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

@@ -3,12 +3,11 @@ import tkinter
 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,
@@ -35,7 +34,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
@@ -59,8 +58,8 @@ class CTkProgressBar(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, rowspan=1, columnspan=1, sticky="nswe")
         self.draw_engine = DrawEngine(self.canvas)
 
@@ -78,7 +77,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.draw()
 
     def destroy(self):
@@ -95,36 +101,26 @@ 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),
+        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 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"]
@@ -159,10 +155,15 @@ class CTkProgressBar(CTkBaseClass):
 
             del kwargs["variable"]
 
-        super().configure(*args, **kwargs)
+        if "width" in kwargs:
+            self.set_dimensions(width=kwargs["width"])
+            del kwargs["width"]
 
-        if require_redraw is True:
-            self.draw()
+        if "height" in kwargs:
+            self.set_dimensions(height=kwargs["height"])
+            del kwargs["height"]
+
+        super().configure(require_redraw=require_redraw, **kwargs)
 
     def variable_callback(self, var_name, index, mode):
         if not self.variable_callback_blocked:

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,122 @@ 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 "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 +253,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,7 +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.draw()
 
     def destroy(self):
@@ -117,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),
@@ -140,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:
@@ -224,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)
@@ -236,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
@@ -293,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:
@@ -310,7 +328,12 @@ class CTkSlider(CTkBaseClass):
 
             del kwargs["variable"]
 
-        super().configure(*args, **kwargs)
+        if "width" in kwargs:
+            self.set_dimensions(width=kwargs["width"])
+            del kwargs["width"]
 
-        if require_redraw:
-            self.draw()
+        if "height" in kwargs:
+            self.set_dimensions(height=kwargs["height"])
+            del kwargs["height"]
+
+        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,42 +209,42 @@ 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)
                 self.variable_callback_blocked = False
 
+            if self.command is not None:
+                self.command()
+
     def deselect(self, from_variable_callback=False):
         if self.state is not tkinter.DISABLED or from_variable_callback:
             self.check_state = False
 
             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)
                 self.variable_callback_blocked = False
 
+            if self.command is not None:
+                self.command()
+
     def get(self):
         return self.onvalue if self.check_state is True else self.offvalue
 
@@ -254,13 +252,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 +267,60 @@ 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 "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,168 @@
+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,
+                                    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 "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

@@ -2,7 +2,12 @@ import tkinter
 import tkinter.ttk as ttk
 import copy
 import re
-from typing import Callable, Union, TypedDict
+from typing import Callable, Union
+
+try:
+    from typing import TypedDict
+except ImportError:
+    from typing_extensions import TypedDict
 
 from ..windows.ctk_tk import CTk
 from ..windows.ctk_toplevel import CTkToplevel
@@ -12,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
 
@@ -69,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:
@@ -101,86 +117,93 @@ 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
 
-    def detect_color_of_master(self):
+    def detect_color_of_master(self, master_widget=None):
         """ detect color of self.master widget to set correct bg_color """
 
-        if isinstance(self.master, CTkBaseClass) and hasattr(self.master, "fg_color"):  # master is CTkFrame
-            return self.master.fg_color
+        if master_widget is None:
+            master_widget = self.master
 
-        elif isinstance(self.master, (ttk.Frame, ttk.LabelFrame, ttk.Notebook)):  # master is ttk widget
+        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)
+
+        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(self.master.winfo_class(), 'background')
+                return ttk_style.lookup(master_widget.winfo_class(), 'background')
             except Exception:
                 return "#FFFFFF", "#000000"
 
         else:  # master is normal tkinter widget
             try:
-                return self.master.cget("bg")  # try to get bg color by .cget() method
+                return master_widget.cget("bg")  # try to get bg color by .cget() method
             except Exception:
                 return "#FFFFFF", "#000000"
 
     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 apply_widget_scaling(self, value):
+    def set_dimensions(self, width=None, height=None):
+        if width is not None:
+            self._desired_width = width
+        if height is not None:
+            self._desired_height = 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: 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
 
@@ -189,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

@@ -102,8 +102,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

@@ -68,7 +68,7 @@ class CTk(tkinter.Tk):
 
         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
@@ -129,27 +129,42 @@ 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))
+            # 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))
+        else:
+            return self.reverse_geometry_scaling(super().geometry())
 
     def apply_geometry_scaling(self, geometry_string):
-        numbers = list(map(int, re.split(r"[x+]", geometry_string)))  # split geometry string into list of numbers
+        value_list = re.split(r"[x+-]", geometry_string)
+        separator_list = re.split(r"\d+", 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}"
-        else:
-            return geometry_string
+        if len(value_list) == 2:
+            scaled_width = str(round(int(value_list[0]) * self.window_scaling))
+            scaled_height = str(round(int(value_list[1]) * self.window_scaling))
+            return f"{scaled_width}x{scaled_height}"
+        elif len(value_list) == 4:
+            scaled_width = str(round(int(value_list[0]) * self.window_scaling))
+            scaled_height = str(round(int(value_list[1]) * self.window_scaling))
+            return f"{scaled_width}x{scaled_height}{separator_list[2]}{value_list[2]}{separator_list[3]}{value_list[3]}"
+
+    def reverse_geometry_scaling(self, scaled_geometry_string):
+        value_list = re.split(r"[x+-]", scaled_geometry_string)
+        separator_list = re.split(r"\d+", scaled_geometry_string)
+
+        if len(value_list) == 2:
+            width = str(round(int(value_list[0]) / self.window_scaling))
+            height = str(round(int(value_list[1]) / self.window_scaling))
+            return f"{width}x{height}"
+        elif len(value_list) == 4:
+            width = str(round(int(value_list[0]) / self.window_scaling))
+            height = str(round(int(value_list[1]) / self.window_scaling))
+            return f"{width}x{height}{separator_list[2]}{value_list[2]}{separator_list[3]}{value_list[3]}"
 
     def apply_window_scaling(self, value):
         if isinstance(value, (int, float)):

customtkinter/windows/ctk_toplevel.py

@@ -47,7 +47,7 @@ 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.geometry(f"{self._current_width}x{self._current_height}")
 
         if sys.platform.startswith("win"):
             if self.appearance_mode == 1:
@@ -63,7 +63,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
@@ -84,18 +84,30 @@ class CTkToplevel(tkinter.Toplevel):
             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
+        value_list = re.split(r"[x+-]", geometry_string)
+        separator_list = re.split(r"\d+", 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}"
-        else:
-            return geometry_string
+        if len(value_list) == 2:
+            scaled_width = str(round(int(value_list[0]) * self.window_scaling))
+            scaled_height = str(round(int(value_list[1]) * self.window_scaling))
+            return f"{scaled_width}x{scaled_height}"
+        elif len(value_list) == 4:
+            scaled_width = str(round(int(value_list[0]) * self.window_scaling))
+            scaled_height = str(round(int(value_list[1]) * self.window_scaling))
+            return f"{scaled_width}x{scaled_height}{separator_list[2]}{value_list[2]}{separator_list[3]}{value_list[3]}"
+
+    def reverse_geometry_scaling(self, scaled_geometry_string):
+        value_list = re.split(r"[x+-]", scaled_geometry_string)
+        separator_list = re.split(r"\d+", scaled_geometry_string)
+
+        if len(value_list) == 2:
+            width = str(round(int(value_list[0]) / self.window_scaling))
+            height = str(round(int(value_list[1]) / self.window_scaling))
+            return f"{width}x{height}"
+        elif len(value_list) == 4:
+            width = str(round(int(value_list[0]) / self.window_scaling))
+            height = str(round(int(value_list[1]) / self.window_scaling))
+            return f"{width}x{height}{separator_list[2]}{value_list[2]}{separator_list[3]}{value_list[3]}"
 
     def apply_window_scaling(self, value):
         if isinstance(value, (int, float)):
@@ -103,13 +115,16 @@ class CTkToplevel(tkinter.Toplevel):
         else:
             return value
 
-    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))
+            # 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))
+        else:
+            return self.reverse_geometry_scaling(super().geometry())
 
     def destroy(self):
         AppearanceModeTracker.remove(self.set_appearance_mode)

examples/complex_example.py

@@ -14,10 +14,8 @@ class App(customtkinter.CTk):
     def __init__(self):
         super().__init__()
 
-        self.title("CustomTkinter complex example")
+        self.title("CustomTkinter complex_example.py")
         self.geometry(f"{App.WIDTH}x{App.HEIGHT}")
-        # self.minsize(App.WIDTH, App.HEIGHT)
-
         self.protocol("WM_DELETE_WINDOW", self.on_closing)  # call .on_closing() when app gets closed
 
         # ============ create two frames ============
@@ -48,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 ============
 
@@ -95,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)
@@ -136,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")
@@ -171,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()
@@ -188,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

@@ -12,7 +12,7 @@ PATH = os.path.dirname(os.path.realpath(__file__))
 
 class App(customtkinter.CTk):
 
-    APP_NAME = "CustomTkinter background gradient image"
+    APP_NAME = "CustomTkinter example_background_image.py"
     WIDTH = 900
     HEIGHT = 600
 
@@ -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,5 +1,5 @@
 import tkinter
-import customtkinter  # <- import the CustomTkinter module
+import customtkinter
 from PIL import Image, ImageTk  # <- import PIL for the images
 import os
 
@@ -8,9 +8,9 @@ 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"
 
-root_tk = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
-root_tk.geometry("450x260")
-root_tk.title("CustomTkinter button images")
+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")
 
 
 def button_function():
@@ -29,10 +29,10 @@ add_user_image = ImageTk.PhotoImage(Image.open(PATH + "/test_images/add-user.png
 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))
 
-root_tk.grid_rowconfigure(0, weight=1)
-root_tk.grid_columnconfigure(0, weight=1, minsize=200)
+app.grid_rowconfigure(0, weight=1)
+app.grid_columnconfigure(0, weight=1, minsize=200)
 
-frame_1 = customtkinter.CTkFrame(master=root_tk, width=250, height=240, corner_radius=15)
+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)
@@ -56,9 +56,9 @@ button_4 = customtkinter.CTkButton(master=frame_1, image=home_image, text="", wi
                                    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=root_tk, image=add_user_image, text="Add User", width=130, height=70, border_width=3,
+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)
 
-root_tk.mainloop()
+app.mainloop()

examples/simple_example.py

@@ -1,61 +1,62 @@
 import tkinter
-import customtkinter  # <- import the CustomTkinter module
+import customtkinter
 
 customtkinter.set_appearance_mode("dark")  # Modes: "System" (standard), "Dark", "Light"
-# customtkinter.set_default_color_theme("blue")  # Themes: "blue" (standard), "green", "dark-blue"
+customtkinter.set_default_color_theme("blue")  # Themes: "blue" (standard), "green", "dark-blue"
 
-root_tk = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
-root_tk.geometry("400x480")
-root_tk.title("CustomTkinter Test")
+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=root_tk, 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)
+button_1.configure(state='disabled')
 
-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)
 
-root_tk.mainloop()
+app.mainloop()

examples/simple_example_standard_tkinter.py

@@ -3,7 +3,7 @@ import tkinter
 
 app = tkinter.Tk()
 app.geometry("400x350")
-app.title("Standard Tkinter Test")
+app.title("simple_example_standard_tkinter.py")
 
 
 def button_function():

pyproject.toml

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

setup.cfg

@@ -1,8 +1,8 @@
 [metadata]
 name = customtkinter
-version = 4.0.1
+version = 4.5.9
 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
@@ -14,10 +14,12 @@ classifiers =
     Programming Language :: Python :: 3 :: Only
 
 [options]
+python_requires = >=3.7
 packages =
     customtkinter
     customtkinter.widgets
     customtkinter.windows
 install_requires =
     darkdetect
+    typing_extensions; python_version<="3.7"
 include_package_data = True

test/manual_integration_tests/complex_example_new.py

@@ -0,0 +1,148 @@
+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="Widget 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=["90%", "100%", "110%"],
+                                                               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)
+        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.slider_1 = customtkinter.CTkSlider(self.slider_progressbar_frame)
+        self.slider_1.grid(row=1, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+        self.slider_2 = customtkinter.CTkSlider(self.slider_progressbar_frame, from_=0, to=4, number_of_steps=4)
+        self.slider_2.grid(row=2, column=0, padx=(20, 10), pady=(10, 10), sticky="ew")
+        self.slider_3 = customtkinter.CTkSlider(self.slider_progressbar_frame, orient="vertical")
+        self.slider_3.grid(row=0, column=1, rowspan=4, padx=(10, 10), pady=(10, 10), sticky="ns")
+        self.progressbar_2 = customtkinter.CTkProgressBar(self.slider_progressbar_frame, orient="vertical")
+        self.progressbar_2.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.textbox.tag_add("headline", "1.0", "1.end")
+        #self.textbox.tag_config("headline", foreground="red")
+
+    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_askdialog.py

@@ -1,9 +1,7 @@
-from tkinter.constants import CENTER, LEFT
 import tkinter
 import tkinter.messagebox
 from tkinter import filedialog as fd
-import customtkinter  # <- import the CustomTkinter module
-import os
+import customtkinter
 
 
 class App(customtkinter.CTk):

test/manual_integration_tests/test_button_antialiasing.py

@@ -1,5 +1,4 @@
 import customtkinter
-import tkinter
 
 customtkinter.set_default_color_theme("blue")
 customtkinter.set_appearance_mode("dark")

test/manual_integration_tests/test_configure_dimensions.py

@@ -0,0 +1,36 @@
+import customtkinter
+import random
+
+
+app = customtkinter.CTk()
+app.geometry("400x400")
+
+
+def button_callback():
+    button_1.configure(width=random.randint(30, 200), height=random.randint(30, 60))
+    frame_1.configure(width=random.randint(30, 200), height=random.randint(30, 200))
+    label_1.configure(width=random.randint(30, 200), height=random.randint(30, 40))
+    entry_1.configure(width=random.randint(30, 200), height=random.randint(30, 40))
+    progressbar_1.configure(width=random.randint(30, 200), height=random.randint(10, 16))
+    slider_1.configure(width=random.randint(30, 200), height=random.randint(14, 20))
+
+
+button_1 = customtkinter.CTkButton(app, text="button_1", command=button_callback)
+button_1.pack(pady=10)
+
+frame_1 = customtkinter.CTkFrame(app)
+frame_1.pack(pady=10)
+
+label_1 = customtkinter.CTkLabel(app, fg_color="green")
+label_1.pack(pady=10)
+
+entry_1 = customtkinter.CTkEntry(app, placeholder_text="placeholder")
+entry_1.pack(pady=10)
+
+progressbar_1 = customtkinter.CTkProgressBar(app)
+progressbar_1.pack(pady=10)
+
+slider_1 = customtkinter.CTkSlider(app)
+slider_1.pack(pady=10)
+
+app.mainloop()

test/manual_integration_tests/test_ctk_toplevel.py

@@ -1,4 +1,3 @@
-import tkinter
 import customtkinter
 
 

test/manual_integration_tests/test_iconify_destroy.py

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

test/manual_integration_tests/test_new_menu_design.py

@@ -1,53 +1,71 @@
 import customtkinter
 import tkinter
-
-# customtkinter.set_appearance_mode("light")
-
-root_tk = customtkinter.CTk()
-root_tk.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")
+import sys
 
 
 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()
+        super().__init__()
 
-        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.overrideredirect(True)
+        self.geometry(f"120x{len(options) * (25 + 3) + 3}+{x}+{y}")
 
-        self.frame.grid_rowconfigure(0, minsize=2)
-        self.frame.grid_rowconfigure(len(options) + 1, minsize=2)
+        if sys.platform.startswith("darwin"):
+            self.overrideredirect(False)
+            self.wm_attributes("-transparent", True)  # turn off shadow
+            self.config(bg='systemTransparent')  # transparent bg
+            self.frame = customtkinter.CTkFrame(self, border_width=0, width=120, corner_radius=6, border_color="gray4", fg_color="#333740")
+        elif sys.platform.startswith("win"):
+            self.configure(bg="#FFFFF1")
+            self.wm_attributes("-transparent", "#FFFFF1")
+            self.focus()
+            self.frame = customtkinter.CTkFrame(self, border_width=0, width=120, corner_radius=6, border_color="gray4", fg_color="#333740",
+                                                overwrite_preferred_drawing_method="circle_shapes")
+        else:
+            self.configure(bg="#FFFFF1")
+            self.wm_attributes("-transparent", "#FFFFF1")
+            self.frame = customtkinter.CTkFrame(self, border_width=0, width=120, corner_radius=6, border_color="gray4", fg_color="#333740",
+                                                overwrite_preferred_drawing_method="circle_shapes")
 
+        self.frame.grid(row=0, column=0, sticky="nsew", rowspan=len(options) + 1, columnspan=1, ipadx=0, ipady=0)
+
+        self.frame.grid_rowconfigure(len(options) + 1, minsize=3)
+        self.frame.grid_columnconfigure(0, weight=1)
         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 = customtkinter.CTkButton(self.frame, text=option, height=25, width=108, fg_color="#333740", text_color="gray74",
+                                             hover_color="gray28", corner_radius=4, command=self.button_click)
             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)
+            button.grid(row=index, column=0, padx=(3, 3), pady=(3, 0), columnspan=1, rowspan=1, sticky="ew")
             self.buttons.append(button)
 
-        # master.bind("<Configure>", self.window_drag())
+        self.bind("<FocusOut>", self.focus_loss_event)
+        self.frame.canvas.bind("<Button-1>", self.focus_loss_event)
+
+    def focus_loss_event(self, event):
+        print("focus loss")
+        self.destroy()
+        # self.update()
+
+    def button_click(self):
+        print("button press")
+        self.destroy()
+        # self.update()
 
 
+app = customtkinter.CTk()
+app.geometry("600x500")
 
 
 def open_menu():
-    menu = CTkMenu(root_tk, button.winfo_rootx(), button.winfo_rooty() + button.winfo_height() + 4, ["Option 1", "Option 2", "Point 3"])
+    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 = customtkinter.CTkButton(command=open_menu, height=30, corner_radius=6)
 button.pack(pady=20)
 
-root_tk.mainloop()
+button_2 = customtkinter.CTkButton(command=open_menu, height=30, corner_radius=6)
+button_2.pack(pady=60)
+
+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)
+combobox_tk.pack(pady=10, padx=10)
+
+combobox_1 = customtkinter.CTkComboBox(app, variable=None, 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_scaling/test_scaling_simple_place.py

@@ -6,17 +6,17 @@ customtkinter.ScalingTracker.set_window_scaling(0.5)
 customtkinter.set_appearance_mode("dark")  # Modes: "System" (standard), "Dark", "Light"
 customtkinter.set_default_color_theme("blue")  # Themes: "blue" (standard), "green", "dark-blue"
 
-root_tk = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
-root_tk.geometry("400x600")
-root_tk.title("CustomTkinter manual scaling test")
+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.title("CustomTkinter manual scaling test")
 
-#root_tk.minsize(200, 200)
-#root_tk.maxsize(520, 520)
-#root_tk.resizable(True, False)
+#app.minsize(200, 200)
+#app.maxsize(520, 520)
+#app.resizable(True, False)
 
 
 def button_function():
-    root_tk.geometry(f"{200}x{200}")
+    app.geometry(f"{200}x{200}")
     print("Button click", label_1.text_label.cget("text"))
 
 
@@ -29,7 +29,7 @@ def slider_function(value):
 
 y_padding = 13
 
-frame_1 = customtkinter.CTkFrame(master=root_tk, height=550, width=300)
+frame_1 = customtkinter.CTkFrame(master=app, height=550, width=300)
 frame_1.place(relx=0.5, rely=0.5, anchor=tkinter.CENTER)
 label_1 = customtkinter.CTkLabel(master=frame_1, justify=tkinter.LEFT)
 label_1.place(relx=0.5, y=50, anchor=tkinter.CENTER)
@@ -53,4 +53,4 @@ s_var = tkinter.StringVar(value="on")
 switch_1 = customtkinter.CTkSwitch(master=frame_1)
 switch_1.place(relx=0.5, y=450, anchor=tkinter.CENTER)
 
-root_tk.mainloop()
+app.mainloop()

test/manual_integration_tests/test_scaling/test_scaling_toplevel_pack.py

@@ -6,20 +6,20 @@ customtkinter.ScalingTracker.set_window_scaling(0.5)
 customtkinter.set_appearance_mode("dark")  # Modes: "System" (standard), "Dark", "Light"
 customtkinter.set_default_color_theme("blue")  # Themes: "blue" (standard), "green", "dark-blue"
 
-root_tk = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
-root_tk.geometry("400x480")
-root_tk.title("CustomTkinter manual scaling test")
+app = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
+app.geometry("400x480")
+app.title("CustomTkinter manual scaling test")
 
-top_tk = customtkinter.CTkToplevel(root_tk)
+top_tk = customtkinter.CTkToplevel(app)
 top_tk.geometry("500x500")
 
-#root_tk.minsize(200, 200)
-#root_tk.maxsize(520, 520)
-#root_tk.resizable(True, False)
+#app.minsize(200, 200)
+#app.maxsize(520, 520)
+#app.resizable(True, False)
 
 
 def button_function():
-    root_tk.geometry(f"{200}x{200}")
+    app.geometry(f"{200}x{200}")
     print("Button click", label_1.text_label.cget("text"))
 
 
@@ -32,7 +32,7 @@ def slider_function(value):
 
 y_padding = 13
 
-frame_1 = customtkinter.CTkFrame(master=root_tk)
+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)
@@ -78,4 +78,4 @@ radiobutton_2.pack(pady=y_padding, padx=10)
 switch_1 = customtkinter.CTkSwitch(master=top_tk)
 switch_1.pack(pady=y_padding, padx=10)
 
-root_tk.mainloop()
+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

@@ -0,0 +1,62 @@
+import tkinter
+import customtkinter
+
+
+app = customtkinter.CTk()
+app.geometry("400x900")
+app.title("CustomTkinter Test")
+
+
+def change_state(widget):
+    if widget.state == tkinter.NORMAL:
+        widget.configure(state=tkinter.DISABLED)
+    elif widget.state == tkinter.DISABLED:
+        widget.configure(state=tkinter.NORMAL)
+
+
+def widget_click():
+    print("widget clicked")
+
+
+button_1 = customtkinter.CTkButton(master=app, text="button_1", command=widget_click)
+button_1.pack(padx=20, pady=(20, 10))
+button_2 = customtkinter.CTkButton(master=app, text="Disable/Enable button_1", command=lambda: change_state(button_1))
+button_2.pack(padx=20, pady=(10, 20))
+
+switch_1 = customtkinter.CTkSwitch(master=app, text="switch_1", command=widget_click)
+switch_1.pack(padx=20, pady=(20, 10))
+button_2 = customtkinter.CTkButton(master=app, text="Disable/Enable switch_1", command=lambda: change_state(switch_1))
+button_2.pack(padx=20, pady=(10, 20))
+
+entry_1 = customtkinter.CTkEntry(master=app, placeholder_text="entry_1")
+entry_1.pack(padx=20, pady=(20, 10))
+button_3 = customtkinter.CTkButton(master=app, text="Disable/Enable entry_1", command=lambda: change_state(entry_1))
+button_3.pack(padx=20, pady=(10, 20))
+
+checkbox_1 = customtkinter.CTkCheckBox(master=app, text="checkbox_1")
+checkbox_1.pack(padx=20, pady=(20, 10))
+button_4 = customtkinter.CTkButton(master=app, text="Disable/Enable checkbox_1", command=lambda: change_state(checkbox_1))
+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 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_string_dialog.py

@@ -1,5 +1,4 @@
 import customtkinter
-import tkinter
 
 customtkinter.set_appearance_mode("dark")
 customtkinter.set_default_color_theme("blue")
@@ -22,8 +21,8 @@ def button_click_event():
 
 
 button = customtkinter.CTkButton(app, text="Open Dialog", command=button_click_event)
-button.place(relx=0.5, rely=0.5, anchor=tkinter.CENTER)
+button.place(relx=0.5, rely=0.5, anchor=customtkinter.CENTER)
 c1 = customtkinter.CTkCheckBox(app, text="dark mode", command=change_mode)
-c1.place(relx=0.5, rely=0.8, anchor=tkinter.CENTER)
+c1.place(relx=0.5, rely=0.8, anchor=customtkinter.CENTER)
 
-app.mainloop()
+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_tk_variables.py

@@ -1,74 +0,0 @@
-import tkinter
-import customtkinter  # <- import the CustomTkinter module
-
-TEST_CONFIGURE = True
-TEST_REMOVING = False
-
-root_tk = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
-root_tk.geometry("400x600")
-root_tk.title("Tkinter Variable Test")
-
-txt_var = tkinter.StringVar(value="")
-entry_1 = customtkinter.CTkEntry(root_tk, width=200, textvariable=txt_var)
-entry_1.pack(pady=15)
-txt_var.set("new text wjkfjdshkjfb")
-if TEST_CONFIGURE: entry_1.configure(textvariable=txt_var)
-if TEST_REMOVING: entry_1.configure(textvariable="")
-
-label_1 = customtkinter.CTkLabel(root_tk, width=200, textvariable=txt_var)
-label_1.pack(pady=15)
-if TEST_CONFIGURE: label_1.configure(textvariable=txt_var)
-if TEST_REMOVING: label_1.configure(textvariable="")
-
-button_1 = customtkinter.CTkButton(root_tk, width=200, textvariable=txt_var)
-button_1.pack(pady=15)
-int_var = tkinter.IntVar(value=10)
-if TEST_CONFIGURE: button_1.configure(textvariable=int_var)
-if TEST_REMOVING: button_1.configure(textvariable="")
-
-slider_1 = customtkinter.CTkSlider(root_tk, width=200, from_=0, to=3, variable=int_var)
-slider_1.pack(pady=15)
-if TEST_CONFIGURE: slider_1.configure(variable=int_var)
-if TEST_REMOVING: slider_1.configure(variable="")
-int_var.set(2)
-
-slider_2 = customtkinter.CTkSlider(root_tk, width=200, from_=0, to=3, variable=int_var)
-slider_2.pack(pady=15)
-if TEST_CONFIGURE: slider_2.configure(variable=int_var)
-if TEST_REMOVING: slider_2.configure(variable="")
-
-label_2 = customtkinter.CTkLabel(root_tk, width=200, textvariable=int_var)
-label_2.pack(pady=15)
-
-progress_1 = customtkinter.CTkProgressBar(root_tk, width=200, variable=int_var)
-progress_1.pack(pady=15)
-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(root_tk, text="check 1", variable=check_var, onvalue="on", offvalue="off")
-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())
-
-check_2 = customtkinter.CTkCheckBox(root_tk, text="check 2", variable=check_var, onvalue="on", offvalue="off")
-check_2.pack(pady=15)
-if TEST_CONFIGURE: check_2.configure(variable=check_var)
-if TEST_REMOVING: check_2.configure(variable="")
-
-label_3 = customtkinter.CTkLabel(root_tk, width=200, textvariable=check_var)
-label_3.pack(pady=15)
-label_3.configure(textvariable=check_var)
-
-def switch_event():
-    print("switch event")
-
-s_var = tkinter.StringVar(value="on")
-switch_1 = customtkinter.CTkSwitch(master=root_tk, 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=root_tk, variable=s_var, textvariable=s_var, onvalue="on", offvalue="off")
-switch_1.pack(pady=20, padx=10)
-#switch_1.toggle()
-
-root_tk.mainloop()

test/manual_integration_tests/test_ttk_frames.py

@@ -4,28 +4,28 @@ import customtkinter
 
 customtkinter.set_appearance_mode("light")
 
-root_tk = customtkinter.CTk()
-root_tk.geometry("1400x480")
-root_tk.title("CustomTkinter TTk Compatibility Test")
+app = customtkinter.CTk()
+app.geometry("1400x480")
+app.title("CustomTkinter TTk Compatibility Test")
 
-root_tk.grid_rowconfigure(0, weight=1)
-root_tk.grid_columnconfigure((0, 1, 2, 3, 5, 6), weight=1)
+app.grid_rowconfigure(0, weight=1)
+app.grid_columnconfigure((0, 1, 2, 3, 5, 6), weight=1)
 
 
-button_0 = customtkinter.CTkButton(root_tk)
+button_0 = customtkinter.CTkButton(app)
 button_0.grid(padx=20, pady=20, row=0, column=0)
 
-frame_1 = tkinter.Frame(master=root_tk)
+frame_1 = tkinter.Frame(master=app)
 frame_1.grid(padx=20, pady=20, row=0, column=1, sticky="nsew")
 button_1 = customtkinter.CTkButton(frame_1, text="tkinter.Frame")
 button_1.pack(pady=20, padx=20)
 
-frame_2 = tkinter.LabelFrame(master=root_tk, text="Tkinter LabelFrame")
+frame_2 = tkinter.LabelFrame(master=app, text="Tkinter LabelFrame")
 frame_2.grid(padx=20, pady=20, row=0, column=2, sticky="nsew")
 button_2 = customtkinter.CTkButton(frame_2, text="tkinter.LabelFrame")
 button_2.pack(pady=20, padx=20)
 
-frame_3 = customtkinter.CTkFrame(master=root_tk)
+frame_3 = customtkinter.CTkFrame(master=app)
 frame_3.grid(padx=20, pady=20, row=0, column=3, sticky="nsew")
 label_3 = customtkinter.CTkLabel(master=frame_3, text="CTkFrame Label", fg_color=("gray95", "gray15"))
 label_3.grid(row=0, column=0, columnspan=1, padx=5, pady=5, sticky="ew")
@@ -34,17 +34,17 @@ button_3.grid(row=1, column=0, padx=20)
 frame_3.grid_rowconfigure(1, weight=1)
 frame_3.grid_columnconfigure((0, ), weight=1)
 
-frame_4 = ttk.Frame(master=root_tk)
+frame_4 = ttk.Frame(master=app)
 frame_4.grid(padx=20, pady=20, row=0, column=4, sticky="nsew")
 button_4 = customtkinter.CTkButton(frame_4, text="ttk.Frame")
 button_4.pack(pady=20, padx=20)
 
-frame_5 = ttk.LabelFrame(master=root_tk, text="TTk LabelFrame")
+frame_5 = ttk.LabelFrame(master=app, text="TTk LabelFrame")
 frame_5.grid(padx=20, pady=20, row=0, column=5, sticky="nsew")
 button_5 = customtkinter.CTkButton(frame_5)
 button_5.pack(pady=20, padx=20)
 
-frame_6 = ttk.Notebook(master=root_tk)
+frame_6 = ttk.Notebook(master=app)
 frame_6.grid(padx=20, pady=20, row=0, column=6, sticky="nsew")
 button_6 = customtkinter.CTkButton(frame_6, text="ttk.Notebook")
 button_6.pack(pady=20, padx=20)
@@ -52,4 +52,4 @@ button_6.pack(pady=20, padx=20)
 ttk_style = ttk.Style()
 ttk_style.configure(frame_3.winfo_class(), background='red')
 
-root_tk.mainloop()
+app.mainloop()

test/manual_integration_tests/test_variables.py

@@ -0,0 +1,90 @@
+import tkinter
+import customtkinter
+
+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("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, placeholder_text="placeholder")
+entry_1.pack(pady=15)
+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)
+if TEST_CONFIGURE: label_1.configure(textvariable=txt_var)
+if TEST_REMOVING: label_1.configure(textvariable="")
+
+button_1 = customtkinter.CTkButton(app, width=200, textvariable=txt_var)
+button_1.pack(pady=15)
+int_var = tkinter.IntVar(value=10)
+if TEST_CONFIGURE: button_1.configure(textvariable=int_var)
+if TEST_REMOVING: button_1.configure(textvariable="")
+
+slider_1 = customtkinter.CTkSlider(app, width=200, from_=0, to=3, variable=int_var)
+slider_1.pack(pady=15)
+if TEST_CONFIGURE: slider_1.configure(variable=int_var)
+if TEST_REMOVING: slider_1.configure(variable="")
+int_var.set(2)
+
+slider_2 = customtkinter.CTkSlider(app, width=200, from_=0, to=3, variable=int_var)
+slider_2.pack(pady=15)
+if TEST_CONFIGURE: slider_2.configure(variable=int_var)
+if TEST_REMOVING: slider_2.configure(variable="")
+
+label_2 = customtkinter.CTkLabel(app, width=200, textvariable=int_var)
+label_2.pack(pady=15)
+
+progress_1 = customtkinter.CTkProgressBar(app, width=200, variable=int_var)
+progress_1.pack(pady=15)
+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", 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 created")
+
+check_2 = customtkinter.CTkCheckBox(app, text="check 2", variable=check_var, onvalue="on", offvalue="off")
+check_2.pack(pady=15)
+if TEST_CONFIGURE: check_2.configure(variable=check_var)
+if TEST_REMOVING: check_2.configure(variable="")
+
+label_3 = customtkinter.CTkLabel(app, width=200, textvariable=check_var)
+label_3.pack(pady=15)
+label_3.configure(textvariable=check_var)
+
+def switch_event():
+    print("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_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=optionmenu_var, values=["Option 1", "Option 2", "Option 3"])
+optionmenu_1.pack(pady=20, padx=10)
+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_vertical_widgets.py

@@ -1,25 +1,25 @@
 import customtkinter
 
-root_tk = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
-root_tk.geometry("400x650")
-root_tk.title("test_vertical_widgets")
+app = customtkinter.CTk()  # create CTk window like you do with the Tk window (you can also use normal tkinter.Tk window)
+app.geometry("400x650")
+app.title("test_vertical_widgets")
 
-root_tk.grid_columnconfigure(0, weight=1)
-root_tk.grid_rowconfigure((0, 1, 2, 3), weight=1)
+app.grid_columnconfigure(0, weight=1)
+app.grid_rowconfigure((0, 1, 2, 3), weight=1)
 
-progressbar_1 = customtkinter.CTkProgressBar(root_tk, orient="horizontal")
+progressbar_1 = customtkinter.CTkProgressBar(app, orient="horizontal")
 progressbar_1.grid(row=0, column=0, pady=20, padx=20)
 
-progressbar_2 = customtkinter.CTkProgressBar(root_tk, orient="vertical")
+progressbar_2 = customtkinter.CTkProgressBar(app, orient="vertical")
 progressbar_2.grid(row=1, column=0, pady=20, padx=20)
 
-slider_1 = customtkinter.CTkSlider(root_tk, orient="horizontal", command=progressbar_1.set,
+slider_1 = customtkinter.CTkSlider(app, orient="horizontal", command=progressbar_1.set,
                                    button_corner_radius=3, button_length=20)
 slider_1.grid(row=2, column=0, pady=20, padx=20)
 
-slider_2 = customtkinter.CTkSlider(root_tk, orient="vertical", command=progressbar_2.set,
+slider_2 = customtkinter.CTkSlider(app, orient="vertical", command=progressbar_2.set,
                                    button_corner_radius=3, button_length=20)
 slider_2.grid(row=3, column=0, pady=20, padx=20)
 
 
-root_tk.mainloop()
+app.mainloop()

test/manual_integration_tests/test_widget_states.py

@@ -1,47 +0,0 @@
-import tkinter
-import customtkinter
-
-
-root_tk = customtkinter.CTk()
-root_tk.geometry("400x800")
-root_tk.title("CustomTkinter Test")
-
-
-def change_state(widget):
-    if widget.state == tkinter.NORMAL:
-        widget.configure(state=tkinter.DISABLED)
-    elif widget.state == tkinter.DISABLED:
-        widget.configure(state=tkinter.NORMAL)
-
-
-def widget_click():
-    print("widget clicked")
-
-
-button_1 = customtkinter.CTkButton(master=root_tk, text="button_1", command=widget_click)
-button_1.pack(padx=20, pady=(20, 10))
-button_2 = customtkinter.CTkButton(master=root_tk, text="Disable/Enable button_1", command=lambda: change_state(button_1))
-button_2.pack(padx=20, pady=(10, 20))
-
-switch_1 = customtkinter.CTkSwitch(master=root_tk, text="switch_1", command=widget_click)
-switch_1.pack(padx=20, pady=(20, 10))
-button_2 = customtkinter.CTkButton(master=root_tk, text="Disable/Enable switch_1", command=lambda: change_state(switch_1))
-button_2.pack(padx=20, pady=(10, 20))
-
-entry_1 = customtkinter.CTkEntry(master=root_tk, placeholder_text="entry_1")
-entry_1.pack(padx=20, pady=(20, 10))
-button_3 = customtkinter.CTkButton(master=root_tk, text="Disable/Enable entry_1", command=lambda: change_state(entry_1))
-button_3.pack(padx=20, pady=(10, 20))
-
-checkbox_1 = customtkinter.CTkCheckBox(master=root_tk, text="checkbox_1")
-checkbox_1.pack(padx=20, pady=(20, 10))
-button_4 = customtkinter.CTkButton(master=root_tk, text="Disable/Enable checkbox_1", command=lambda: change_state(checkbox_1))
-button_4.pack(padx=20, pady=(10, 20))
-
-radiobutton_1 = customtkinter.CTkRadioButton(master=root_tk, text="radiobutton_1")
-radiobutton_1.pack(padx=20, pady=(20, 10))
-button_5 = customtkinter.CTkButton(master=root_tk, text="Disable/Enable entry_1", command=lambda: change_state(radiobutton_1))
-button_5.pack(padx=20, pady=(10, 20))
-
-
-root_tk.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()