Bump to 4.6.0

Fix for issue #351

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.6.0] - 2022-06-23
+### Added
+ - CTkProgressBar indeterminate mode, automatic progress loop with .start() and .stop()
+
+## [4.5.0] - 2022-06-23
+### Added
+ - CTkScrollbar (vertical, horizontal)
+
 ## [4.4.0] - 2022-06-14
 ### Changed
  - Changed custom dropdown menu to normal tkinter.Menu because of multiple platform specific bugs

Readme.md

@@ -31,7 +31,9 @@ pip3 install customtkinter
 
 ## Documentation
 
-A detailed documentation can be found in the Wiki Tab here: **[Documentation](https://github.com/TomSchimansky/CustomTkinter/wiki)**.
+The **official** documentation can be found in the Wiki Tab here:
+
+**--> [Documentation](https://github.com/TomSchimansky/CustomTkinter/wiki)**.
 
 ## Example Program
 To test customtkinter you can try this simple example with only a single button:

customtkinter/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.4.1"
+__version__ = "4.6.0"
 
 import os
 import sys
@@ -14,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
@@ -41,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
@@ -53,6 +62,8 @@ from .widgets.ctk_canvas import CTkCanvas
 from .widgets.ctk_switch import CTkSwitch
 from .widgets.ctk_optionmenu import CTkOptionMenu
 from .widgets.ctk_combobox import CTkComboBox
+from .widgets.ctk_scrollbar import CTkScrollbar
+from .widgets.ctk_textbox import CTkTextbox
 
 # import windows
 from .windows.ctk_tk import CTk

customtkinter/appearance_mode_tracker.py

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

customtkinter/assets/themes/blue.json

@@ -11,7 +11,7 @@
     "entry_placeholder_text": ["gray52", "gray62"],
     "frame_border": ["#979DA2", "#1F2122"],
     "frame_low": ["#D1D5D8", "#2A2D2E"],
-    "frame_high": ["#D7D8D9", "#343638"],
+    "frame_high": ["#C0C2C5", "#343638"],
     "label": [null, null],
     "text": ["gray10", "#DCE4EE"],
     "text_disabled": ["gray60", "#777B80"],
@@ -20,7 +20,7 @@
     "progressbar_progress": ["#3B8ED0", "#1F6AA5"],
     "progressbar_border": ["gray", "gray"],
     "slider": ["#939BA2", "#4A4D50"],
-    "slider_progress": ["white", "#AAB0B5"],
+    "slider_progress": ["gray40", "#AAB0B5"],
     "slider_button": ["#3B8ED0", "#1F6AA5"],
     "slider_button_hover": ["#36719F", "#144870"],
     "switch": ["#939BA2", "#4A4D50"],
@@ -33,7 +33,9 @@
     "combobox_button_hover": ["#6E7174", "#7A848D"],
     "dropdown_color": ["gray90", "gray20"],
     "dropdown_hover": ["gray75", "gray28"],
-    "dropdown_text": ["gray10", "#DCE4EE"]
+    "dropdown_text": ["gray10", "#DCE4EE"],
+    "scrollbar_button": ["gray55", "gray41"],
+    "scrollbar_button_hover": ["gray40", "gray53"]
   },
   "text": {
     "macOS": {
@@ -60,7 +62,7 @@
     "entry_border_width": 2,
     "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,
@@ -70,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/dark-blue.json

@@ -33,7 +33,9 @@
     "combobox_button_hover": ["#6E7174", "#7A848D"],
     "dropdown_color": ["gray90", "gray20"],
     "dropdown_hover": ["gray75", "gray28"],
-    "dropdown_text": ["gray10", "#DCE4EE"]
+    "dropdown_text": ["gray10", "#DCE4EE"],
+    "scrollbar_button": ["gray55", "gray41"],
+    "scrollbar_button_hover": ["gray40", "gray53"]
   },
   "text": {
     "macOS": {
@@ -60,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,
@@ -70,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

@@ -33,7 +33,9 @@
     "combobox_button_hover": ["#6E7174", "#7A848D"],
     "dropdown_color": ["gray90", "gray20"],
     "dropdown_hover": ["gray75", "gray28"],
-    "dropdown_text": ["gray10", "#DCE4EE"]
+    "dropdown_text": ["gray10", "#DCE4EE"],
+    "scrollbar_button": ["gray55", "gray41"],
+    "scrollbar_button_hover": ["gray40", "gray53"]
   },
   "text": {
     "macOS": {
@@ -60,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,
@@ -70,6 +72,8 @@
     "switch_border_width": 3,
     "switch_corner_radius": 1000,
     "switch_button_corner_radius": 1000,
-    "switch_button_length": 0
+    "switch_button_length": 0,
+    "scrollbar_corner_radius": 1000,
+    "scrollbar_border_spacing": 4
   }
 }

customtkinter/assets/themes/sweetkind.json

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

@@ -20,6 +20,7 @@ class DrawEngine:
      - 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()
 
@@ -38,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)
 
@@ -397,8 +398,8 @@ class DrawEngine:
             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"))
-                self._canvas.create_rectangle((0, 0, 0, 0), tags=("border_rect_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",
@@ -490,22 +491,27 @@ class DrawEngine:
                 # 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)
+                    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)
+                    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)
+                    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):
@@ -513,7 +519,8 @@ class DrawEngine:
 
                 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)
+                    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")
@@ -554,14 +561,16 @@ class DrawEngine:
             # 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)
+                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)
+                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")
@@ -569,7 +578,8 @@ class DrawEngine:
             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)
+                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):
@@ -577,7 +587,8 @@ class DrawEngine:
 
             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)
+                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")
@@ -634,8 +645,8 @@ class DrawEngine:
         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).
