bootstack 0.2.1__tar.gz → 0.2.3__tar.gz

bootstack-0.2.3/NOTICE

@@ -0,0 +1,30 @@
+bootstack
+Copyright (c) 2021 - 2026 Israel Dryer
+
+This project is derived from ttkbootstrap
+(https://github.com/israel-dryer/ttkbootstrap),
+Copyright (c) 2021 - 2026 Israel Dryer and ttkbootstrap contributors,
+licensed under the MIT License.
+
+The original ttkbootstrap license and copyright notice are preserved above
+in compliance with the MIT License terms.
+
+This project also contains code derived from IDLE, part of the CPython
+standard library (https://github.com/python/cpython),
+Copyright (c) 2001-2023 Python Software Foundation; All Rights Reserved,
+licensed under the Python Software Foundation License Agreement, Version 2.
+
+  src/bootstack/widgets/_impl/composites/textarea/redirector.py
+
+is a port of idlelib/redirector.py, carrying its WidgetRedirector and
+OriginalCommand classes and their dispatch logic. Summary of the changes made,
+as the Python Software Foundation License Agreement asks for: the
+OriginalCommand interface was narrowed to three private attributes,
+WidgetRedirector.__repr__ was dropped, the operation name is coerced to a
+string before lookup, the widget reference is retained after close() rather
+than deleted, and type hints and rewritten documentation were added.
+
+Other modules in the same package implement designs described in IDLE — the
+Delegator and Percolator chain, UndoDelegator, the editor sidebar, and
+parenmatch's flash-and-restore highlighting — but share no substantial code
+with it and are original implementations.

{bootstack-0.2.1/src/bootstack.egg-info → bootstack-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bootstack
-Version: 0.2.1
+Version: 0.2.3
 Summary: Build desktop GUI apps in pure Python and ship them as a standalone executable — built on Tk, no Tkinter boilerplate.
 Author-email: Israel Dryer <israel.dryer@gmail.com>
 License-Expression: MIT

{bootstack-0.2.1 → bootstack-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bootstack"
-version = "0.2.1"
+version = "0.2.3"
 description = "Build desktop GUI apps in pure Python and ship them as a standalone executable — built on Tk, no Tkinter boilerplate."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -114,7 +114,7 @@ where = ["src"]
 ]
 
 [tool.bumpversion]
-current_version = "0.2.1"
+current_version = "0.2.3"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)((?P<pre>a|b|rc)(?P<pre_n>\\d+))?"
 serialize = [
     "{major}.{minor}.{patch}{pre}{pre_n}",

{bootstack-0.2.1 → bootstack-0.2.3}/src/bootstack/widgets/_core/base.py

@@ -282,7 +282,9 @@ class PublicWidgetBase:
         Example:
             .. code-block:: python
 
-               widget.emit("change", data=bs.events.ChangeEvent(value=new_value))
+               from bootstack.events import ChangeEvent
+
+               field.emit("change", data=ChangeEvent(value=new_value))
         """
         sequence = resolve_event(self, str(event))
 

{bootstack-0.2.1 → bootstack-0.2.3}/src/bootstack/widgets/_impl/composites/tableview/tableview.py

@@ -29,7 +29,7 @@ from bootstack.style.style import get_style
 from bootstack.data.sqlite_source import SqliteDataSource
 from bootstack.data.query import col, any_of, all_of
 from bootstack.widgets._impl.primitives.button import Button
-from bootstack._runtime.utility import bind_right_click
+from bootstack._runtime.utility import bind_right_click, debug_log_exception
 from bootstack.widgets._impl.composites.contextmenu import ContextMenu
 from bootstack.widgets._impl.composites.tooltip import ToolTip
 from bootstack.widgets._impl.composites.dropdownbutton import DropdownButton
@@ -1148,8 +1148,8 @@ class TableView(Frame):
         self._tree.bind("<Button-1>", self._on_header_click)
         self._tree.bind("<<TreeviewSelect>>", self._on_selection_event)
         # Keep group-header chevrons in sync with their open/closed state.
-        self._tree.bind("<<TreeviewOpen>>", self._refresh_group_chevrons, add="+")
-        self._tree.bind("<<TreeviewClose>>", self._refresh_group_chevrons, add="+")
+        self._tree.bind("<<TreeviewOpen>>", self._refresh_group_chevrons_deferred, add="+")
+        self._tree.bind("<<TreeviewClose>>", self._refresh_group_chevrons_deferred, add="+")
         self._tree.bind("<ButtonRelease-1>", self._on_row_click_event)
         # Escape clears the selection (also reachable in single-select mode, where
         # clicking can't return to an empty selection). Bound on the tree widget
@@ -1158,8 +1158,10 @@ class TableView(Frame):
         self._tree.bind("<Escape>", lambda _e: self.deselect_all(), add="+")
         if self._context_menus != "none":
             bind_right_click(self._tree, self._on_tree_context)
-        if self._editing['updating']:
-            self._tree.bind("<Double-1>", self._on_row_double_click)
+        # Bound unconditionally: `on_row_double_click` is public API and does not
+        # depend on editing. The handler itself gates the built-in edit dialog on
+        # `_editing['updating']`, so editing behavior is unchanged.
+        self._tree.bind("<Double-1>", self._on_row_double_click)
         # Track resize events to rebalance grouped layouts
         self._tree.bind("<Configure>", self._on_tree_configure)
 
@@ -1690,9 +1692,12 @@ class TableView(Frame):
             col_idx = 0
         # Right-click does not alter the selection (left-click owns that); it
         # only records which row the menu targets and opens the menu there.
-        self._context_iid = iid or None
-        if not iid:
+        # A group header is a real tree item but holds no record — it is absent
+        # from `_row_map` — so it targets nothing, exactly like empty space.
+        if not iid or iid not in self._row_map:
+            self._context_iid = None
             return  # empty space or a group-header row — no row menu
+        self._context_iid = iid
         rec = self._row_map.get(iid, {})
         self.event_generate("<<RowRightClick>>", data=RowEvent(record=self._public_record(rec), id=self._record_id(rec)))
         self._row_menu_col = col_idx
@@ -1704,8 +1709,8 @@ class TableView(Frame):
         if region == "heading":
             return
         iid = self._tree.identify_row(event.y)
-        if not iid:
-            return
+        if not iid or iid not in self._row_map:
+            return  # empty space or a group-header row (no record)
         rec = self._row_map.get(iid, {})
         self.event_generate("<<RowDoubleClick>>", data=RowEvent(record=self._public_record(rec), id=self._record_id(rec)))
         if self._editing['updating']:
@@ -2343,6 +2348,19 @@ class TableView(Frame):
         except Exception:
             pass
 
+    def _refresh_group_chevrons_deferred(self, _event=None) -> None:
+        """Refresh chevrons once Tk has applied the item's new open state.
+
+        The toolkit reports an expand *before* it records it, so reading the
+        state inside the notification paints the previous chevron. Deferring to
+        the next idle point reads the settled state. Scheduled on the root so
+        the pending callback outlives any widget being torn down.
+        """
+        try:
+            self._root().after_idle(self._refresh_group_chevrons)
+        except Exception:
+            pass
+
     def _refresh_group_chevrons(self, _event=None) -> None:
         """Sync every group header's chevron to its current open/closed state."""
         if not self._group_by_key:
@@ -2845,6 +2863,23 @@ class TableView(Frame):
         """
         return self._selection_markers_active()
 
+    def _take_click_focus(self, iid) -> None:
+        """Give the body keyboard focus, and point it at the clicked row.
+
+        Both branches that call this answer the click themselves and stop it,
+        which also stops the built-in handling that would otherwise have done
+        this. Without it a click leaves the keyboard aimed somewhere else, so
+        the row the user just clicked is not the row the arrow keys move from.
+        """
+        try:
+            self._tree.focus_set()
+            if iid:
+                self._tree.focus(iid)
+        except Exception:
+            # Silence here would restore the very bug this method exists to
+            # fix, with nothing to show for it on any channel.
+            debug_log_exception("could not move keyboard focus to the clicked row")
+
     def _on_header_click(self, event):
         """Handle left-click: header sorting, or toggle-select with checkboxes."""
         # A left-click on the tree dismisses an open context menu. Do it
@@ -2873,20 +2908,25 @@ class TableView(Frame):
         # fall through to normal selection below.
         iid = self._tree.identify_row(event.y)
         if iid and self._tree.get_children(iid):
+            self._take_click_focus(iid)
             self._toggle_group_open(iid)
             return "break"
 
         # Body click with checkboxes showing: treat the list like a checklist —
         # a plain click toggles the row in/out of the selection (no modifier),
         # and "break" suppresses ttk's default replace-the-selection behavior.
+        # Only a click that lands on a row earns that "break" — a click on a
+        # column separator reports no row, and stopping it there would kill the
+        # drag that resizes the column.
         if self._toggle_select_active():
             iid = self._tree.identify_row(event.y)
             if iid:
+                self._take_click_focus(iid)
                 if iid in self._tree.selection():
                     self._tree.selection_remove(iid)
                 else:
                     self._tree.selection_add(iid)
-            return "break"
+                return "break"
         return None
 
     def _filter_header_column(self) -> None:

{bootstack-0.2.1 → bootstack-0.2.3}/src/bootstack/widgets/_impl/composites/textarea/filter.py

@@ -12,7 +12,9 @@ which are clean Python callables, not raw Tcl strings.
 from __future__ import annotations
 
 import tkinter as tk
-from idlelib.redirector import WidgetRedirector
+from bootstack.widgets._impl.composites.textarea.redirector import (
+    WidgetRedirector,
+)
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:

bootstack-0.2.3/src/bootstack/widgets/_impl/composites/textarea/redirector.py

@@ -0,0 +1,138 @@
+"""Tk command interception for the edit filter chain.
+
+Port of IDLE's `idlelib/redirector.py`. The rest of this package already ports
+that design rather than importing it — `filter.py` adapts Delegator and
+Percolator, `undo.py` adapts UndoDelegator, `sidebar.py` and
+`extensions/line_numbers.py` port the sidebar — and this was the one piece left
+as a live import. `idlelib` is standard library, but not every Python build
+ships it, so that import made the whole framework unimportable on those builds
+rather than degrading the code editor.
+
+A Tk widget is backed by a Tcl command named after the widget's path, and every
+operation on the widget goes through it — including the ones Tk's own key
+bindings perform, which never reach Python at all. Renaming that command and
+putting a dispatcher in its place is what lets the filter chain see an insert
+that came from a keystroke, which is the whole reason this exists.
+"""
+from __future__ import annotations
+
+import tkinter as tk
+from typing import Any, Callable
+
+
+class WidgetRedirector:
+    """Intercepts operations on a Tk widget, including the toolkit's own.
+
+    Renames the widget's Tcl command out of the way and installs a dispatcher
+    under the original name. Registered operations are routed to a Python
+    callable; everything else passes straight through to the renamed command.
+
+    Only one redirector can exist for a given widget — the rename fails once
+    the name it renames to is taken.
+
+    Args:
+        widget: The widget whose operations are to be intercepted.
+    """
+
+    def __init__(self, widget: tk.Misc) -> None:
+        self._operations: dict[str, Callable[..., Any]] = {}
+        self.widget = widget
+        self.tk = widget.tk
+        path = widget._w
+        self.orig = path + "_orig"
+        self.tk.call("rename", path, self.orig)
+        self.tk.createcommand(path, self.dispatch)
+
+    def register(
+        self, operation: str, function: Callable[..., Any]
+    ) -> OriginalCommand:
+        """Route `operation` to `function`, returning a way to call the original.
+
+        The function is also set on the widget, so a call written in Python —
+        `text.insert(...)` — is intercepted the same way a keystroke is.
+        Registering a second function for the same operation replaces the first
+        in both places.
+
+        Args:
+            operation: Name of the widget operation, such as `insert`.
+            function: What to call in its place. It receives the operation's
+                arguments, and is handed the returned callable to pass the call
+                on with.
+        """
+        self._operations[operation] = function
+        setattr(self.widget, operation, function)
+        return OriginalCommand(self, operation)
+
+    def unregister(self, operation: str) -> Callable[..., Any] | None:
+        """Stop routing `operation`, returning whatever was handling it.
+
+        Returns None if the operation was not registered. Dropping the widget
+        attribute that `register` set unmasks the widget's own method again.
+
+        Args:
+            operation: Name of the widget operation to stop intercepting.
+        """
+        function = self._operations.pop(operation, None)
+        if function is None:
+            return None
+        try:
+            delattr(self.widget, operation)
+        except AttributeError:
+            pass
+        return function
+
+    def dispatch(self, operation, *args):
+        """Handle one call to the widget, invoked from Tcl.
+
+        A registered operation goes to its function and does not continue on to
+        the widget — the function decides whether to pass the call along, using
+        the callable it was given at registration. Everything else goes
+        straight through.
+
+        Args:
+            operation: The operation being performed. Tcl may hand this over as
+                its own object type rather than a string.
+            args: The operation's arguments, exactly as Tcl passed them.
+        """
+        operation = str(operation)
+        function = self._operations.get(operation)
+        try:
+            if function is not None:
+                return function(*args)
+            return self.tk.call((self.orig, operation) + args)
+        except tk.TclError:
+            # What the toolkit itself does with a failed widget command. The
+            # caller here is Tcl, which has nowhere useful to put an exception.
+            return ""
+
+    def close(self) -> None:
+        """Undo the interception and restore the widget's own Tcl command."""
+        for operation in list(self._operations):
+            self.unregister(operation)
+        path = self.widget._w
+        self.tk.deletecommand(path)
+        self.tk.call("rename", self.orig, path)
+
+
+class OriginalCommand:
+    """The widget operation a redirector displaced, as a plain callable.
+
+    Returned by `WidgetRedirector.register` so a registered function can pass
+    the call on to the widget after inspecting or changing it. Calling this
+    reaches the widget directly and does not re-enter the chain.
+
+    Args:
+        redirector: The redirector that displaced the operation.
+        operation: Name of the displaced operation.
+    """
+
+    def __init__(self, redirector: WidgetRedirector, operation: str) -> None:
+        self._operation = operation
+        self._call = redirector.tk.call
+        self._target = (redirector.orig, operation)
+
+    def __call__(self, *args):
+        return self._call(self._target + args)
+
+    def __repr__(self) -> str:
+        return f"OriginalCommand({self._operation!r})"

{bootstack-0.2.1 → bootstack-0.2.3/src/bootstack.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bootstack
-Version: 0.2.1
+Version: 0.2.3
 Summary: Build desktop GUI apps in pure Python and ship them as a standalone executable — built on Tk, no Tkinter boilerplate.
 Author-email: Israel Dryer <israel.dryer@gmail.com>
 License-Expression: MIT

{bootstack-0.2.1 → bootstack-0.2.3}/src/bootstack.egg-info/SOURCES.txt

@@ -426,6 +426,7 @@ src/bootstack/widgets/_impl/composites/textarea/core.py
 src/bootstack/widgets/_impl/composites/textarea/decoration.py
 src/bootstack/widgets/_impl/composites/textarea/diff.py
 src/bootstack/widgets/_impl/composites/textarea/filter.py
+src/bootstack/widgets/_impl/composites/textarea/redirector.py
 src/bootstack/widgets/_impl/composites/textarea/search_overlay.py
 src/bootstack/widgets/_impl/composites/textarea/sidebar.py
 src/bootstack/widgets/_impl/composites/textarea/style_registry.py

bootstack-0.2.1/NOTICE

@@ -1,10 +0,0 @@
-bootstack
-Copyright (c) 2021 - 2026 Israel Dryer
-
-This project is derived from ttkbootstrap
-(https://github.com/israel-dryer/ttkbootstrap),
-Copyright (c) 2021 - 2026 Israel Dryer and ttkbootstrap contributors,
-licensed under the MIT License.
-
-The original ttkbootstrap license and copyright notice are preserved above
-in compliance with the MIT License terms.