scustomtkinter 0.2.1__py3-none-any.whl

scustomtkinter_pygubu/sCTkTabviewbo.py

@@ -0,0 +1,226 @@
+#!/usr/bin/python3
+"""
+sCTkTabview
+
+Built on top of CTkTabview.
+
+UI source file: sCTkTabview.ui
+"""
+import tkinter as tk
+import tkinter.ttk as ttk
+from customtkinter import CTkTabview
+from pygubu.api.v1 import (
+    BuilderObject,
+    register_widget,
+    copy_custom_property,
+)
+
+from pygubu.plugins.customtkinter import nsctk
+from pygubu.plugins.customtkinter.tabview import CTkTabviewBO, CTkTabviewTabBO
+from scustomtkinter.sctk_tabview import sCTkTabview
+from scustomtkinter.sctk_frame import sCTkFrame
+
+
+#
+# Builder definition section
+#
+widget_namespace = "scustomtkinter.sctk_tabview"
+widget_classname = "sCTkTabview"
+builder_namespace = "scustomtkinter"
+section_name = "sCustomTkinter"
+
+
+class sCTkTabviewBO(CTkTabviewBO):
+    class_ = sCTkTabview
+
+    def code_imports(self):
+        # should return an iterable of (module, classname/function) to import
+        # or None
+        imports = [(widget_namespace, widget_classname)]
+        imports.extend(self.code_extra_imports())
+        return imports
+
+
+builder_id = f"{builder_namespace}.{widget_classname}"
+register_widget(
+    builder_id, sCTkTabviewBO, widget_classname, ("ttk", section_name)
+)
+
+
+# =====================================================================
+# sCTkTabview.Tab
+#
+# A tab is not a widget you construct -- it is created BY its parent tabview,
+# through add(). So this builder object has class_ = None and overrides
+# realize() to call the parent's add() rather than instantiating anything.
+# That is CTkTabviewTabBO's design and this inherits it; only the naming,
+# the parent constraint and the generated code differ.
+#
+# WHAT add() RETURNS. sCTkTabview.add() hands back an sCTkFrame page wrapper
+# nested inside the native tab frame, not the native frame itself -- see the
+# widget's own docs. That is exactly what a container builder object wants:
+# children dropped onto the tab land in the wrapper, which is a themed sCTk
+# widget rather than a bare ctk.CTkFrame. No extra work is needed here to get
+# that; realize() simply returns whatever add() gives it.
+# =====================================================================
+class sCTkTabviewTabBO(CTkTabviewTabBO):
+    # Only this tabview may hold this tab. Without the constraint the Designer
+    # would offer sCTkTabview.Tab as a child of anything, and dropping one
+    # elsewhere would fail at realize() when the parent turned out to have no
+    # add() method.
+    allowed_parents = (builder_id,)
+
+    def realize(self, parent, extra_init_args: dict = None):
+        """
+        Creates the tab, renaming it if that name is already taken.
+
+        Native CTkTabview.add() raises ValueError on a duplicate name. Inside
+        the Designer that exception surfaces only on the console, where nobody
+        is looking -- the tab silently fails to appear and the tree and the
+        preview disagree about what exists.
+
+        A unique suffix is appended instead, and written back into the widget
+        metadata so the inspector's `label` field updates too. Typing "mark"
+        for a second tab therefore produces a visible "mark_2" rather than an
+        invisible error. That is feedback the user actually receives.
+
+        Deliberately NOT done in sCTkTabview itself: the widget keeps raising,
+        so application code that creates a duplicate tab still fails loudly
+        rather than quietly getting a renamed one. This leniency is a
+        design-time affordance, not a change to the widget's contract.
+        """
+        view = parent.get_child_master()
+        name = self._get_tab_name()
+
+        # _name_list is CTkTabview's own record of tab names, in order.
+        existing = list(getattr(view, "_name_list", []))
+        if name in existing:
+            suffix = 2
+            while f"{name}_{suffix}" in existing:
+                suffix += 1
+            name = f"{name}_{suffix}"
+            # Write it back so the inspector and the generated code agree with
+            # what is actually on screen.
+            self.wmeta.properties["label"] = name
+
+        self.widget = view.add(name)
+        return self.widget
+
+    @staticmethod
+    def _find_tabview(widget):
+        """Walk up from a page wrapper to the sCTkTabview that owns it."""
+        node = widget
+        for _ in range(6):          # page -> native tab frame -> tabview
+            if node is None:
+                return None
+            if isinstance(node, sCTkTabview):
+                return node
+            node = getattr(node, "master", None)
+        return None
+
+    def configure(self, target=None):
+        """
+        Applies a changed `label` by renaming the live tab.
+
+        CTkTabviewTabBO.configure() is a no-op -- `pass` -- so editing the
+        label in the inspector updated the metadata but never touched the
+        widget: the design area kept the old name while the preview, which
+        rebuilds from scratch, showed the new one.
+
+        EVERYTHING IS DERIVED FROM self.widget, deliberately. An earlier
+        version stashed the parent view and the created name on the builder
+        object during realize() and read them back here -- which failed,
+        because Pygubu calls configure() on a builder object whose realize()
+        never ran. Tracing showed those instances arriving with the new label
+        correctly set but no instance state at all:
+
+            [TabBO.configure] view=False old=None new='sue'
+
+        The page wrapper is the only reliable anchor: walk up from it to find
+        the tabview, then find the wrapper in that tabview's page registry to
+        learn the name it is currently filed under.
+        """
+        widget = getattr(self, "widget", None)
+        if widget is None:
+            return
+
+        view = self._find_tabview(widget)
+        if view is None:
+            return
+
+        # The name this page is currently registered under, found by identity
+        # rather than by trusting any stored value.
+        old_name = None
+        for name, page in getattr(view, "_sctk_pages", {}).items():
+            if page is widget:
+                old_name = name
+                break
+        if old_name is None:
+            return
+
+        new_name = self._get_tab_name()
+        if new_name == old_name:
+            return
+
+        existing = [n for n in getattr(view, "_name_list", []) if n != old_name]
+        if new_name in existing:
+            suffix = 2
+            while f"{new_name}_{suffix}" in existing:
+                suffix += 1
+            new_name = f"{new_name}_{suffix}"
+            self.wmeta.properties["label"] = new_name
+
+        try:
+            view.rename(old_name, new_name)
+        except Exception:
+            # Widget torn down mid-edit, or a native rename this build of
+            # CustomTkinter doesn't support. The preview rebuild still shows
+            # the new label, so this degrades rather than breaks.
+            return
+
+    def code_realize(self, boparent, code_identifier=None):
+        """
+        Emits the tab creation line.
+
+        Overridden only to keep the generated code honest about which class
+        the returned page is: sCTkTabview.add() returns an sCTkFrame wrapper,
+        so the comment tells a reader what they are holding. The call itself
+        is identical to the parent implementation's.
+        """
+        view = boparent.code_child_master()
+        tabid = self.code_identifier()
+        tab_name = self._get_tab_name()
+        return [f'{tabid} = {view}.add("{tab_name}")  # returns an sCTkFrame']
+
+
+tab_builder_id = f"{builder_namespace}.sCTkTabviewTab"
+register_widget(
+    tab_builder_id,
+    sCTkTabviewTabBO,
+    f"{widget_classname}.Tab",
+    ("ttk", section_name),
+)
+
+#
+# Wire the parent/child relationship in both directions. Pygubu checks both:
+# add_allowed_child() lets the Designer offer the tab when a tabview is
+# selected, and allowed_parents on the class above stops it being offered
+# anywhere else.
+#
+sCTkTabviewBO.add_allowed_child(tab_builder_id)
+
+#
+# CustomTkinter's own tab is still accepted, so existing .ui files that used
+# CTkTabview.Tab inside an sCTkTabview keep loading. New designs should use
+# sCTkTabview.Tab above -- it is the one that appears under the sCustomTkinter
+# palette section.
+#
+sCTkTabviewBO.add_allowed_child(nsctk.CTkTabviewTab)
+CTkTabviewTabBO.add_allowed_parent(builder_id)
+
+# NOTE: an earlier version of this file also called
+#     sCTkTabviewBO.add_allowed_child(sCTkFrame)
+# passing the CLASS. add_allowed_child() takes a builder id STRING, so that
+# call silently matched nothing and had no effect. Removed rather than
+# corrected: a tabview's children are tabs, and a frame belongs inside a tab
+# rather than directly in the tabview.

