scustomtkinter 0.2.1__py3-none-any.whl

scustomtkinter/sctk_combobox.py

@@ -0,0 +1,155 @@
+#!/usr/bin/python3
+"""
+sCTkComboBox
+
+A custom, theme-compliant parameter selection dropdown combobox widget.
+Inherits cleanly and directly from ctk.CTkComboBox to preserve 100% of native
+CustomTkinter features, theme tracking loops, and native input locks.
+"""
+import customtkinter as ctk
+from .themeable_widget import ThemeableWidget
+
+class sCTkComboBox(ctk.CTkComboBox, ThemeableWidget):
+    def __init__(self, master=None, **kw):
+        # 1. PARAMETER POPPING: Capture combobox-specific tracking parameters early
+        values = kw.pop("values", [""])
+        command = kw.pop("command", None)
+        variable = kw.pop("variable", None)
+
+        # 2. Fire our shared theme logic first. It automatically finds "sCTkComboBox" in the JSON
+        ThemeableWidget.__init__(self, kw)
+
+        # 3. THE MUTATION SAFEGUARD DEEP COPY:
+        self._local_defaults = dict(self.final_kw)
+        self._custom_disabled_map = dict(self._widget_disabled_map)
+
+        # 4. Initialize CustomTkinter natively with the clean final kwargs array safely
+        super().__init__(master, **self.final_kw)
+
+        # 5. Build your inner custom properties using your popped parameters safely
+        if values:
+            super().configure(values=values)
+            if isinstance(values, list) and len(values) > 0 and values[0] != "":
+                self.set(values[0])
+
+        if command: super().configure(command=command)
+        if variable: super().configure(variable=variable)
+
+        self._custom_current_state = "normal"
+
+        # 6. REGISTER LIFECYCLE HANDSHAKE HOOK:
+        self._finalize_themeable_lifecycle()
+
+    def _set_appearance_mode(self, mode_string: str):
+        """
+        EXPERIMENTAL: no longer manually re-triggers _update_current_visual_state().
+        _update_current_visual_state() now passes raw (light, dark) tuples straight
+        through to configure() instead of pre-resolving to a single color, so CTk's
+        own appearance-mode tracking should repaint correctly on its own. If colors
+        stop following mode changes (especially while disabled), that's the signal
+        this doesn't hold and the manual re-trigger needs to come back.
+        """
+        if hasattr(super(), "_set_appearance_mode"):
+            try:
+                super()._set_appearance_mode(mode_string)
+            except Exception:
+                pass
+
+    def configure(self, *args, **kwargs):
+        """Handles Pygubu designer queries and manages composite state updates safely."""
+        if len(args) == 1:
+            if isinstance(args[0], dict):
+                kwargs = {**args[0], **kwargs}
+            else:
+                pname = args[0]
+                if pname == "state":
+                    return ("state", "state", "state", "normal", str(self.state()))
+
+                if pname in ["fg_color", "border_color", "text_color", "hover_color"]:
+                    current_state = str(self.state()).lower()
+                    val = self._custom_disabled_map.get(pname) if current_state == "disabled" else self._local_defaults.get(pname)
+                    return (pname, pname, pname, self._query_value(self._theme_default(pname)), self._query_value(val))
+
+                return self._configure_query(pname)
+
+        if "values" in kwargs: super().configure(values=kwargs.pop("values"))
+        if "command" in kwargs: super().configure(command=kwargs.pop("command"))
+        if "variable" in kwargs: super().configure(variable=kwargs.pop("variable"))
+
+        # Runtime overrides have to reach the map a repaint reads, or
+        # _update_current_visual_state() puts the theme value straight back --
+        # see ThemeableWidget._record_theme_overrides().
+        self._record_theme_overrides(kwargs)
+
+        if "state" in kwargs:
+            self.state(kwargs.pop("state"))
+
+        if kwargs:
+            self._drop_cleared(kwargs)
+            if kwargs:
+                return super().configure(**kwargs)
+        return None
+
+    config = configure
+
+    def get_state(self):
+        """Explicit getter synchronized with your standalone test harness script assertions."""
+        return self.state()
+
+    def state(self, mode: str = None):
+        """Dedicated combobox state controller."""
+        if mode is None:
+            return str(getattr(self, "_custom_current_state", "normal")).lower()
+
+        mode = mode.lower()
+        if mode in ("normal", "enabled", "active"):
+            self._custom_current_state = "normal"
+            self._update_current_visual_state()
+
+        elif mode == "disabled":
+            self._custom_current_state = "disabled"
+            self._update_current_visual_state()
+
+        # FIX: this returned nothing when SETTING a mode -- only the query
+        # branch above returned a value -- so `widget.state("disabled")` gave
+        # None. Every other themed widget returns the resulting state, and
+        # sCTkCheckBox had the identical gap fixed earlier in this audit.
+        return self._custom_current_state
+
+    def _update_current_visual_state(self):
+        """
+        EXPERIMENTAL: passes raw (light, dark) tuples straight through to configure()
+        instead of resolving to a single color first, so CTk's native tracking can
+        handle appearance-mode repaints without help from _set_appearance_mode.
+        """
+        is_disabled = getattr(self, "_custom_current_state", "normal") == "disabled"
+        target_map = self._custom_disabled_map if is_disabled else self._local_defaults
+
+        config_payload = {}
+        for key in ("fg_color", "border_color", "button_color", "button_hover_color",
+                    "dropdown_fg_color", "dropdown_text_color", "dropdown_hover_color", "border_width", "font"):
+            val = target_map.get(key)
+            if val is not None:
+                config_payload[key] = val
+
+        # text_color is handled separately, because this widget sets CTk's own
+        # state="disabled" below -- and CTkComboBox's draw code then uses its
+        # native text_color_disabled option, overriding whatever text_color was
+        # set to. Swapping text_color out of disabled_map was therefore
+        # discarded at draw time and the theme key had no visible effect.
+        #
+        # Both options are set, so CTk chooses between them as designed.
+        normal_text = self._local_defaults.get("text_color")
+        if normal_text is not None:
+            config_payload["text_color"] = normal_text
+        disabled_text = self._custom_disabled_map.get("text_color")
+        if disabled_text is not None:
+            config_payload["text_color_disabled"] = disabled_text
+
+        if config_payload:
+            super().configure(**config_payload)
+
+        if is_disabled:
+            super().configure(state="disabled")
+        else:
+            super().configure(state="normal")

scustomtkinter/sctk_core.py

@@ -0,0 +1,15 @@
+#!/usr/bin/python3
+"""
+sCTk
+
+A clean, zero-overhead wrapper subclass of ctk.CTk.
+Eliminitates the need for end-users to import customtkinter directly,
+acting as the singular core application window root for the sCustomTkinter library.
+"""
+import customtkinter as ctk
+
+class sCTk(ctk.CTk):
+    def __init__(self, fg_color=None, **kwargs):
+        # 🔑 THE HOOK PASS: Explicitly scoop up and forward all positional/keyword arguments
+        # directly up to the native CustomTkinter top-level application root constructor safely.
+        super().__init__(fg_color=fg_color, **kwargs)