+                                              border_width: Union[float, int], progress_value_1: float, progress_value_2: float, orientation: str) -> bool:
+        """ Draws a rounded bar on the canvas, and onntop sits a progress bar from value 1 to value 2 (range 0-1, left to right, bottom to top).
             The border elements get the 'border_parts' tag", the main elements get the 'inner_parts' tag and
             the progress elements get the 'progress_parts' tag. The 'orientation' argument defines from which direction the progress starts (n, w, s, e).
 
@@ -657,13 +668,13 @@ class DrawEngine:
 
         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)
+                                                                               progress_value_1, progress_value_2, orientation)
         elif self.preferred_drawing_method == "font_shapes":
             return self.__draw_rounded_progress_bar_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
-                                                                            progress_value, orientation)
+                                                                            progress_value_1, progress_value_2, orientation)
 
     def __draw_rounded_progress_bar_with_border_polygon_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
-                                                               progress_value: float, orientation: str) -> bool:
+                                                               progress_value_1: float, progress_value_2: float, orientation: str) -> bool:
 
         requires_recoloring = self.__draw_rounded_rect_with_border_polygon_shapes(width, height, corner_radius, border_width, inner_corner_radius)
 
@@ -680,32 +691,32 @@ class DrawEngine:
 
         if orientation == "w":
             self._canvas.coords("progress_line_1",
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 border_width + inner_corner_radius,
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
                                 border_width + inner_corner_radius,
-                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
-                                border_width + inner_corner_radius,
-                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
                                 height - (border_width + inner_corner_radius) + bottom_right_shift,
-                                border_width + inner_corner_radius,
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 height - (border_width + inner_corner_radius) + bottom_right_shift)
 
         elif orientation == "s":
             self._canvas.coords("progress_line_1",
                                 border_width + inner_corner_radius,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value),
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2),
                                 width - (border_width + inner_corner_radius),
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value),
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2),
                                 width - (border_width + inner_corner_radius),
-                                height - (border_width + inner_corner_radius) + bottom_right_shift,
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1),
                                 border_width + inner_corner_radius,
-                                height - (border_width + inner_corner_radius) + bottom_right_shift)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1))
 
         self._canvas.itemconfig("progress_line_1", width=inner_corner_radius * 2)
 
         return requires_recoloring
 
     def __draw_rounded_progress_bar_with_border_font_shapes(self, width: int, height: int, corner_radius: int, border_width: int, inner_corner_radius: int,
-                                                            progress_value: float, orientation: str) -> bool:
+                                                            progress_value_1: float, progress_value_2: float, orientation: str) -> bool:
 
         requires_recoloring, requires_recoloring_2 = False, False
 
@@ -740,64 +751,72 @@ 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"))
+                                                                                     ())
 
             # set positions of progress corner parts
-            self._canvas.coords("progress_oval_1_a", border_width + inner_corner_radius, border_width + inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_1_b", border_width + inner_corner_radius, border_width + inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_2_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+            self._canvas.coords("progress_oval_1_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 border_width + inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_2_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+            self._canvas.coords("progress_oval_1_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 border_width + inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_3_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+            self._canvas.coords("progress_oval_2_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
+                                border_width + inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("progress_oval_2_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
+                                border_width + inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("progress_oval_3_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
                                 height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_3_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+            self._canvas.coords("progress_oval_3_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
+                                height - border_width - inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("progress_oval_4_a", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
+                                height - border_width - inner_corner_radius, inner_corner_radius)
+            self._canvas.coords("progress_oval_4_b", border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_4_a", border_width + inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_4_b", border_width + inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
 
             # set positions of progress rect parts
             self._canvas.coords("progress_rectangle_1",
-                                border_width + inner_corner_radius,
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_1,
                                 border_width,
-                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value,
+                                border_width + inner_corner_radius + (width - 2 * border_width - 2 * inner_corner_radius) * progress_value_2,
                                 height - border_width)
             self._canvas.coords("progress_rectangle_2",
-                                border_width,
+                                border_width + 2 * inner_corner_radius + (width - 2 * inner_corner_radius - 2 * border_width) * progress_value_1,
                                 border_width + inner_corner_radius,
-                                border_width + 2 * inner_corner_radius + (width - 2 * inner_corner_radius - 2 * border_width) * progress_value,
+                                border_width + 2 * inner_corner_radius + (width - 2 * inner_corner_radius - 2 * border_width) * progress_value_2,
                                 height - inner_corner_radius - border_width)
 
         # vertical orientation from the bottom
         if orientation == "s":
             requires_recoloring_2 = self.__draw_rounded_rect_with_border_font_shapes(width, height, corner_radius, border_width, inner_corner_radius,
-                                                                                     ("inner_oval_3", "inner_oval_4"))
+                                                                                     ())
 
             # set positions of progress corner parts
             self._canvas.coords("progress_oval_1_a", border_width + inner_corner_radius,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value), inner_corner_radius)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2), inner_corner_radius)
             self._canvas.coords("progress_oval_1_b", border_width + inner_corner_radius,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value), inner_corner_radius)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2), inner_corner_radius)
             self._canvas.coords("progress_oval_2_a", width - border_width - inner_corner_radius,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value), inner_corner_radius)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2), inner_corner_radius)
             self._canvas.coords("progress_oval_2_b", width - border_width - inner_corner_radius,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value), inner_corner_radius)
-            self._canvas.coords("progress_oval_3_a", width - border_width - inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_3_b", width - border_width - inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_4_a", border_width + inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
-            self._canvas.coords("progress_oval_4_b", border_width + inner_corner_radius, height - border_width - inner_corner_radius, inner_corner_radius)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2), inner_corner_radius)
+            self._canvas.coords("progress_oval_3_a", width - border_width - inner_corner_radius,
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1), inner_corner_radius)
+            self._canvas.coords("progress_oval_3_b", width - border_width - inner_corner_radius,
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1), inner_corner_radius)
+            self._canvas.coords("progress_oval_4_a", border_width + inner_corner_radius,
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1), inner_corner_radius)
+            self._canvas.coords("progress_oval_4_b", border_width + inner_corner_radius,
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1), inner_corner_radius)
 
             # set positions of progress rect parts
             self._canvas.coords("progress_rectangle_1",
                                 border_width + inner_corner_radius,
-                                border_width + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value),
+                                border_width + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2),
                                 width - border_width - inner_corner_radius,
-                                height - border_width)
+                                border_width + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1))
             self._canvas.coords("progress_rectangle_2",
                                 border_width,
-                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value),
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_2),
                                 width - border_width,
-                                height - inner_corner_radius - border_width)
+                                border_width + inner_corner_radius + (height - 2 * border_width - 2 * inner_corner_radius) * (1 - progress_value_1))
 
         return requires_recoloring or requires_recoloring_2
 
@@ -836,7 +855,7 @@ class DrawEngine:
 
         # 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)
+                                                                                          0, slider_value, orientation)
 
         # create slider button part
         if not self._canvas.find_withtag("slider_parts"):
@@ -875,7 +894,7 @@ class DrawEngine:
 
         # 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)
+                                                                                       0, slider_value, orientation)
 
         # create 4 circles (if not needed, then less)
         if not self._canvas.find_withtag("slider_oval_1_a"):
@@ -959,6 +978,146 @@ class DrawEngine:
 
         return requires_recoloring
 
+    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.

customtkinter/font_manager.py

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

customtkinter/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,60 +10,65 @@ 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=140,
-                 height=28,
-                 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
         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),
@@ -71,22 +76,16 @@ class CTkButton(CTkBaseClass):
         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)
@@ -102,7 +101,7 @@ class CTkButton(CTkBaseClass):
                               height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
-    def set_dimensions(self, width=None, height=None):
+    def set_dimensions(self, width: int = None, height: int = None):
         super().set_dimensions(width, height)
 
         self.canvas.configure(width=self.apply_widget_scaling(self._desired_width),
@@ -140,6 +139,7 @@ class CTkButton(CTkBaseClass):
             if self.text_label is None:
                 self.text_label = tkinter.Label(master=self,
                                                 font=self.apply_font_scaling(self.text_font),
+                                                text=self.text,
                                                 textvariable=self.textvariable)
 
                 self.text_label.bind("<Enter>", self.on_enter)
@@ -161,8 +161,6 @@ class CTkButton(CTkBaseClass):
                 else:
                     self.text_label.configure(bg=ThemeManager.single_color(self.fg_color, self._appearance_mode))
 
-            self.text_label.configure(text=self.text)  # set text
-
         else:
             # delete text_label if no text given
             if self.text_label is not None:
@@ -237,102 +235,91 @@ class CTkButton(CTkBaseClass):
                                      padx=max(self.apply_widget_scaling(self.corner_radius), self.apply_widget_scaling(self.border_width)),
                                      pady=(self.apply_widget_scaling(self.border_width), 2))
 
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
-
+    def configure(self, require_redraw=False, **kwargs):
         if "text" in kwargs:
-            self.set_text(kwargs["text"])
-            del kwargs["text"]
+            self.text = kwargs.pop("text")
+            if self.text_label is None:
+                require_redraw = True  # text_label will be created in .draw()
+            else:
+                self.text_label.configure(text=self.text)
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            if self.text_label is not None:
+                self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
         if "state" in kwargs:
-            self.state = kwargs["state"]
+            self.state = kwargs.pop("state")
             self.set_cursor()
             require_redraw = True
-            del kwargs["state"]
 
         if "image" in kwargs:
-            self.set_image(kwargs["image"])
-            del kwargs["image"]
+            self.image = kwargs.pop("image")
+            require_redraw = True
+
+        if "corner_radius" in kwargs:
+            self.corner_radius = kwargs.pop("corner_radius")
+            require_redraw = True
 
         if "compound" in kwargs:
-            self.compound = kwargs["compound"]
+            self.compound = kwargs.pop("compound")
             require_redraw = True
-            del kwargs["compound"]
 
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
-            del kwargs["fg_color"]
 
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
-            del kwargs["border_color"]
-
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
 
         if "hover_color" in kwargs:
-            self.hover_color = kwargs["hover_color"]
+            self.hover_color = kwargs.pop("hover_color")
             require_redraw = True
-            del kwargs["hover_color"]
 
         if "text_color" in kwargs:
-            self.text_color = kwargs["text_color"]
+            self.text_color = kwargs.pop("text_color")
             require_redraw = True
-            del kwargs["text_color"]
 
         if "command" in kwargs:
-            self.function = kwargs["command"]
-            del kwargs["command"]
+            self.command = kwargs.pop("command")
 
         if "textvariable" in kwargs:
-            self.textvariable = kwargs["textvariable"]
+            self.textvariable = kwargs.pop("textvariable")
             if self.text_label is not None:
                 self.text_label.configure(textvariable=self.textvariable)
-            del kwargs["textvariable"]
 
         if "width" in kwargs:
-            self.set_dimensions(width=kwargs["width"])
-            del kwargs["width"]
+            self.set_dimensions(width=kwargs.pop("width"))
 
         if "height" in kwargs:
-            self.set_dimensions(height=kwargs["height"])
-            del kwargs["height"]
+            self.set_dimensions(height=kwargs.pop("height"))
 
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)
 
     def set_cursor(self):
         if Settings.cursor_manipulation_enabled:
             if self.state == tkinter.DISABLED:
-                if sys.platform == "darwin" and self.function is not None and Settings.cursor_manipulation_enabled:
+                if sys.platform == "darwin" and self.command is not None and Settings.cursor_manipulation_enabled:
                     self.configure(cursor="arrow")
-                elif sys.platform.startswith("win") and self.function is not None and Settings.cursor_manipulation_enabled:
+                elif sys.platform.startswith("win") and self.command is not None and Settings.cursor_manipulation_enabled:
                     self.configure(cursor="arrow")
 
             elif self.state == tkinter.NORMAL:
-                if sys.platform == "darwin" and self.function is not None and Settings.cursor_manipulation_enabled:
+                if sys.platform == "darwin" and self.command is not None and Settings.cursor_manipulation_enabled:
                     self.configure(cursor="pointinghand")
-                elif sys.platform.startswith("win") and self.function is not None and Settings.cursor_manipulation_enabled:
+                elif sys.platform.startswith("win") and self.command is not None and Settings.cursor_manipulation_enabled:
                     self.configure(cursor="hand2")
 
-    def set_text(self, text):
-        self.text = text
-        self.draw()
-
     def set_image(self, image):
-        self.image = image
-        self.draw()
+        """ will be removed in next major """
+        self.configure(image=image)
 
-    def on_enter(self, event=0):
+    def set_text(self, text):
+        """ will be removed in next major """
+        self.configure(text=text)
+
+    def on_enter(self, event=None):
         if self.hover is True and self.state == tkinter.NORMAL:
             if self.hover_color is None:
                 inner_parts_color = self.fg_color
@@ -352,7 +339,7 @@ class CTkButton(CTkBaseClass):
             if self.image_label is not None:
                 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:
@@ -378,13 +365,13 @@ class CTkButton(CTkBaseClass):
         if self.click_animation_running:
             self.on_enter()
 
-    def clicked(self, event=0):
-        if self.function is not None:
-            if self.state is not tkinter.DISABLED:
+    def clicked(self, event=None):
+        if self.command is not None:
+            if self.state != tkinter.DISABLED:
 
                 # click animation: change color with .on_leave() and back to normal after 100ms with click_animation()
                 self.on_leave()
                 self.click_animation_running = True
                 self.after(100, self.click_animation)
 
-                self.function()
+                self.command()

customtkinter/widgets/ctk_canvas.py

@@ -8,7 +8,6 @@ class CTkCanvas(tkinter.Canvas):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-
         self.aa_circle_canvas_ids = set()
 
     @classmethod
@@ -21,7 +20,7 @@ class CTkCanvas(tkinter.Canvas):
 
         radius_to_char_fine_windows_10 = {19: 'A', 18: 'A', 17: 'B', 16: 'B', 15: 'B', 14: 'B', 13: 'C', 12: 'C',
                                           11: 'C', 10: 'C',
-                                          9: 'D', 8: 'D', 7: 'D', 6: 'F', 5: 'D', 4: 'G', 3: 'G', 2: 'H', 1: 'H',
+                                          9: 'D', 8: 'D', 7: 'D', 6: 'C', 5: 'D', 4: 'G', 3: 'G', 2: 'H', 1: 'H',
                                           0: 'A'}
 
         radius_to_char_fine_windows_11 = {19: 'A', 18: 'A', 17: 'B', 16: 'B', 15: 'B', 14: 'B', 13: 'C', 12: 'C',

customtkinter/widgets/ctk_checkbox.py

@@ -56,15 +56,16 @@ class CTkCheckBox(CTkBaseClass):
         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)
@@ -90,13 +91,23 @@ class CTkCheckBox(CTkBaseClass):
         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.draw()  # initial draw
         self.set_cursor()
@@ -107,6 +118,7 @@ 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.canvas.delete("checkmark")
         self.bg_canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
         self.canvas.configure(width=self.apply_widget_scaling(self._desired_width), height=self.apply_widget_scaling(self._desired_height))
         self.draw()
@@ -153,93 +165,63 @@ class CTkCheckBox(CTkBaseClass):
                                    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"
-
-            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.state == tkinter.DISABLED:
             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.set_text(self.text)
-
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw()
-
+    def configure(self, require_redraw=False, **kwargs):
         if "text" in kwargs:
-            self.set_text(kwargs["text"])
-            del kwargs["text"]
+            self.text = kwargs.pop("text")
+            self.text_label.configure(text=self.text)
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            if self.text_label is not None:
+                self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
         if "state" in kwargs:
-            self.state = kwargs["state"]
+            self.state = kwargs.pop("state")
             self.set_cursor()
             require_redraw = True
-            del kwargs["state"]
 
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
-            del kwargs["fg_color"]
-
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
 
         if "hover_color" in kwargs:
-            self.hover_color = kwargs["hover_color"]
+            self.hover_color = kwargs.pop("hover_color")
             require_redraw = True
-            del kwargs["hover_color"]
 
         if "text_color" in kwargs:
-            self.text_color = kwargs["text_color"]
+            self.text_color = kwargs.pop("text_color")
             require_redraw = True
-            del kwargs["text_color"]
 
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
-            del kwargs["border_color"]
 
         if "command" in kwargs:
-            self.function = kwargs["command"]
-            del kwargs["command"]
+            self.command = kwargs.pop("command")
+
+        if "textvariable" in kwargs:
+            self.textvariable = kwargs.pop("textvariable")
+            self.text_label.configure(textvariable=self.textvariable)
 
         if "variable" in kwargs:
-            if self.variable is not None:
-                self.variable.trace_remove("write", self.variable_callback_name)
+            if self.variable is not None and self.variable != "":
+                self.variable.trace_remove("write", self.variable_callback_name)  # remove old variable callback
 
-            self.variable = kwargs["variable"]
+            self.variable = kwargs.pop("variable")
 
             if self.variable is not None and self.variable != "":
                 self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
-                if self.variable.get() == self.onvalue:
-                    self.select(from_variable_callback=True)
-                elif self.variable.get() == self.offvalue:
-                    self.deselect(from_variable_callback=True)
-            else:
-                self.variable = None
+                self.check_state = True if self.variable.get() == self.onvalue else False
+                require_redraw = True
 
-            del kwargs["variable"]
-
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)
 
     def set_cursor(self):
         if Settings.cursor_manipulation_enabled:
@@ -263,13 +245,6 @@ class CTkCheckBox(CTkBaseClass):
                     if self.text_label is not None:
                         self.text_label.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.")
-
     def on_enter(self, event=0):
         if self.hover is True and self.state == tkinter.NORMAL:
             if self.check_state is True:
@@ -317,14 +292,14 @@ class CTkCheckBox(CTkBaseClass):
                 self.check_state = True
                 self.draw()
 
-            if self.function is not None:
-                self.function()
-
             if self.variable is not None:
                 self.variable_callback_blocked = True
                 self.variable.set(self.onvalue if self.check_state is True else self.offvalue)
                 self.variable_callback_blocked = False
 
+            if self.command is not None:
+                self.command()
+
     def select(self, from_variable_callback=False):
         self.check_state = True
         self.draw()
@@ -334,8 +309,8 @@ class CTkCheckBox(CTkBaseClass):
             self.variable.set(self.onvalue)
             self.variable_callback_blocked = False
 
-        if self.function is not None:
-            self.function()
+        if self.command is not None:
+            self.command()
 
     def deselect(self, from_variable_callback=False):
         self.check_state = False
@@ -346,11 +321,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

@@ -1,9 +1,7 @@
 import tkinter
 import sys
-from typing import Union
 
 from .dropdown_menu import DropdownMenu
-
 from .ctk_canvas import CTkCanvas
 from ..theme_manager import ThemeManager
 from ..settings import Settings
@@ -55,8 +53,8 @@ class CTkComboBox(CTkBaseClass):
         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.variable = variable
+        self.command = command
+        self.textvariable = variable
         self.state = state
         self.hover = hover
 
@@ -65,14 +63,9 @@ class CTkComboBox(CTkBaseClass):
         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,
+                                          command=self.dropdown_callback,
                                           fg_color=dropdown_color,
                                           hover_color=dropdown_hover_color,
                                           text_color=dropdown_text_color,
@@ -100,6 +93,12 @@ class CTkComboBox(CTkBaseClass):
                         padx=(max(self.apply_widget_scaling(self.corner_radius), self.apply_widget_scaling(3)),
                               max(self.apply_widget_scaling(self._current_width - left_section_width + 3), self.apply_widget_scaling(3))))
 
+        # insert default value
+        if len(self.values) > 0:
+            self.entry.insert(0, self.values[0])
+        else:
+            self.entry.insert(0, "CTkComboBox")
+
         self.draw()  # initial draw
 
         # event bindings
@@ -111,12 +110,19 @@ class CTkComboBox(CTkBaseClass):
         self.canvas.tag_bind("dropdown_arrow", "<Button-1>", self.clicked)
         self.bind('<Configure>', self.update_dimensions_event)
 
-        if self.variable is not None:
-            self.entry.configure(textvariable=self.variable)
+        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()
@@ -140,10 +146,6 @@ class CTkComboBox(CTkBaseClass):
                                                                      self.apply_widget_scaling(self._current_height / 2),
                                                                      self.apply_widget_scaling(self._current_height / 3))
 
-        if self.current_value is not None:
-            self.entry.delete(0, tkinter.END)
-            self.entry.insert(0, self.current_value)
-
         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))
@@ -177,85 +179,62 @@ class CTkComboBox(CTkBaseClass):
         self.dropdown_menu.open(self.winfo_rootx(),
                                 self.winfo_rooty() + self.apply_widget_scaling(self._current_height + 0))
 
-    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)
             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 "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 "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 "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.entry.configure(font=self.apply_font_scaling(self.text_font))
 
         if "command" in kwargs:
-            self.function = kwargs["command"]
-            del kwargs["command"]
+            self.command = kwargs.pop("command")
 
         if "variable" in kwargs:
-            self.variable = kwargs["variable"]
-            self.entry.configure(textvariable=self.variable)
-            del kwargs["variable"]
+            self.textvariable = kwargs.pop("variable")
+            self.entry.configure(textvariable=self.textvariable)
 
         if "width" in kwargs:
-            self.set_dimensions(width=kwargs["width"])
-            del kwargs["width"]
+            self.set_dimensions(width=kwargs.pop("width"))
 
         if "height" in kwargs:
-            self.set_dimensions(height=kwargs["height"])
-            del kwargs["height"]
+            self.set_dimensions(height=kwargs.pop("height"))
 
         if "values" in kwargs:
-            self.values = kwargs["values"]
-            del kwargs["values"]
+            self.values = kwargs.pop("values")
             self.dropdown_menu.configure(values=self.values)
 
         if "dropdown_color" in kwargs:
-            self.dropdown_menu.configure(fg_color=kwargs["dropdown_color"])
-            del kwargs["dropdown_color"]
+            self.dropdown_menu.configure(fg_color=kwargs.pop("dropdown_color"))
 
         if "dropdown_hover_color" in kwargs:
-            self.dropdown_menu.configure(hover_color=kwargs["dropdown_hover_color"])
-            del kwargs["dropdown_hover_color"]
+            self.dropdown_menu.configure(hover_color=kwargs.pop("dropdown_hover_color"))
 
         if "dropdown_text_color" in kwargs:
-            self.dropdown_menu.configure(text_color=kwargs["dropdown_text_color"])
-            del kwargs["dropdown_text_color"]
+            self.dropdown_menu.configure(text_color=kwargs.pop("dropdown_text_color"))
 
         if "dropdown_text_font" in kwargs:
-            self.dropdown_menu.configure(text_font=kwargs["dropdown_text_font"])
-            del kwargs["dropdown_text_font"]
+            self.dropdown_menu.configure(text_font=kwargs.pop("dropdown_text_font"))
 
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        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:
@@ -287,15 +266,28 @@ class CTkComboBox(CTkBaseClass):
                                    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
+    def dropdown_callback(self, value: str):
+        if self.state == "readonly":
+            self.entry.configure(state="normal")
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, value)
+            self.entry.configure(state="readonly")
+        else:
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, value)
 
-        self.entry.delete(0, tkinter.END)
-        self.entry.insert(0, self.current_value)
+        if self.command is not None:
+            self.command(value)
 
-        if not from_variable_callback:
-            if self.function is not None:
-                self.function(self.current_value)
+    def set(self, value: str):
+        if self.state == "readonly":
+            self.entry.configure(state="normal")
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, value)
+            self.entry.configure(state="readonly")
+        else:
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, value)
 
     def get(self) -> str:
         return self.entry.get()

customtkinter/widgets/ctk_entry.py

@@ -20,32 +20,39 @@ class CTkEntry(CTkBaseClass):
                  width=140,
                  height=28,
                  state=tkinter.NORMAL,
+                 textvariable: tkinter.Variable = None,
                  **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["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,
@@ -60,17 +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="nswe",
                         padx=self.apply_widget_scaling(self.corner_radius) if self.corner_radius >= 6 else self.apply_widget_scaling(6),
                         pady=(self.apply_widget_scaling(self.border_width), self.apply_widget_scaling(self.border_width + 1)))
 
         super().bind('<Configure>', self.update_dimensions_event)
-        self.entry.bind('<FocusOut>', self.set_placeholder)
-        self.entry.bind('<FocusIn>', self.clear_placeholder)
+        self.entry.bind('<FocusOut>', self.entry_focus_out)
+        self.entry.bind('<FocusIn>', self.entry_focus_in)
 
+        self.activate_placeholder()
         self.draw()
-        self.set_placeholder()
 
     def set_scaling(self, *args, **kwargs):
         super().set_scaling( *args, **kwargs)
@@ -89,23 +97,6 @@ class CTkEntry(CTkBaseClass):
                               height=self.apply_widget_scaling(self._desired_height))
         self.draw()
 
-    def set_placeholder(self, event=None):
-        if self.placeholder_text is not None:
-            if not self.placeholder_text_active and self.entry.get() == "":
-                self.placeholder_text_active = True
-                self.pre_placeholder_arguments = {"show": self.entry.cget("show")}
-                self.entry.config(fg=ThemeManager.single_color(self.placeholder_text_color, self._appearance_mode), show="")
-                self.entry.delete(0, tkinter.END)
-                self.entry.insert(0, self.placeholder_text)
-
-    def clear_placeholder(self, event=None):
-        if self.placeholder_text_active:
-            self.placeholder_text_active = False
-            self.entry.config(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
-            self.entry.delete(0, tkinter.END)
-            for argument, value in self.pre_placeholder_arguments.items():
-                self.entry[argument] = value
-
     def draw(self, no_color_updates=False):
         self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
@@ -146,39 +137,25 @@ class CTkEntry(CTkBaseClass):
     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
@@ -186,31 +163,80 @@ class CTkEntry(CTkBaseClass):
                 self.corner_radius = self._current_width / 2
 
             self.entry.grid(column=0, row=0, sticky="we", padx=self.apply_widget_scaling(self.corner_radius) if self.corner_radius >= 6 else self.apply_widget_scaling(6))
-            del kwargs["corner_radius"]
             require_redraw = True
 
         if "width" in kwargs:
-            self.set_dimensions(width=kwargs["width"])
-            del kwargs["width"]
+            self.set_dimensions(width=kwargs.pop("width"))
 
         if "height" in kwargs:
-            self.set_dimensions(height=kwargs["height"])
-            del kwargs["height"]
+            self.set_dimensions(height=kwargs.pop("height"))
 
         if "placeholder_text" in kwargs:
-            pass
+            self.placeholder_text = kwargs.pop("placeholder_text")
+            if self.placeholder_text_active:
+                self.entry.delete(0, tkinter.END)
+                self.entry.insert(0, self.placeholder_text)
+            else:
+                self.activate_placeholder()
 
-        self.entry.configure(*args, **kwargs)
+        if "placeholder_text_color" in kwargs:
+            self.placeholder_text_color = kwargs.pop("placeholder_text_color")
+            require_redraw = True
 
-        if require_redraw is True:
-            self.draw()
+        if "textvariable" in kwargs:
+            self.textvariable = kwargs.pop("textvariable")
+            self.entry.configure(textvariable=self.textvariable)
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.entry.configure(font=self.apply_font_scaling(self.text_font))
+
+        if "show" in kwargs:
+            if self.placeholder_text_active:
+                self.pre_placeholder_arguments["show"] = kwargs.pop("show")
+            else:
+                self.entry.configure(show=kwargs.pop("show"))
+
+        if "bg_color" in kwargs:
+            super().configure(bg_color=kwargs.pop("bg_color"), require_redraw=require_redraw)
+        else:
+            super().configure(require_redraw=require_redraw)
+
+        self.entry.configure(**kwargs)  # pass remaining kwargs to entry
+
+    def activate_placeholder(self):
+        if self.entry.get() == "" and self.placeholder_text is not None and (self.textvariable is None or self.textvariable == ""):
+            self.placeholder_text_active = True
+
+            self.pre_placeholder_arguments = {"show": self.entry.cget("show")}
+            self.entry.config(fg=ThemeManager.single_color(self.placeholder_text_color, self._appearance_mode), show="")
+            self.entry.delete(0, tkinter.END)
+            self.entry.insert(0, self.placeholder_text)
+
+    def deactivate_placeholder(self):
+        if self.placeholder_text_active:
+            self.placeholder_text_active = False
+
+            self.entry.config(fg=ThemeManager.single_color(self.text_color, self._appearance_mode))
+            self.entry.delete(0, tkinter.END)
+            for argument, value in self.pre_placeholder_arguments.items():
+                self.entry[argument] = value
+
+    def entry_focus_out(self, event=None):
+        self.activate_placeholder()
+
+    def entry_focus_in(self, event=None):
+        self.deactivate_placeholder()
 
     def delete(self, *args, **kwargs):
         self.entry.delete(*args, **kwargs)
-        self.set_placeholder()
+
+        if self.entry.get() == "":
+            self.activate_placeholder()
 
     def insert(self, *args, **kwargs):
-        self.clear_placeholder()
+        self.deactivate_placeholder()
+
         return self.entry.insert(*args, **kwargs)
 
     def get(self):
@@ -218,3 +244,9 @@ class CTkEntry(CTkBaseClass):
             return ""
         else:
             return self.entry.get()
+
+    def focus(self):
+        self.entry.focus()
+
+    def focus_force(self):
+        self.entry.focus_force()

customtkinter/widgets/ctk_frame.py

@@ -101,52 +101,32 @@ class CTkFrame(CTkBaseClass):
         self.canvas.tag_lower("inner_parts")
         self.canvas.tag_lower("border_parts")
 
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
-
+    def configure(self, require_redraw=False, **kwargs):
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
-            del kwargs["fg_color"]
 
             # check if CTk widgets are children of the frame and change their bg_color to new frame fg_color
             for child in self.winfo_children():
                 if isinstance(child, CTkBaseClass):
                     child.configure(bg_color=self.fg_color)
 
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-
-            del kwargs["bg_color"]
-
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
-            del kwargs["border_color"]
 
         if "corner_radius" in kwargs:
-            self.corner_radius = kwargs["corner_radius"]
+            self.corner_radius = kwargs.pop("corner_radius")
             require_redraw = True
-            del kwargs["corner_radius"]
 
         if "border_width" in kwargs:
-            self.border_width = kwargs["border_width"]
+            self.border_width = kwargs.pop("border_width")
             require_redraw = True
-            del kwargs["border_width"]
 
         if "width" in kwargs:
-            self.set_dimensions(width=kwargs["width"])
-            del kwargs["width"]
+            self.set_dimensions(width=kwargs.pop("width"))
 
         if "height" in kwargs:
-            self.set_dimensions(height=kwargs["height"])
-            del kwargs["height"]
+            self.set_dimensions(height=kwargs.pop("height"))
 
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)

customtkinter/widgets/ctk_label.py

@@ -1,3 +1,4 @@
+import sys
 import tkinter
 
 from .ctk_canvas import CTkCanvas
@@ -16,12 +17,12 @@ class CTkLabel(CTkBaseClass):
                  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
         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
 
@@ -52,10 +54,13 @@ class CTkLabel(CTkBaseClass):
         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()
@@ -65,7 +70,9 @@ class CTkLabel(CTkBaseClass):
 
         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()
 
@@ -100,26 +107,31 @@ class CTkLabel(CTkBaseClass):
 
             self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
 
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
+    def config(self, **kwargs):
+        sys.stderr.write("Warning: Use .configure() instead of .config()")
+        self.configure(**kwargs)
+
+    def configure(self, require_redraw=False, **kwargs):
+        if "anchor" in kwargs:
+            self.anchor = kwargs.pop("anchor")
+            text_label_grid_sticky = self.anchor if self.anchor != "center" else ""
+            self.text_label.grid(row=0, column=0, padx=self.apply_widget_scaling(self.corner_radius),
+                                 sticky=text_label_grid_sticky)
 
         if "text" in kwargs:
-            self.set_text(kwargs["text"])
+            self.text = kwargs["text"]
+            self.text_label.configure(text=self.text)
             del kwargs["text"]
 
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.text_label.configure(font=self.apply_font_scaling(self.text_font))
+
         if "fg_color" in kwargs:
             self.fg_color = kwargs["fg_color"]
             require_redraw = True
             del kwargs["fg_color"]
 
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
-
         if "text_color" in kwargs:
             self.text_color = kwargs["text_color"]
             require_redraw = True
@@ -133,11 +145,15 @@ class CTkLabel(CTkBaseClass):
             self.set_dimensions(height=kwargs["height"])
             del kwargs["height"]
 
-        self.text_label.configure(*args, **kwargs)
+        if "bg_color" in kwargs:
+            super().configure(bg_color=kwargs.pop("bg_color"), require_redraw=require_redraw)
+        else:
+            super().configure(require_redraw=require_redraw)
 
-        if require_redraw:
-            self.draw()
+        self.text_label.configure(**kwargs)  # pass remaining kwargs to label
 
     def set_text(self, text):
+        """ Will be removed in the next major release """
+
         self.text = text
-        self.text_label.configure(text=self.text, width=len(self.text))
+        self.text_label.configure(text=self.text)

customtkinter/widgets/ctk_optionmenu.py

@@ -1,6 +1,5 @@
 import tkinter
 import sys
-from typing import Union
 
 from .dropdown_menu import DropdownMenu
 
@@ -32,6 +31,7 @@ class CTkOptionMenu(CTkBaseClass):
                  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
@@ -52,12 +52,13 @@ class CTkOptionMenu(CTkBaseClass):
         self.dropdown_text_font = dropdown_text_font
 
         # callback and hover functionality
-        self.function = command
+        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"]
@@ -71,7 +72,7 @@ class CTkOptionMenu(CTkBaseClass):
 
         self.dropdown_menu = DropdownMenu(master=self,
                                           values=self.values,
-                                          command=self.set,
+                                          command=self.dropdown_callback,
                                           fg_color=dropdown_color,
                                           hover_color=dropdown_hover_color,
                                           text_color=dropdown_text_color,
@@ -89,11 +90,17 @@ class CTkOptionMenu(CTkBaseClass):
         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))
+        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")
@@ -117,14 +124,18 @@ class CTkOptionMenu(CTkBaseClass):
 
         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)
+            self.current_value = self.variable.get()
+            self.text_label.configure(text=self.current_value)
 
     def set_scaling(self, *args, **kwargs):
         super().set_scaling(*args, **kwargs)
 
-        if self.text_label is not None:
-            self.text_label.destroy()
-            self.text_label = None
+        # 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))
@@ -149,9 +160,6 @@ class CTkOptionMenu(CTkBaseClass):
                                                                      self.apply_widget_scaling(self._current_height / 2),
                                                                      self.apply_widget_scaling(self._current_height / 3))
 
-        if self.current_value is not None:
-            self.text_label.configure(text=self.current_value)
-
         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))
@@ -176,97 +184,83 @@ class CTkOptionMenu(CTkBaseClass):
 
             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, *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")
             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 "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 "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 "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
         if "command" in kwargs:
-            self.function = kwargs["command"]
-            del kwargs["command"]
+            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["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)
-                self.set(self.variable.get(), from_variable_callback=True)
+                self.set(self.variable.get(), block_set_variable=True)
             else:
                 self.variable = None
 
-            del kwargs["variable"]
-
         if "width" in kwargs:
-            self.set_dimensions(width=kwargs["width"])
-            del kwargs["width"]
+            self.set_dimensions(width=kwargs.pop("width"))
 
         if "height" in kwargs:
-            self.set_dimensions(height=kwargs["height"])
-            del kwargs["height"]
+            self.set_dimensions(height=kwargs.pop("height"))
 
         if "values" in kwargs:
-            self.values = kwargs["values"]
-            del kwargs["values"]
+            self.values = kwargs.pop("values")
             self.dropdown_menu.configure(values=self.values)
 
         if "dropdown_color" in kwargs:
-            self.dropdown_menu.configure(fg_color=kwargs["dropdown_color"])
-            del kwargs["dropdown_color"]
+            self.dropdown_menu.configure(fg_color=kwargs.pop("dropdown_color"))
 
         if "dropdown_hover_color" in kwargs:
-            self.dropdown_menu.configure(hover_color=kwargs["dropdown_hover_color"])
-            del kwargs["dropdown_hover_color"]
+            self.dropdown_menu.configure(hover_color=kwargs.pop("dropdown_hover_color"))
 
         if "dropdown_text_color" in kwargs:
-            self.dropdown_menu.configure(text_color=kwargs["dropdown_text_color"])
-            del kwargs["dropdown_text_color"]
+            self.dropdown_menu.configure(text_color=kwargs.pop("dropdown_text_color"))
 
         if "dropdown_text_font" in kwargs:
-            self.dropdown_menu.configure(text_font=kwargs["dropdown_text_font"])
-            del kwargs["dropdown_text_font"]
+            self.dropdown_text_font = kwargs.pop("dropdown_text_font")
+            self.dropdown_menu.configure(text_font=self.dropdown_text_font)
 
-        super().configure(*args, **kwargs)
+        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)
 
-        if require_redraw:
-            self.draw()
+        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:
@@ -284,24 +278,29 @@ class CTkOptionMenu(CTkBaseClass):
 
     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
-
-        if self.text_label is not None:
+            self.current_value = self.variable.get()
             self.text_label.configure(text=self.current_value)
-        else:
-            self.draw()
 
-        if self.variable is not None and not from_variable_callback:
+    def dropdown_callback(self, value: str):
+        self.current_value = value
+        self.text_label.configure(text=self.current_value)
+
+        if self.variable is not None:
             self.variable_callback_blocked = True
             self.variable.set(self.current_value)
             self.variable_callback_blocked = False
 
-        if not from_variable_callback:
-            if self.function is not None:
-                self.function(self.current_value)
+        if self.command is not None:
+            self.command(self.current_value)
+
+    def set(self, value: str):
+        self.current_value = value
+        self.text_label.configure(text=self.current_value)
+
+        if self.variable is not None:
+            self.variable_callback_blocked = True
+            self.variable.set(self.current_value)
+            self.variable_callback_blocked = False
 
     def get(self) -> str:
         return self.current_value

customtkinter/widgets/ctk_progressbar.py

@@ -1,4 +1,5 @@
 import tkinter
+import math
 
 from .ctk_canvas import CTkCanvas
 from ..theme_manager import ThemeManager
@@ -20,6 +21,9 @@ class CTkProgressBar(CTkBaseClass):
                  height=None,
                  border_width="default_theme",
                  orient="horizontal",
+                 mode="determinate",
+                 determinate_speed=1,
+                 indeterminate_speed=1,
                  **kwargs):
 
         # set default dimensions according to orientation
@@ -50,8 +54,14 @@ class CTkProgressBar(CTkBaseClass):
         # shape
         self.corner_radius = ThemeManager.theme["shape"]["progressbar_corner_radius"] if corner_radius == "default_theme" else corner_radius
         self.border_width = ThemeManager.theme["shape"]["progressbar_border_width"] if border_width == "default_theme" else border_width
-        self.value = 0.5
+        self.determinate_value = 0.5  # range 0-1
+        self.determinate_speed = determinate_speed  # range 0-1
+        self.indeterminate_value = 0  # range 0-inf
+        self.indeterminate_width = 0.4  # range 0-1
+        self.indeterminate_speed = indeterminate_speed  # range 0-1 to travel in 50ms
+        self.loop_running = False
         self.orient = orient
+        self.mode = mode  # "determinate" or "indeterminate"
 
         self.grid_rowconfigure(0, weight=1)
         self.grid_columnconfigure(0, weight=1)
@@ -101,12 +111,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),
-                                                                                     self.apply_widget_scaling(self.corner_radius),
-                                                                                     self.apply_widget_scaling(self.border_width),
-                                                                                     self.value,
-                                                                                     orientation)
+        if self.mode == "determinate":
+            requires_recoloring = self.draw_engine.draw_rounded_progress_bar_with_border(self.apply_widget_scaling(self._current_width),
+                                                                                         self.apply_widget_scaling(self._current_height),
+                                                                                         self.apply_widget_scaling(self.corner_radius),
+                                                                                         self.apply_widget_scaling(self.border_width),
+                                                                                         0,
+                                                                                         self.determinate_value,
+                                                                                         orientation)
+        else:  # indeterminate mode
+            progress_value = (math.sin(self.indeterminate_value * math.pi / 40) + 1) / 2
+            progress_value_1 = min(1.0, progress_value + (self.indeterminate_width / 2))
+            progress_value_2 = max(0.0, progress_value - (self.indeterminate_width / 2))
+
+            requires_recoloring = self.draw_engine.draw_rounded_progress_bar_with_border(self.apply_widget_scaling(self._current_width),
+                                                                                         self.apply_widget_scaling(self._current_height),
+                                                                                         self.apply_widget_scaling(self.corner_radius),
+                                                                                         self.apply_widget_scaling(self.border_width),
+                                                                                         progress_value_1,
+                                                                                         progress_value_2,
+                                                                                         orientation)
 
         if no_color_updates is False or requires_recoloring:
             self.canvas.configure(bg=ThemeManager.single_color(self.bg_color, self._appearance_mode))
@@ -120,17 +144,7 @@ class CTkProgressBar(CTkBaseClass):
                                    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"]
-
+    def configure(self, require_redraw=False, **kwargs):
         if "fg_color" in kwargs:
             self.fg_color = kwargs["fg_color"]
             del kwargs["fg_color"]
@@ -165,6 +179,16 @@ class CTkProgressBar(CTkBaseClass):
 
             del kwargs["variable"]
 
+        if "mode" in kwargs:
+            self.mode = kwargs.pop("mode")
+            require_redraw = True
+
+        if "determinate_speed" in kwargs:
+            self.determinate_speed = kwargs.pop("determinate_speed")
+
+        if "indeterminate_speed" in kwargs:
+            self.indeterminate_speed = kwargs.pop("indeterminate_speed")
+
         if "width" in kwargs:
             self.set_dimensions(width=kwargs["width"])
             del kwargs["width"]
@@ -173,26 +197,61 @@ class CTkProgressBar(CTkBaseClass):
             self.set_dimensions(height=kwargs["height"])
             del kwargs["height"]
 
-        super().configure(*args, **kwargs)
-
-        if require_redraw is True:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)
 
     def variable_callback(self, var_name, index, mode):
         if not self.variable_callback_blocked:
             self.set(self.variable.get(), from_variable_callback=True)
 
     def set(self, value, from_variable_callback=False):
-        self.value = value
+        """ set determinate value """
+        self.determinate_value = value
 
-        if self.value > 1:
-            self.value = 1
-        elif self.value < 0:
-            self.value = 0
+        if self.determinate_value > 1:
+            self.determinate_value = 1
+        elif self.determinate_value < 0:
+            self.determinate_value = 0
 
         self.draw(no_color_updates=True)
 
         if self.variable is not None and not from_variable_callback:
             self.variable_callback_blocked = True
-            self.variable.set(round(self.value) if isinstance(self.variable, tkinter.IntVar) else self.value)
+            self.variable.set(round(self.determinate_value) if isinstance(self.variable, tkinter.IntVar) else self.determinate_value)
             self.variable_callback_blocked = False
+
+    def get(self):
+        """ get determinate value """
+        return self.determinate_value
+
+    def start(self):
+        """ start indeterminate mode """
+        if not self.loop_running:
+            self.loop_running = True
+            self.internal_loop()
+
+    def stop(self):
+        """ stop indeterminate mode """
+        self.loop_running = False
+
+    def internal_loop(self):
+        if self.loop_running:
+            if self.mode == "determinate":
+                self.determinate_value += self.determinate_speed / 50
+                if self.determinate_value > 1:
+                    self.determinate_value -= 1
+                self.draw()
+                self.after(20, self.internal_loop)
+            else:
+                self.indeterminate_value += self.indeterminate_speed
+                self.draw()
+                self.after(20, self.internal_loop)
+
+    def step(self):
+        if self.mode == "determinate":
+            self.determinate_value += self.determinate_speed / 50
+            if self.determinate_value > 1:
+                self.determinate_value -= 1
+            self.draw()
+        else:
+            self.indeterminate_value += self.indeterminate_speed
+            self.draw()

customtkinter/widgets/ctk_radiobutton.py

@@ -1,6 +1,6 @@
 import tkinter
 import sys
-from typing import Callable, Union
+from typing import Union
 
 from .ctk_canvas import CTkCanvas
 from ..theme_manager import ThemeManager
@@ -54,7 +54,7 @@ class CTkRadioButton(CTkBaseClass):
         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
@@ -86,15 +86,25 @@ class CTkRadioButton(CTkBaseClass):
         self.canvas.bind("<Leave>", self.on_leave)
         self.canvas.bind("<Button-1>", self.invoke)
 
-        self.draw()  # initial draw
-        self.set_cursor()
+        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)
@@ -134,19 +144,6 @@ class CTkRadioButton(CTkBaseClass):
                                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"
-
-            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.state == tkinter.DISABLED:
             self.text_label.configure(fg=ThemeManager.single_color(self.text_color_disabled, self._appearance_mode))
         else:
@@ -154,79 +151,59 @@ class CTkRadioButton(CTkBaseClass):
 
         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()
-
+    def configure(self, require_redraw=False, **kwargs):
         if "text" in kwargs:
-            self.set_text(kwargs["text"])
-            del kwargs["text"]
+            self.text = kwargs.pop("text")
+            self.text_label.configure(text=self.text)
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
         if "state" in kwargs:
-            self.state = kwargs["state"]
+            self.state = kwargs.pop("state")
             self.set_cursor()
             require_redraw = True
-            del kwargs["state"]
 
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
-            del kwargs["fg_color"]
-
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
 
         if "hover_color" in kwargs:
-            self.hover_color = kwargs["hover_color"]
+            self.hover_color = kwargs.pop("hover_color")
             require_redraw = True
-            del kwargs["hover_color"]
 
         if "text_color" in kwargs:
-            self.text_color = kwargs["text_color"]
+            self.text_color = kwargs.pop("text_color")
             require_redraw = True
-            del kwargs["text_color"]
 
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
-            del kwargs["border_color"]
 
         if "border_width" in kwargs:
-            self.border_width = kwargs["border_width"]
+            self.border_width = kwargs.pop("border_width")
             require_redraw = True
-            del kwargs["border_width"]
 
         if "command" in kwargs:
-            self.function = kwargs["command"]
-            del kwargs["command"]
+            self.command = kwargs.pop("command")
+
+        if "textvariable" in kwargs:
+            self.textvariable = kwargs.pop("textvariable")
+            self.text_label.configure(textvariable=self.textvariable)
 
         if "variable" in kwargs:
             if self.variable is not None:
                 self.variable.trace_remove("write", self.variable_callback_name)
 
-            self.variable = kwargs["variable"]
+            self.variable = kwargs.pop("variable")
 
             if self.variable is not None and self.variable != "":
                 self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
-                if self.variable.get() == self.value:
-                    self.select(from_variable_callback=True)
-                else:
-                    self.deselect(from_variable_callback=True)
-            else:
-                self.variable = None
+                self.check_state = True if self.variable.get() == self.value else False
+                require_redraw = True
 
-            del kwargs["variable"]
-
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)
 
     def set_cursor(self):
         if Settings.cursor_manipulation_enabled:
@@ -250,13 +227,6 @@ class CTkRadioButton(CTkBaseClass):
                     if self.text_label is not None:
                         self.text_label.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.")
-
     def on_enter(self, event=0):
         if self.hover is True and self.state == tkinter.NORMAL:
             self.canvas.itemconfig("border_parts",
@@ -287,11 +257,8 @@ class CTkRadioButton(CTkBaseClass):
                 self.check_state = True
                 self.select()
 
-        if self.function is not None:
-            try:
-                self.function()
-            except:
-                pass
+        if self.command is not None:
+            self.command()
 
     def select(self, from_variable_callback=False):
         self.check_state = True

customtkinter/widgets/ctk_scrollbar.py

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

customtkinter/widgets/ctk_slider.py

@@ -61,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
@@ -72,7 +72,7 @@ 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
@@ -139,9 +139,9 @@ class CTkSlider(CTkBaseClass):
                 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"
@@ -185,7 +185,7 @@ class CTkSlider(CTkBaseClass):
 
     def clicked(self, event=None):
         if self.state == "normal":
-            if self.orient.lower() == "horizontal":
+            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
@@ -205,8 +205,8 @@ class CTkSlider(CTkBaseClass):
                 self.variable.set(round(self.output_value) if isinstance(self.variable, tkinter.IntVar) else self.output_value)
                 self.variable_callback_blocked = False
 
-            if self.callback_function is not None:
-                self.callback_function(self.output_value)
+            if self.command is not None:
+                self.command(self.output_value)
 
     def on_enter(self, event=0):
         if self.state == "normal":
@@ -249,9 +249,6 @@ class CTkSlider(CTkBaseClass):
 
         self.draw(no_color_updates=False)
 
-        # if self.callback_function is not None and not from_variable_callback:
-        #     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)
@@ -261,9 +258,7 @@ 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()
@@ -275,14 +270,6 @@ class CTkSlider(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 "progress_color" in kwargs:
             if kwargs["progress_color"] is None:
                 self.progress_color = self.fg_color
@@ -324,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:
@@ -349,7 +336,4 @@ class CTkSlider(CTkBaseClass):
             self.set_dimensions(height=kwargs["height"])
             del kwargs["height"]
 
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)

customtkinter/widgets/ctk_switch.py

@@ -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
@@ -94,16 +91,26 @@ class CTkSwitch(CTkBaseClass):
         self.canvas.bind("<Leave>", self.on_leave)
         self.canvas.bind("<Button-1>", self.toggle)
 
+        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)
+
+        if self.variable is not None and self.variable != "":
+            self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
+            self.check_state = True if self.variable.get() == self.onvalue else False
+
         self.draw()  # initial draw
         self.set_cursor()
 
-        if self.variable is not None:
-            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)
-
     def set_scaling(self, *args, **kwargs):
         super().set_scaling(*args, **kwargs)
 
@@ -186,22 +193,6 @@ class CTkSwitch(CTkBaseClass):
             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"
-
-            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.textvariable is not None:
-                self.text_label.configure(textvariable=self.textvariable)
-
         if self.state == tkinter.DISABLED:
             self.text_label.configure(fg=(ThemeManager.single_color(self.text_color_disabled, self._appearance_mode)))
         else:
@@ -209,13 +200,6 @@ class CTkSwitch(CTkBaseClass):
 
         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)
-
     def toggle(self, event=None):
         if self.state is not tkinter.DISABLED:
             if self.check_state is True:
@@ -225,14 +209,14 @@ 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
@@ -244,9 +228,6 @@ class CTkSwitch(CTkBaseClass):
                 self.variable.set(self.onvalue)
                 self.variable_callback_blocked = False
 
-            if self.callback_function is not None:
-                self.callback_function()
-
     def deselect(self, from_variable_callback=False):
         if self.state is not tkinter.DISABLED or from_variable_callback:
             self.check_state = False
@@ -258,9 +239,6 @@ class CTkSwitch(CTkBaseClass):
                 self.variable.set(self.offvalue)
                 self.variable_callback_blocked = False
 
-            if self.callback_function is not None:
-                self.callback_function()
-
     def get(self):
         return self.onvalue if self.check_state is True else self.offvalue
 
@@ -283,82 +261,64 @@ class CTkSwitch(CTkBaseClass):
             elif self.variable.get() == self.offvalue:
                 self.deselect(from_variable_callback=True)
 
-    def configure(self, *args, **kwargs):
-        require_redraw = False  # some attribute changes require a call of self.draw() at the end
+    def configure(self, require_redraw=False, **kwargs):
+        if "text" in kwargs:
+            self.text = kwargs.pop("text")
+            self.text_label.configure(text=self.text)
+
+        if "text_font" in kwargs:
+            self.text_font = kwargs.pop("text_font")
+            self.text_label.configure(font=self.apply_font_scaling(self.text_font))
 
         if "state" in kwargs:
-            self.state = kwargs["state"]
+            self.state = kwargs.pop("state")
             self.set_cursor()
             require_redraw = True
-            del kwargs["state"]
 
         if "fg_color" in kwargs:
-            self.fg_color = kwargs["fg_color"]
+            self.fg_color = kwargs.pop("fg_color")
             require_redraw = True
-            del kwargs["fg_color"]
-
-        if "bg_color" in kwargs:
-            if kwargs["bg_color"] is None:
-                self.bg_color = self.detect_color_of_master()
-            else:
-                self.bg_color = kwargs["bg_color"]
-            require_redraw = True
-            del kwargs["bg_color"]
 
         if "progress_color" in kwargs:
-            if kwargs["progress_color"] is None:
+            new_progress_color = kwargs.pop("progress_color")
+            if new_progress_color is None:
                 self.progress_color = self.fg_color
             else:
-                self.progress_color = kwargs["progress_color"]
+                self.progress_color = new_progress_color
             require_redraw = True
-            del kwargs["progress_color"]
 
         if "button_color" in kwargs:
-            self.button_color = kwargs["button_color"]
+            self.button_color = kwargs.pop("button_color")
             require_redraw = True
-            del kwargs["button_color"]
 
         if "button_hover_color" in kwargs:
-            self.button_hover_color = kwargs["button_hover_color"]
+            self.button_hover_color = kwargs.pop("button_hover_color")
             require_redraw = True
-            del kwargs["button_hover_color"]
 
         if "border_color" in kwargs:
-            self.border_color = kwargs["border_color"]
+            self.border_color = kwargs.pop("border_color")
             require_redraw = True
-            del kwargs["border_color"]
 
         if "border_width" in kwargs:
-            self.border_width = kwargs["border_width"]
+            self.border_width = kwargs.pop("border_width")
             require_redraw = True
-            del kwargs["border_width"]
 
         if "command" in kwargs:
-            self.callback_function = kwargs["command"]
-            del kwargs["command"]
+            self.command = kwargs.pop("command")
 
         if "textvariable" in kwargs:
-            self.text_label.configure(textvariable=kwargs["textvariable"])
-            del kwargs["textvariable"]
+            self.textvariable = kwargs.pop("textvariable")
+            self.text_label.configure(textvariable=self.textvariable)
 
         if "variable" in kwargs:
-            if self.variable is not None:
+            if self.variable is not None and self.variable != "":
                 self.variable.trace_remove("write", self.variable_callback_name)
 
-            self.variable = kwargs["variable"]
+            self.variable = kwargs.pop("variable")
 
             if self.variable is not None and self.variable != "":
                 self.variable_callback_name = self.variable.trace_add("write", self.variable_callback)
-                if self.variable.get() == self.onvalue:
-                    self.select(from_variable_callback=True)
-                elif self.variable.get() == self.offvalue:
-                    self.deselect(from_variable_callback=True)
-            else:
-                self.variable = None
+                self.check_state = True if self.variable.get() == self.onvalue else False
+                require_redraw = True
 
-            del kwargs["variable"]
-
-        super().configure(*args, **kwargs)
-
-        if require_redraw:
-            self.draw()
+        super().configure(require_redraw=require_redraw, **kwargs)

customtkinter/widgets/ctk_textbox.py

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

customtkinter/widgets/dropdown_menu.py

@@ -42,6 +42,8 @@ class DropdownMenu(tkinter.Menu):
         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))
@@ -98,29 +100,24 @@ class DropdownMenu(tkinter.Menu):
 
     def configure(self, **kwargs):
         if "values" in kwargs:
-            self.values = kwargs["values"]
-            del kwargs["values"]
+            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["fg_color"]
-            del kwargs["fg_color"]
+            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["hover_color"]
-            del kwargs["hover_color"]
+            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["text_color"]
-            del kwargs["text_color"]
+            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["text_font"]
-            del kwargs["text_font"]
+            self.text_font = kwargs.pop("text_font")
             self.configure(font=self.apply_font_scaling(self.text_font))
 
         super().configure(**kwargs)

customtkinter/widgets/widget_base_class.py

@@ -17,7 +17,7 @@ from ..theme_manager import ThemeManager
 
 
 class CTkBaseClass(tkinter.Frame):
-    """ Base class of every Ctk widget, handles the dimensions, bg_color,
+    """ 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,
@@ -26,6 +26,7 @@ class CTkBaseClass(tkinter.Frame):
                  width: int,
                  height: int,
                  **kwargs):
+
         super().__init__(*args, width=width, height=height, **kwargs)  # set desired size of underlying tkinter.Frame
 
         # dimensions
@@ -116,29 +117,24 @@ 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)
+        # 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
@@ -151,15 +147,15 @@ class CTkBaseClass(tkinter.Frame):
         if master_widget is None:
             master_widget = self.master
 
-        if isinstance(master_widget, CTkBaseClass) and hasattr(master_widget, "fg_color"):  # master is CTkFrame
+        if isinstance(master_widget, (CTkBaseClass, CTk, CTkToplevel)) and hasattr(master_widget, "fg_color"):
             if master_widget.fg_color is not None:
                 return master_widget.fg_color
 
             # if fg_color of master is None, try to retrieve fg_color from master of master
             elif hasattr(master_widget.master, "master"):
-                return self.detect_color_of_master(self.master.master)
+                return self.detect_color_of_master(master_widget.master)
 
-        elif isinstance(master_widget, (ttk.Frame, ttk.LabelFrame, ttk.Notebook)):  # master is ttk widget
+        elif isinstance(master_widget, (ttk.Frame, ttk.LabelFrame, ttk.Notebook, ttk.Label)):  # master is ttk widget
             try:
                 ttk_style = ttk.Style()
                 return ttk_style.lookup(master_widget.winfo_class(), 'background')
@@ -178,11 +174,6 @@ class CTkBaseClass(tkinter.Frame):
         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.draw()
 
     def set_scaling(self, new_widget_scaling, new_spacing_scaling, new_window_scaling):

customtkinter/windows/ctk_input_dialog.py

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

customtkinter/windows/ctk_tk.py

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

customtkinter/windows/ctk_toplevel.py

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

examples/complex_example.py

@@ -90,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)

examples/example_button_images.py

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

pyproject.toml

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

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = customtkinter
-version = 4.4.1
+version = 4.6.0
 description = Create modern looking GUIs with Python
 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

test/manual_integration_tests/complex_example_new.py

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

test/manual_integration_tests/test_button_antialiasing.py

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

test/manual_integration_tests/test_ctk_behavior/test_ctk_appearance_mode_change.py

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

test/manual_integration_tests/test_ctk_behavior/test_ctk_iconify_at_beginning.py

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

test/manual_integration_tests/test_ctk_behavior/test_ctk_withdraw_at_beginning.py

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

test/manual_integration_tests/test_ctk_behavior/test_ctk_zoomed_state.py

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

test/manual_integration_tests/test_ctk_toplevel.py

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

test/manual_integration_tests/test_ctk_toplevel_behavior/test_ctk_toplevel_appearance_mode_change.py

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

test/manual_integration_tests/test_ctk_toplevel_behavior/test_ctk_toplevel_iconify_at_beginning.py

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

test/manual_integration_tests/test_ctk_toplevel_behavior/test_ctk_toplevel_withdraw_at_beginning.py

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

test/manual_integration_tests/test_ctk_toplevel_behavior/test_ctk_toplevel_zoomed_state.py

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

test/manual_integration_tests/test_iconify_destroy.py

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

test/manual_integration_tests/test_new_menu_design.py

@@ -1,71 +0,0 @@
-import customtkinter
-import tkinter
-import sys
-
-
-class CTkMenu(tkinter.Toplevel):
-    def __init__(self, master, x, y, options):
-        super().__init__()
-
-        self.overrideredirect(True)
-        self.geometry(f"120x{len(options) * (25 + 3) + 3}+{x}+{y}")
-
-        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, 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, column=0, padx=(3, 3), pady=(3, 0), columnspan=1, rowspan=1, sticky="ew")
-            self.buttons.append(button)
-
-        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(app, button.winfo_rootx(), button.winfo_rooty() + button.winfo_height() + 4, ["Option 1", "Option 2", "Point 3"])
-
-button = customtkinter.CTkButton(command=open_menu, height=30, corner_radius=6)
-button.pack(pady=20)
-
-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

@@ -4,7 +4,7 @@ import customtkinter
 
 app = customtkinter.CTk()
 app.title('Test OptionMenu ComboBox.py')
-app.geometry('400x300')
+app.geometry('400x500')
 
 
 def select_callback(choice):
@@ -12,7 +12,7 @@ def select_callback(choice):
     print("display_selected", choice)
 
 
-countries = ['Bahamas', 'Canada', 'Cuba', 'United States']
+countries = ['Bahamas', 'Canada', 'Cuba', 'United States', "long sdhfhjgdshjafghdgshfhjdsfj"]
 
 variable = tkinter.StringVar()
 variable.set("test")
@@ -23,10 +23,22 @@ 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)
 
-combobox_tk = ttk.Combobox(app, values=countries)
+optionmenu_2 = customtkinter.CTkOptionMenu(app, variable=variable, values=countries, command=select_callback,
+                                           dynamic_resizing=False)
+optionmenu_2.pack(pady=20, padx=10)
+
+combobox_tk = ttk.Combobox(app, values=countries, textvariable=variable)
 combobox_tk.pack(pady=10, padx=10)
 
-combobox_1 = customtkinter.CTkComboBox(app, variable=variable, values=countries, command=select_callback)
+combobox_1 = customtkinter.CTkComboBox(app, variable=variable, values=countries, command=select_callback, width=300)
 combobox_1.pack(pady=20, padx=10)
 
+def set_new_scaling(scaling):
+    customtkinter.set_spacing_scaling(scaling)
+    customtkinter.set_window_scaling(scaling)
+    customtkinter.set_widget_scaling(scaling)
+
+scaling_slider = customtkinter.CTkSlider(app, command=set_new_scaling, from_=0, to=2)
+scaling_slider.pack(pady=20, padx=10)
+
 app.mainloop()

test/manual_integration_tests/test_progressbar_intermediate_mode.py

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

test/manual_integration_tests/test_scrollbar.py

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

test/manual_integration_tests/test_textbox.py

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

test/manual_integration_tests/test_variables.py

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

test/manual_integration_tests/test_window_geometry.py

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

test/manual_integration_tests/text_entry_placeholder.py

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