scustomtkinter_pygubu/sCTkTextboxPrimarybo.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python3
+"""
+sCTkTextboxPrimary
+
+update to ctktextbox
+
+UI source file: sCTkTextboxPrimary.ui
+"""
+import tkinter as tk
+import tkinter.ttk as ttk
+from customtkinter import CTkTextbox
+from pygubu.api.v1 import (
+    BuilderObject,
+    register_widget,
+)
+
+from pygubu.plugins.customtkinter.widgets import CTkTextboxBO
+from scustomtkinter.sctk_textbox_primary import sCTkTextboxPrimary
+
+
+#
+# Builder definition section
+#
+widget_namespace = "scustomtkinter.sctk_textbox_primary"
+widget_classname = "sCTkTextboxPrimary"
+builder_namespace = "scustomtkinter"
+section_name = "sCustomTkinter"
+
+
+class sCTkTextboxPrimaryBO(CTkTextboxBO):
+    class_ = sCTkTextboxPrimary
+
+    def code_imports(self):
+        # should return an iterable of (module, classname/function) to import
+        # or None
+        imports = [(widget_namespace, widget_classname)]
+        imports.extend(self.code_extra_imports())
+        return imports
+
+
+builder_id = f"{builder_namespace}.{widget_classname}"
+register_widget(
+    builder_id, sCTkTextboxPrimaryBO, widget_classname, ("ttk", section_name)
+)
+

