scustomtkinter 0.2.1__py3-none-any.whl

scustomtkinter/sctk_separator.py

@@ -0,0 +1,308 @@
+#!/usr/bin/python3
+"""
+sCTkSeparator
+
+An advanced Separator widget supporting custom section header text,
+dashed line patterns, corner roundness, and responsive orientation modes.
+Inherits cleanly and directly from ctk.CTkBaseClass to preserve native canvas draw engines.
+
+Derived from Selector class by Fastattack, 2024.
+https://github.com
+"""
+import customtkinter as ctk
+from .themeable_widget import ThemeableWidget
+
+
+class sCTkSeparator(ctk.CTkBaseClass, ThemeableWidget):
+    """Advanced Separator supporting headers, dashed lines, and themes.json matrices."""
+
+    # Required at the TOP LEVEL of the theme block. Structural parameters
+    # (orientation, length, width, text, dash) are deliberately absent: they
+    # are constructor arguments with sensible defaults, and although the theme
+    # CAN supply them, requiring them would force layout decisions into the
+    # stylesheet.
+    _REQUIRED_THEME_KEYS = ("fg_color", "text_color", "font", "corner_radius")
+
+    # Required inside disabled_map.
+    _REQUIRED_DISABLED_KEYS = ("fg_color", "text_color")
+
+    def __init__(self, master=None, **kwargs):
+        # 1. Fire our shared theme logic first. It automatically finds "sCTkSeparator" in themes.json
+        ThemeableWidget.__init__(self, kwargs)
+
+        # 2. 🛠️ THE MUTATION SAFEGUARD DEEP COPY SHIELD:
+        self._local_defaults = dict(self.final_kw)
+        self._custom_disabled_map = dict(self._widget_disabled_map)
+        self._validate_theme_keys()
+
+        # Extract structural parameters safely out of the resolved theme dictionary
+        self._orientation = str(self.final_kw.pop("orientation", "vertical")).lower()
+        length = int(self.final_kw.pop("length", 100))
+        width = float(self.final_kw.pop("width", 4))
+
+        self._text = str(self.final_kw.pop("text", ""))
+        self._dash = self.final_kw.pop("dash", None)
+        # No fallback: validated above.
+        self._font = self.final_kw.pop("font")
+
+        # 🔑 VERTICAL HOUSING REMAP: Programmatically upscale horizontal bounds to fit text
+        if self._text and width <= 4:
+            width = 28
+
+        if self._orientation == "vertical":
+            height = length
+        elif self._orientation == "horizontal":
+            height = width
+            width = length
+        else:
+            raise ValueError(
+                f"The value for orientation is incorrect: \"{self._orientation}\". Should be \"vertical\" or \"horizontal\"")
+
+        # 3. Initialize CustomTkinter's base structure using finalized parameters
+        ctk.CTkBaseClass.__init__(
+            self,
+            master=master,
+            width=width,
+            height=height,
+            bg_color=self.final_kw.get("bg_color", "transparent")
+        )
+
+        self._custom_current_state = "normal"
+        self._corner_radius = self.final_kw.get("corner_radius")
+        self._fg_color = self._check_color_type(self.final_kw.get("fg_color"))
+
+        # Map text color vectors safely out of the extracted dictionary layout layers
+        # No CTkLabel fallback: text_color is validated above, so borrowing another
+        # widget class's colour would only mask a theme gap.
+        self._text_color = self._check_color_type(self.final_kw.get("text_color"))
+
+        # 4. Canvas and render configurations
+        self._canvas = ctk.CTkCanvas(self, highlightthickness=0)
+        self._canvas.place(x=0, y=0, relwidth=1, relheight=1)
+        self._draw_engine = ctk.DrawEngine(self._canvas)
+
+        # 5. Bind layout adjustments to bypass CTkBaseClass strict bind filters safely
+        super(ctk.CTkBaseClass, self).bind("<Configure>", lambda e: self._draw(), add="+")
+
+        # 6. Trigger the initial render loop pass
+        self._draw(no_color_updates=True)
+
+        # 🔑 7. REGISTER LIFECYCLE HANDSHAKE HOOK: Pushes notifications up to Pygubu systems cleanly.
+        self._finalize_themeable_lifecycle()
+
+    def _validate_theme_keys(self) -> None:
+        """
+        Hard-fails at construction on an incomplete theme block, naming the
+        missing key and where it belongs.
+
+        Raises:
+            KeyError: naming the first missing key found.
+        """
+        name = self.__class__.__name__
+        for key in self._REQUIRED_THEME_KEYS:
+            if self._local_defaults.get(key) is None:
+                raise KeyError(
+                    f"'{name}' theme block is missing '{key}' at the top level "
+                    f"of sCTkThemes.json."
+                )
+        for key in self._REQUIRED_DISABLED_KEYS:
+            if self._custom_disabled_map.get(key) is None:
+                raise KeyError(
+                    f"'{name}' theme block is missing '{key}' in disabled_map."
+                )
+
+    def _set_appearance_mode(self, mode_string: str):
+        """Native look catcher ensuring active or disabled tracks repaint fluidly on theme shifts."""
+        if hasattr(super(), "_set_appearance_mode"):
+            try:
+                super()._set_appearance_mode(mode_string)
+            except Exception:
+                pass
+        self._update_current_visual_state()
+    def _update_current_visual_state(self):
+        """Forwards global theme preference swipes directly to our core draw layout routine."""
+        self._draw()
+
+    def _draw(self, no_color_updates=False):
+        if hasattr(super(), "_draw"):
+            try: super()._draw(no_color_updates)
+            except Exception: pass
+        current_w = self.winfo_width() if self.winfo_width() > 1 else self._current_width
+        current_h = self.winfo_height() if self.winfo_height() > 1 else self._current_height
+        self._canvas.delete("all")
+
+        detected_bg = self._detect_color_of_master()
+        if detected_bg == "transparent" or detected_bg is None:
+            detected_bg = ctk.ThemeManager.theme["CTk"]["fg_color"]
+
+        is_disabled = getattr(self, "_custom_current_state", "normal") == "disabled"
+        # FIX: these previously carried hardcoded fallbacks, and since this
+        # widget's theme block had no disabled_map at all, the fallbacks were
+        # ALWAYS taken -- a disabled separator never used the configured
+        # theme. disabled_map is now required, so no fallback is needed. (The
+        # old text fallback also used the Tk colour name "gray50" rather than
+        # a hex pair, the only such value in the library.)
+        target_fg = self._custom_disabled_map.get("fg_color") if is_disabled else self._fg_color
+        target_txt = self._custom_disabled_map.get("text_color") if is_disabled else self._text_color
+
+        fg_rendered = self._apply_appearance_mode(self._check_color_type(target_fg))
+        txt_rendered = self._apply_appearance_mode(self._check_color_type(target_txt))
+        self._canvas.configure(bg=self._apply_appearance_mode(detected_bg))
+
+        if self._orientation == "horizontal":
+            line_thickness = self._current_height if self._current_height < current_h else 4
+            if line_thickness > 10: line_thickness = 4
+        else:
+            line_thickness = self._current_width if self._current_width < current_w else 4
+            if line_thickness > 10: line_thickness = 4
+
+        if self._text:
+            t_id = self._canvas.create_text(current_w / 2, current_h / 2, text=self._text, font=self._font, fill=txt_rendered)
+            bbox = self._canvas.bbox(t_id)
+            if bbox:
+                text_width = bbox[2] - bbox[0]
+                text_height = bbox[3] - bbox[1]
+                tw, th = text_width + 16, text_height + 8
+                x1 = (current_w / 2) - (tw / 2)
+                x2 = (current_w / 2) + (tw / 2)
+
+                if self._orientation == "horizontal":
+                    y1, y2 = 1, current_h - 1
+                    self._canvas.create_line(x1, y1, x1, y2, fill=fg_rendered, width=2)
+                    self._canvas.create_line(x2, y1, x2, y2, fill=fg_rendered, width=2)
+                    mid_y = current_h / 2
+                    self._canvas.create_line(0, mid_y, x1, mid_y, fill=fg_rendered, width=line_thickness, dash=self._dash)
+                    self._canvas.create_line(x2, mid_y, current_w, mid_y, fill=fg_rendered, width=line_thickness, dash=self._dash)
+                else:
+                    x1_v, x2_v = 1, current_w - 1
+                    y1 = (current_h / 2) - (th / 2)
+                    y2 = (current_h / 2) + (th / 2)
+                    self._canvas.create_line(x1_v, y1, x2_v, y1, fill=fg_rendered, width=2)
+                    self._canvas.create_line(x1_v, y2, x2_v, y2, fill=fg_rendered, width=2)
+                    mid_x = current_w / 2
+                    self._canvas.create_line(mid_x, 0, mid_x, y1, fill=fg_rendered, width=line_thickness, dash=self._dash)
+                    self._canvas.create_line(mid_x, y2, mid_x, current_h, fill=fg_rendered, width=line_thickness, dash=self._dash)
+        else:
+            if self._dash:
+                if self._orientation == "horizontal":
+                    self._canvas.create_line(0, current_h / 2, current_w, current_h / 2, fill=fg_rendered, width=line_thickness, dash=self._dash)
+                else:
+                    self._canvas.create_line(current_w / 2, 0, current_w / 2, current_h, fill=fg_rendered, width=line_thickness, dash=self._dash)
+            else:
+                self._draw_engine.draw_rounded_rect_with_border(current_w, current_h, self._apply_widget_scaling(self._corner_radius), 0)
+                self._canvas.itemconfig("inner_parts", outline=fg_rendered, fill=fg_rendered)
+
+    def configure(self, *args, **kwargs):
+        """Processes Pygubu designer workspace queries and manages theme state updates cleanly."""
+        if args and len(args) == 1:
+            pname = args[0]
+            if pname == "state": return ("state", "state", "state", "normal", self.get_state())
+            if pname in ["fg_color", "text_color"]:
+                val = self._custom_disabled_map.get(pname) if self.get_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)
+
+        # FIX: was `if args and isinstance(args, dict)`. args is ALWAYS a
+        # tuple, so this never fired and the dict form of configure() was
+        # dead code. Same tautology fixed across the batch-one widgets.
+        if len(args) == 1 and isinstance(args[0], dict): kwargs = {**args[0], **kwargs}
+        # Runtime overrides have to reach the map a repaint reads, or the
+        # repaint 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 "text" in kwargs: self._text = str(kwargs.pop("text"))
+        if "dash" in kwargs: self._dash = kwargs.pop("dash")
+
+        # FIX: orientation was accepted by __init__ and registered as a Pygubu
+        # property, but configure() never popped it -- so changing it at
+        # runtime fell through to native CTkBaseClass.configure(), whose
+        # check_kwargs_empty() raised "['orientation'] are not supported
+        # arguments". Construction worked; reconfiguration did not, which is
+        # exactly what the Designer does when the dropdown is changed.
+        #
+        # Unlike the other properties here, orientation has a GEOMETRIC
+        # consequence: __init__ assigns height=length for a vertical
+        # separator and width=length for a horizontal one. Switching
+        # orientation therefore has to swap the two dimensions, or a vertical
+        # separator turned horizontal stays tall and thin.
+        if "orientation" in kwargs:
+            new_orientation = str(kwargs.pop("orientation")).lower()
+            if new_orientation not in ("vertical", "horizontal"):
+                raise ValueError(
+                    f'The value for orientation is incorrect: "{new_orientation}". '
+                    f'Should be "vertical" or "horizontal"'
+                )
+            if new_orientation != self._orientation:
+                self._orientation = new_orientation
+                # Swap, rather than recompute from length/width: those were
+                # consumed at construction and aren't retained, and the current
+                # dimensions already reflect any resizing since.
+                kwargs.setdefault("width", self._current_height)
+                kwargs.setdefault("height", self._current_width)
+
+        # length is a construction-time alias for whichever dimension the
+        # orientation makes the long one. Translated here so the Designer can
+        # edit it after the fact.
+        if "length" in kwargs:
+            new_length = int(kwargs.pop("length"))
+            if self._orientation == "vertical":
+                kwargs["height"] = new_length
+            else:
+                kwargs["width"] = new_length
+
+        self._drop_cleared(kwargs)
+        if kwargs: super().configure(**kwargs)
+        self._draw()
+
+    config = configure
+    def get_state(self) -> str: return str(getattr(self, "_custom_current_state", "normal")).lower()
+    def state(self, mode: str = None) -> str:
+        if mode is None: return self.get_state()
+        self._custom_current_state = mode.lower()
+        self._draw()
+        return self._custom_current_state
+
+    def cget(self, attribute_name: str):
+        if attribute_name == "height": raise ValueError("Use length and width arguments instead.")
+        if attribute_name == "state": return self.get_state()
+        mapping = {"corner_radius": self._corner_radius, "fg_color": self._fg_color,
+                   "text_color": self._text_color, "orientation": self._orientation,
+                   "text": self._text, "dash": self._dash}
+        # CHECKED FIRST, not passed as get()'s default.
+        #
+        # This read `mapping.get(name, super().cget(name))`, and Python works
+        # out the default BEFORE calling get() -- so super().cget(name) ran on
+        # every call and raised for anything the native base class does not
+        # know, including every property listed above. cget("text") and
+        # cget("fg_color") both failed on a separator that knew their values
+        # perfectly well. text_color was also missing from the list.
+        if attribute_name in mapping:
+            return mapping[attribute_name]
+        return super().cget(attribute_name)
+
+    def bind(self, sequence=None, command=None, add=True):
+        """
+        Routes bindings to the internal canvas, which is what actually
+        receives events -- CTkBaseClass filters direct binds on the widget.
+
+        FIX: the `add` argument was previously accepted and then ignored,
+        with add=True hardcoded in the forwarded call. A caller passing
+        add=False expecting to REPLACE existing bindings would silently
+        accumulate them instead.
+        """
+        self._canvas.bind(sequence, command, add=add)
+
+    def unbind(self, sequence=None, funcid=None):
+        """
+        Removes a binding from the internal canvas.
+
+        FIX: funcid was previously accepted and then discarded, so this always
+        removed EVERY binding for the sequence rather than the single one the
+        caller identified. That is the same destructive behaviour that made
+        unbind() unusable for blocking scrollbar drags in
+        sCTkScrollableFrame -- Tk's unbind() with no funcid wipes bindings
+        this widget never installed, with no way to restore them.
+        """
+        self._canvas.unbind(sequence, funcid)