scustomtkinter_pygubu/sCTkTextboxSecondarybo.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python3
+"""
+sCTkTextboxSecondary
+
+based on ctktextbox
+
+UI source file: sCTkTextboxSecondary.ui
+"""
+import tkinter as tk
+import tkinter.ttk as ttk
+from customtkinter import CTkTextbox
+from pygubu.api.v1 import (
+    BuilderObject,
+    register_widget,
+)
+
+from pygubu.plugins.customtkinter.widgets import CTkTextboxBO
+from scustomtkinter.sctk_textbox_secondary import sCTkTextboxSecondary
+
+
+#
+# Builder definition section
+#
+widget_namespace = "scustomtkinter.sctk_textbox_secondary"
+widget_classname = "sCTkTextboxSecondary"
+builder_namespace = "scustomtkinter"
+section_name = "sCustomTkinter"
+
+
+class sCTkTextboxSecondaryBO(CTkTextboxBO):
+    class_ = sCTkTextboxSecondary
+
+    def code_imports(self):
+        # should return an iterable of (module, classname/function) to import
+        # or None
+        imports = [(widget_namespace, widget_classname)]
+        imports.extend(self.code_extra_imports())
+        return imports
+
+
+builder_id = f"{builder_namespace}.{widget_classname}"
+register_widget(
+    builder_id, sCTkTextboxSecondaryBO, widget_classname, ("ttk", section_name)
+)
+

scustomtkinter_pygubu/sCTkToplevelbo.py

@@ -0,0 +1,55 @@
+#!/usr/bin/python3
+
+import tkinter as tk
+import tkinter.ttk as ttk
+
+from pygubu.api.v1 import (
+    BuilderObject,
+    register_widget,
+    register_custom_property
+)
+
+from pygubu.plugins.customtkinter import nsctk
+from pygubu.plugins.customtkinter.windows import CTkToplevelBO
+from pygubu.api.v1 import copy_custom_property
+
+from scustomtkinter.sctk_toplevel import sCTkToplevel
+from pygubu.plugins.customtkinter._config import GROOT
+
+
+
+#
+# Builder definition section
+#
+widget_namespace = "scustomtkinter.sctk_toplevel"
+# NOTE the capitalisation: sCTkToplevel, lowercase "l", matching the class in
+# sctk_toplevel.py and CustomTkinter's own CTkToplevel. This was previously
+# "sCTkTopLevel", which fed straight into code_imports() below and generated
+#     from scustomtkinter.sctk_toplevel import sCTkTopLevel
+# -- a name that does not exist, so every generated file using this widget
+# failed at import. It also made the builder id and the palette entry disagree
+# with the rest of the library.
+widget_classname = "sCTkToplevel"
+builder_namespace = "scustomtkinter"
+section_name = "sCustomTkinter"
+
+
+class sCTkToplevelBO(CTkToplevelBO):
+    class_ = sCTkToplevel
+    container = True
+
+    def code_imports(self):
+        # should return an iterable of (module, classname/function) to import
+        # or None
+        return [(widget_namespace, widget_classname)]
+
+    # NOTE: unlike sCTkBO, CTkToplevelBO's own code_imports() has no
+    # conditional appearance_mode / color_theme handling -- those are CTk-only
+    # properties -- so overriding it here loses nothing.
+
+
+builder_id = f"{builder_namespace}.{widget_classname}"
+register_widget(
+    builder_id, sCTkToplevelBO, widget_classname, ("ttk", section_name), group=GROOT
+)
+

scustomtkinter_pygubu/sCTkWidgetSetForPygubuDesigner.py