scustomtkinter/sctk_slider.py

@@ -0,0 +1,264 @@
+#!/usr/bin/python3
+"""
+sCTkSlider
+
+A theme-compliant linear adjustment slider widget. Inherits directly from
+ctk.CTkSlider so CustomTkinter handles native mouse-drag handling, scaling,
+and coordinate snapping; this class layers automatic light/dark theme
+resolution and a distinct enabled/disabled visual state on top.
+
+Base class order matters here: `class sCTkSlider(ctk.CTkSlider,
+ThemeableWidget)` puts the native CTk class first, so every `super()` call in
+this file's own methods resolves to ctk.CTkSlider -- and, beneath it,
+tkinter.Misc -- never to ThemeableWidget. ThemeableWidget's own
+configure()/cget()/_set_appearance_mode() overrides have been removed entirely
+for this reason (see themeable_widget.py's docstring); this widget owns all of
+its own runtime color-swapping logic.
+
+Unlike every other widget in this project, state is NOT tracked in a parallel
+self._custom_current_state attribute -- state() and _apply_custom_theme_colors()
+both read the NATIVE widget's own "state" property directly via
+super().cget("state"), treating it as the single source of truth rather than
+duplicating it. Disabling routes "state" straight through to the native
+widget's own configure(), which is the same underlying mechanism confirmed
+correct elsewhere in this library (native state="disabled" blocks
+interaction; manual event-unbinding does not).
+"""
+from typing import Any, Callable, Optional
+import customtkinter as ctk
+from .themeable_widget import ThemeableWidget, defer
+
+
+class sCTkSlider(ctk.CTkSlider, ThemeableWidget):
+    """Themeable linear adjustment slider.
+
+    Adds to native ctk.CTkSlider:
+      - Automatic light/dark theme resolution from sCTkThemes.json (via
+        ThemeableWidget.__init__ -- see that class's docstring for what it does,
+        and just as importantly, what it no longer does).
+      - A distinct enabled/disabled visual state, read directly from the
+        native widget's own state (see module docstring) rather than a
+        parallel instance attribute.
+      - Pygubu Designer property introspection for `state`, `fg_color`,
+        `progress_color`, `button_color`, and `button_hover_color` via a
+        single-argument configure() call.
+
+    Colors are passed through to configure() as raw (light, dark) tuples rather
+    than pre-resolved to a single value, so CustomTkinter's own appearance-mode
+    tracking repaints them automatically on a light/dark switch -- the same
+    approach validated on sCTkComboBox, sCTkSegmentedButton, and the button
+    family. Not separately re-confirmed for this specific widget.
+    """
+
+    def __init__(self, master: Optional[Any] = None, **kw: Any) -> None:
+        """
+        Args:
+            master: Parent container.
+            **kw: `command` (callable) and `variable` (tkinter.Variable) are
+                pulled out explicitly below. Everything else is either a
+                native CTkSlider argument or a theme-key override (see the
+                "sCTkSlider" block in sCTkThemes.json).
+        """
+        # 1. Capture widget-specific attributes early, before the mixin's own
+        # configuration pass.
+        command = kw.pop("command", None)
+        variable = kw.pop("variable", None)
+
+        # 2. Fire our shared theme logic. This resolves final_kw
+        # (construction-time properties) and the disabled color map. See
+        # ThemeableWidget.__init__ for what actually happens here.
+        ThemeableWidget.__init__(self, kw)
+        self._local_defaults = dict(self.final_kw)
+        self._custom_disabled_map = dict(self._widget_disabled_map)
+
+        # Remove any stray "state" key from final_kw -- prevents native
+        # constructor validation collisions.
+        self.final_kw.pop("state", None)
+
+        # 3. Initialize CustomTkinter natively with the clean final kwargs array.
+        super().__init__(master, **self.final_kw)
+
+        if command is not None: super().configure(command=command)
+        if variable is not None: super().configure(variable=variable)
+
+        # Deferred slightly, matching this file's original startup pattern --
+        # applies the initial theme colors shortly after construction.
+        defer(self, 10, self._apply_custom_theme_colors)
+        self._finalize_themeable_lifecycle()
+
+    def configure(self, *args: Any, **kwargs: Any) -> Any:
+        """
+        Standard widget configuration, with Pygubu/positional-argument handling.
+
+        Args:
+            *args: At most one positional argument is meaningful:
+                - a dict: merged into kwargs and processed normally below.
+                - the literal string "state": returns a Tkinter-style
+                  (name, name, name, default, current) tuple.
+                - one of "fg_color"/"progress_color"/"button_color"/
+                  "button_hover_color": returns the same style of tuple, with
+                  `current` reflecting the disabled or normal value as
+                  appropriate. Note the returned value is str(value), where
+                  value may itself be a (light, dark) tuple rather than a
+                  single resolved color -- a known limitation shared with the
+                  wider Pygubu-query investigation set aside elsewhere in this
+                  project, not fixed here.
+                - anything else: forwarded directly to the native widget's
+                  configure(), which does not support single-argument property
+                  queries for arbitrary properties (same limitation).
+            **kwargs: Standard CTkSlider configuration options, plus:
+                `command`/`variable` are routed through super().configure()
+                individually. Note `state` is NOT specially intercepted here
+                -- it flows straight through to the native widget's own
+                configure(state=...), which is what makes this widget's
+                disable mechanism correct (see module docstring).
+
+        Returns:
+            The query tuple described above for the single-argument case, or
+            whatever super().configure() returns for the keyword-argument case
+            (typically None).
+        """
+        # args[0] was already correctly unwrapped here in the original file --
+        # unlike most other widgets in this library, this one never had the
+        # `pname = args` tuple-comparison bug. Preserved as-is.
+        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", "progress_color", "button_color", "button_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)
+
+                    # The default falls back to the CURRENT value when the
+                    # theme has nothing to offer. sCTkThemes.json has no
+                    # sCTkSlider block at all, so every one of these lookups
+                    # returns None -- and pygubu hands that None straight back
+                    # to the widget:
+                    #
+                    #     color is None, for transparency set color='transparent'
+                    #
+                    # With the fallback, clearing such a field is a no-op
+                    # rather than an error. Adding the theme block is the real
+                    # fix; this stops the Designer breaking in the meantime.
+                    theme_value = self._theme_default(pname)
+                    if theme_value is None:
+                        theme_value = val if val is not None else super().cget(pname)
+                    return (pname, pname, pname,
+                            self._query_value(theme_value),
+                            self._query_value(val if val is not None else super().cget(pname)))
+
+                return self._configure_query(pname)
+
+        # Runtime overrides have to reach the map a repaint reads, or
+        # _apply_custom_theme_colors() puts the theme value straight back --
+        # see ThemeableWidget._record_theme_overrides().
+        self._record_theme_overrides(kwargs)
+
+        if "command" in kwargs: super().configure(command=kwargs.pop("command"))
+        if "variable" in kwargs: super().configure(variable=kwargs.pop("variable"))
+
+        # "state" is deliberately left in kwargs here, not popped -- it flows
+        # through to super().configure(**kwargs) below, reaching the native
+        # widget directly. has_state only tracks whether a repaint is needed
+        # afterward.
+        has_state = "state" in kwargs
+        self._drop_cleared(kwargs)
+
+        if kwargs:
+            super().configure(**kwargs)
+
+        if has_state:
+            self._apply_custom_theme_colors()
+
+    # Tkinter/CTk convention binds .config to .configure as a SEPARATE class
+    # attribute -- it does not automatically track whichever configure() a
+    # subclass defines. Without this line, calling .config(...) on an instance
+    # would silently skip this entire override and land on the native widget's
+    # configure() directly, bypassing theming entirely.
+    config = configure
+
+    def _set_appearance_mode(self, mode_string: str) -> None:
+        """
+        Forwards CustomTkinter's internal light/dark mode change notification to
+        the native widget.
+
+        No longer manually re-triggers _apply_custom_theme_colors(). That
+        method 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 -- the
+        same approach validated on sCTkComboBox, sCTkSegmentedButton, and the
+        button family.
+
+        Args:
+            mode_string: The new appearance mode ("Light" or "Dark"), as passed
+                by CustomTkinter's internal appearance-mode change machinery.
+        """
+        if hasattr(super(), "_set_appearance_mode"):
+            try: super()._set_appearance_mode(mode_string)
+            except Exception: pass
+
+    def state(self, mode: Optional[str] = None) -> str:
+        """
+        Gets or sets the widget's enabled/disabled state.
+
+        Unlike every other widget in this library, this reads the query
+        directly from the native widget's own cget("state") rather than a
+        parallel self._custom_current_state -- see module docstring.
+
+        Args:
+            mode: If None, returns the native widget's current "state" value
+                directly. Otherwise, forwarded to configure(state=mode),
+                which reaches the native widget's own state handling.
+
+        Returns:
+            If querying: whatever the native widget's "state" cget returns,
+            lowercased. If setting: echoes back the `mode` argument exactly as
+            given (not re-queried from the native widget afterward).
+        """
+        if mode is None:
+            return str(super().cget("state")).lower()
+        self.configure(state=mode)
+        return mode
+
+    def get_state(self) -> str:
+        """Equivalent to calling state() with no argument."""
+        return self.state()
+
+    def _apply_custom_theme_colors(self) -> None:
+        """
+        Recomputes and applies this widget's colors from the theme file, based
+        on the current state (read directly from the native widget -- see
+        module docstring).
+
+        Called shortly after construction (via after(10, ...)), on every
+        state()/configure(state=...) change, and (indirectly, via
+        _set_appearance_mode) on appearance-mode changes.
+
+        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.
+        Every value here traces back to sCTkThemes.json; there are no
+        hardcoded colors in this method.
+
+        While disabled, button_hover_color is forced to match button_color --
+        since hover can't trigger once natively disabled, this just ensures
+        nothing else could show a stale hover color if queried directly.
+        """
+        is_disabled = str(super().cget("state")).lower() == "disabled"
+        target_map = self._custom_disabled_map if is_disabled else self._local_defaults
+
+        fg_payload = {}
+        for key in ("fg_color", "progress_color", "button_color", "button_hover_color"):
+            val = target_map.get(key)
+            if val is not None:
+                fg_payload[key] = val
+
+        if is_disabled and "button_color" in fg_payload:
+            fg_payload["button_hover_color"] = fg_payload["button_color"]
+
+        if fg_payload:
+            super().configure(**fg_payload)