@@ -0,0 +1,141 @@
+import importlib
+import tkinter as tk
+from typing import List
+from pygubu.component.plugin_engine import BuilderLoaderPlugin
+from customtkinter import (CTkScrollableFrame)
+
+#
+#   EVERY WIDGET NEEDS A LINE HERE.
+#
+#   These imports are what register the builder objects when an APPLICATION
+#   loads a .ui file. The Designer does not use them -- it imports the builder
+#   objects directly through designer/plugin.py -- so a widget missing from
+#   this list works perfectly while you design and fails the moment you run
+#   the generated code:
+#
+#       AttributeError: 'list' object has no attribute 'startswith'
+#
+#   raised from importlib, because pygubu fell through to get_module_for().
+#   sCTkNotebook, sCTkDialog and sCTkFileExplorer were all in that state.
+#
+#   Import the sCustomTkinter Widgets (alphabetically)
+#   Format is "import foobo" for normal widgets that are selectable
+#   format is
+#   from foo import foo
+#   from foobo import (fooBO,builder_id as foo_builder_id)
+#   notice difference between "foorbo" (file name) and "fooBO" (class name within that file)
+#
+
+import scustomtkinter_pygubu.sCTkCorebo
+import scustomtkinter_pygubu.sCTkToplevelbo
+
+import scustomtkinter_pygubu.sCTkButtonPrimarybo
+import scustomtkinter_pygubu.sCTkButtonSecondarybo
+import scustomtkinter_pygubu.sCTkButtonTertiarybo
+
+import scustomtkinter_pygubu.sCTkCheckBoxbo
+import scustomtkinter_pygubu.sCTkComboBoxbo
+
+import scustomtkinter_pygubu.sCTkDialbo
+
+import scustomtkinter_pygubu.sCTkDialogbo
+
+import scustomtkinter_pygubu.sCTkEntryPrimarybo
+import scustomtkinter_pygubu.sCTkEntrySecondarybo
+
+import scustomtkinter_pygubu.sCTkFileExplorerbo
+
+import scustomtkinter_pygubu.sCTkFramebo
+
+import scustomtkinter_pygubu.sCTkFrameLabeledPrimarybo
+import scustomtkinter_pygubu.sCTkFrameLabeledSecondarybo
+
+import scustomtkinter_pygubu.sCTkFrequencyDisplaybo
+
+import scustomtkinter_pygubu.sCTkLabelPrimarybo
+import scustomtkinter_pygubu.sCTkLabelSecondarybo
+import scustomtkinter_pygubu.sCTkLabelTertiarybo
+
+import scustomtkinter_pygubu.sCTkNotebookbo
+
+import scustomtkinter_pygubu.sCTkOptionMenuPrimarybo
+import scustomtkinter_pygubu.sCTkOptionMenuSecondarybo
+
+import scustomtkinter_pygubu.sCTkPathChooserbo
+
+import scustomtkinter_pygubu.sCTkProgressBarbo
+
+import scustomtkinter_pygubu.sCTkRadioButtonbo
+
+import scustomtkinter_pygubu.sCTkScrollableFramebo
+
+import scustomtkinter_pygubu.sCTkScrollbarbo
+
+import scustomtkinter_pygubu.sCTkSegmentedButtonbo
+# from sCTkSegmentedButtonbo import (sCTkSegmentedButtonBO, builder_id as sCTkSegmentedButton_builder_id )
+
+import scustomtkinter_pygubu.sCTkSelectorbo
+
+import scustomtkinter_pygubu.sCTkSeparatorbo
+
+import scustomtkinter_pygubu.sCTkSliderbo
+
+import scustomtkinter_pygubu.sCTkSMeterbo
+import scustomtkinter_pygubu.sCTkSMeterBarbo
+
+import scustomtkinter_pygubu.sCTkSpinboxbo
+
+import scustomtkinter_pygubu.sCTkSwitchbo
+
+import scustomtkinter_pygubu.sCTkTabviewbo
+
+import scustomtkinter_pygubu.sCTkTableviewbo
+
+import scustomtkinter_pygubu.sCTkTextboxPrimarybo
+import scustomtkinter_pygubu.sCTkTextboxSecondarybo
+
+
+# import sCTkTreeviewbo         # undecied whether to include
+
+
+class sCTkPlugin(BuilderLoaderPlugin):
+
+    @classmethod
+    def get_uid(cls) -> str:
+        """Return plugin unique ID."""
+        return "scustomtkinter"
+
+    @classmethod
+    def get_dependencies(cls) -> List[str]:
+        """Return a list of required plugins UID."""
+        return ["pygubu_customtkinter"]
+
+    def do_activate(self) -> bool:
+        spec = importlib.util.find_spec("scustomtkinter")
+        return spec is not None
+
+    def get_module_for(self, identifier: str) -> str:
+        # A STRING, not a list.
+        #
+        # pygubu calls this when a class in a .ui file is not already
+        # registered, then hands the result to importlib -- which does
+        # name.startswith("."), so a list raised:
+        #
+        #     AttributeError: 'list' object has no attribute 'startswith'
+        #
+        # It went unnoticed for as long as it did because every widget was
+        # registered by the imports at the top of this file, so the fallback
+        # never ran. The first class to miss that list found it immediately.
+        # get_all_modules() below DOES return a list, which is what the two
+        # were confused with.
+        return "scustomtkinter_pygubu"
+
+    def get_all_modules(self):
+        return ["scustomtkinter_pygubu"]
+
+    def can_load(self, identifier: str) -> bool:
+        return identifier.startswith("scustomtkinter.")
+
+    def get_designer_plugin(self):
+        from scustomtkinter_pygubu.designer.plugin import sCTkDesignerPlugin
+        return sCTkDesignerPlugin()