bootstack 0.1.6__tar.gz → 0.1.8__tar.gz

{bootstack-0.1.6/src/bootstack.egg-info → bootstack-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bootstack
-Version: 0.1.6
+Version: 0.1.8
 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.1.6 → bootstack-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bootstack"
-version = "0.1.6"
+version = "0.1.8"
 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.1.6"
+current_version = "0.1.8"
 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.1.6 → bootstack-0.1.8}/src/bootstack/_runtime/utility.py

@@ -30,11 +30,18 @@ def _platform_baseline() -> float:
 
     Tk scaling is measured in pixels-per-point (72 points per inch).
     - Windows/Linux default DPI is 96  → baseline = 96/72 ≈ 1.334
-    - macOS default DPI is 72          → baseline = 72/72 = 1.0
+    - macOS default DPI is 72 on Tk 8.6 → baseline = 72/72 = 1.0
       (Retina pixel-doubling is handled by the OS, not Tk scaling)
+
+    Tk 9 changed Aqua's nominal resolution from 72 to 96 DPI, aligning it with
+    Windows/X11 (#375). The pixel grid is unchanged — only the physical-size
+    claim moved — so the baseline must key off the Tk version, not the platform
+    alone. Keying off platform alone reports ui_scale ~1.333 instead of 1.0 on
+    macOS + Tk 9 and inflates every DPI-derived measurement by a third.
     """
     import platform
-    if platform.system() == 'Darwin':
+    import tkinter
+    if platform.system() == 'Darwin' and tkinter.TkVersion < 9.0:
         return 1.0
     return 1.33398982438864281  # 96 DPI / 72
 
@@ -54,6 +61,11 @@ class _ScalingState:
         """Get the current global scale factor."""
         return cls._scale_factor
 
+    @classmethod
+    def get_baseline(cls) -> float:
+        """Get the platform's nominal Tk scaling (pixels per point)."""
+        return cls._baseline
+
     @classmethod
     def get_ui_scale(cls) -> float:
         """Get the UI scale factor (relative to baseline)."""

bootstack-0.1.8/src/bootstack/_runtime/wheel.py

@@ -0,0 +1,152 @@
+"""Scroll-gesture normalization across Tk 8.6 and Tk 9.
+
+Tk 9 changed the scroll-event contract in two ways that break code written
+against Tk 8.6:
+
+* A precise-delta device — every Apple trackpad, Magic Mouse and Magic
+  Trackpad — now fires `<TouchpadScroll>` and **never** `<MouseWheel>`.
+  Binding only `<MouseWheel>` leaves those devices completely dead.
+* Wheel deltas are normalized to multiples of 120 on every windowing
+  system. On Aqua a notch used to report 1; it now reports 120.
+
+On X11, `<Button-4>`/`<Button-5>` are no longer delivered to scripts at
+all — Tk translates them to `<MouseWheel>` internally.
+
+This module hides all of that behind one vocabulary. Callers ask for the
+sequences to bind, then convert an incoming event to either wheel
+*notches* or precise *pixels*.
+
+Sign convention (matching Tk's own bindings): a positive value means the
+wheel rolled away from the user, i.e. the view should move toward the
+*start* of the content. Callers therefore negate to get a scroll amount.
+"""
+
+from __future__ import annotations
+
+import tkinter as tk
+
+TOUCHPAD_SCROLL = "<TouchpadScroll>"
+"""Sequence for precise-delta scroll gestures. Tk 8.7+ only."""
+
+_WHEEL_UNITS = 120.0
+"""Delta reported for one wheel notch on a normalized (Tk 8.7+) build."""
+
+_TOUCHPAD_TK = 8.7
+"""First Tk release generating `<TouchpadScroll>` and normalized deltas."""
+
+
+def _windowingsystem(widget: tk.Misc) -> str:
+    try:
+        return str(widget.tk.call("tk", "windowingsystem")).lower()
+    except Exception:
+        return ""
+
+
+def has_touchpad_scroll() -> bool:
+    """Whether the running Tk generates `<TouchpadScroll>` events."""
+    return tk.TkVersion >= _TOUCHPAD_TK
+
+
+def uses_x11_buttons(widget: tk.Misc) -> bool:
+    """Whether wheel input arrives as `<Button-4>`/`<Button-5>` here.
+
+    True only on legacy X11 builds. Tk 8.7+ translates those buttons to
+    `<MouseWheel>` and stops delivering them to scripts.
+    """
+    return not has_touchpad_scroll() and _windowingsystem(widget) == "x11"
+
+
+def wheel_sequences(widget: tk.Misc, *, shift: bool = False) -> tuple[str, ...]:
+    """Event sequences carrying wheel notches for `widget`.
+
+    Args:
+        widget: Any widget; used to resolve the windowing system.
+        shift: Request the horizontal (Shift-modified) sequences.
+    """
+    if uses_x11_buttons(widget):
+        if shift:
+            return ("<Shift-Button-4>", "<Shift-Button-5>")
+        return ("<Button-4>", "<Button-5>")
+    return ("<Shift-MouseWheel>",) if shift else ("<MouseWheel>",)
+
+
+def wheel_notches(widget: tk.Misc, event: tk.Event) -> float:
+    """Signed notch count for a wheel event.
+
+    Returns a positive value when the wheel rolled away from the user.
+    One physical notch is 1.0 on every platform and Tk version.
+    """
+    num = getattr(event, "num", None)
+    if num in (4, 6):
+        return 1.0
+    if num in (5, 7):
+        return -1.0
+
+    try:
+        delta = float(event.delta)
+    except (AttributeError, TypeError, ValueError):
+        return 0.0
+    if not delta:
+        return 0.0
+
+    # Tk 8.6 on Aqua reported one notch as 1; everything else uses 120.
+    if not has_touchpad_scroll() and _windowingsystem(widget) == "aqua":
+        return delta
+    return delta / _WHEEL_UNITS
+
+
+def precise_deltas(event: tk.Event) -> tuple[int, int]:
+    """Unpack a `<TouchpadScroll>` event into `(dx, dy)` pixels.
+
+    Tk packs both axes into the delta field as two signed 16-bit values.
+    This mirrors Tcl's `::tk::PreciseScrollDeltas`.
+    """
+    try:
+        packed = int(event.delta)
+    except (AttributeError, TypeError, ValueError):
+        return (0, 0)
+    dx = packed >> 16
+    low = packed & 0xFFFF
+    dy = low if low < 0x8000 else low - 0x10000
+    return (dx, dy)
+
+
+def scale_num(widget: tk.Misc, value: float) -> int:
+    """Scale a pixel amount for display density, like `::tk::ScaleNum`."""
+    try:
+        scaling = float(widget.tk.call("tk", "scaling"))
+    except Exception:
+        scaling = 1.0
+    return round(value * scaling * 0.75)
+
+
+class PixelAccumulator:
+    """Converts precise pixel deltas into whole discrete scroll steps.
+
+    A touchpad reports small deltas roughly sixty times a second. Widgets
+    that scroll by rows or canvas units cannot act on each one, so the
+    fractional remainder is carried forward until it adds up to a step.
+    """
+
+    __slots__ = ("_x", "_y")
+
+    def __init__(self) -> None:
+        self._x = 0.0
+        self._y = 0.0
+
+    def add(self, dx: float, dy: float, step_x: float, step_y: float) -> tuple[int, int]:
+        """Add a delta and return the whole `(x, y)` steps it completes."""
+        step_x = step_x if step_x and step_x > 0 else 1.0
+        step_y = step_y if step_y and step_y > 0 else 1.0
+        self._x += dx
+        self._y += dy
+        out_x = int(self._x / step_x)
+        out_y = int(self._y / step_y)
+        self._x -= out_x * step_x
+        self._y -= out_y * step_y
+        return (out_x, out_y)
+
+    def reset(self) -> None:
+        """Drop any carried remainder."""
+        self._x = 0.0
+        self._y = 0.0

{bootstack-0.1.6 → bootstack-0.1.8}/src/bootstack/style/typography.py

@@ -8,6 +8,8 @@ from tkinter import Misc, font as tkfont
 from tkinter.font import Font as TkFont
 from typing import Any, Literal, NamedTuple
 
+from bootstack._runtime.utility import _ScalingState
+
 
 # =============================================================================
 # Token model
@@ -90,12 +92,19 @@ def build_desktop_tokens(
     elif system == "darwin":
         default_ui = "SF Pro Text"
         default_mono = "Menlo"
-        # Tk's pt-to-pixel conversion uses the active scaling factor.
-        # macOS defaults to 1.0 (72 DPI baseline) vs ~1.334 on Win/Linux,
-        # so the same point size renders ~25% smaller on Mac. Bump the
-        # base to keep visual parity across platforms and align with the
-        # macOS HIG default control text size (13pt).
-        base = _clamp_base_size(base + 2)
+        # Tk's pt-to-pixel conversion uses the active scaling factor. On Tk 8.6
+        # macOS defaults to 1.0 (72 DPI baseline) vs ~1.334 on Win/Linux, so
+        # the same point size renders ~25% smaller on Mac. Bump the base to
+        # align with the macOS HIG default control text size (13pt).
+        #
+        # Tk 9 moved Aqua to a 96 DPI baseline (#375), so a "point" is no
+        # longer the same physical size and the raw bump double-counts (a
+        # `body` label rendered at 20px linespace instead of 16px). The target
+        # is a physical size, so express it in the active point unit: divide by
+        # the baseline ratio. Tk 8.6 -> 13pt (unchanged), Tk 9 -> 10pt, which
+        # is the same rendered size and matches the point size Tk 9 itself
+        # picks for TkDefaultFont.
+        base = _clamp_base_size(round((base + 2) / _ScalingState.get_baseline()))
     else:
         default_ui = "DejaVu Sans"
         default_mono = "DejaVu Sans Mono"

{bootstack-0.1.6 → bootstack-0.1.8}/src/bootstack/widgets/_core/base.py

@@ -355,6 +355,7 @@ class PublicWidgetBase:
                 options.update(_flex_child_opts(self, kwargs))
             master.add_child(self._internal, options, index=index)
             placement.options = options
+            self._recolor_on_attach()
             return
 
         if kwargs:
@@ -376,6 +377,29 @@ class PublicWidgetBase:
             options.update({k: v for k, v in kwargs.items() if k in PLACE_KEYS})
             self._internal.place(in_=master, **options)
         placement.options = options
+        self._recolor_on_attach()
+
+    def _recolor_on_attach(self) -> None:
+        """Recolor after a theme change that arrived while detached.
+
+        The theme walk skips off-screen widgets, so a widget detached across a
+        theme change comes back carrying the old palette. Attaching is the
+        genuine "now visible" trigger, matching PageStack navigation and
+        Expander expansion. Deferred to idle so the widget is mapped first.
+        """
+        widget = self._internal
+
+        def _recolor() -> None:
+            from bootstack.style.style import get_style
+            try:
+                get_style().apply_theme_walk(widget, only_stale=True)
+            except tkinter.TclError:
+                pass  # destroyed between attach and the idle callback
+
+        try:
+            widget.after_idle(_recolor)
+        except tkinter.TclError:
+            pass
 
     @overload
     def on_destroy(self) -> "Stream": ...

{bootstack-0.1.6 → bootstack-0.1.8}/src/bootstack/widgets/_impl/_parts/numberentry_part.py

@@ -6,10 +6,14 @@ wheel support.
 """
 
 
+from bootstack._runtime import wheel
 from bootstack.events import ChangeEvent
 from bootstack.widgets._impl.mixins.configure_mixin import configure_delegate
 from bootstack.widgets._impl._parts.textentry_part import TextEntryPart
 
+_TOUCHPAD_STEP_PX = 40
+"""Trackpad travel, in pixels, that advances a stepper by one increment."""
+
 
 class NumberEntryPart(TextEntryPart):
     """Numeric entry widget with stepping and bounds validation.
@@ -111,12 +115,13 @@ class NumberEntryPart(TextEntryPart):
         self.bind('<Up>', self._handle_up_key, add=True)
         self.bind('<Down>', self._handle_down_key, add=True)
 
-        # Bind mouse wheel (Windows/macOS)
-        self.bind('<MouseWheel>', self._handle_mouse_wheel, add=True)
-
-        # Bind mouse wheel (Linux/X11)
-        self.bind('<Button-4>', self._handle_wheel_up, add=True)
-        self.bind('<Button-5>', self._handle_wheel_down, add=True)
+        # Bind wheel stepping. A wheel arrives as <MouseWheel> everywhere
+        # except legacy X11; a trackpad fires <TouchpadScroll> on Tk 8.7+.
+        for seq in wheel.wheel_sequences(self):
+            self.bind(seq, self._handle_mouse_wheel, add=True)
+        if wheel.has_touchpad_scroll():
+            self._touchpad = wheel.PixelAccumulator()
+            self.bind(wheel.TOUCHPAD_SCROLL, self._handle_touchpad_scroll, add=True)
 
         # Listen for increment/decrement events to invoke step
         self.bind('<<Increment>>', self._handle_increment_event, add=True)
@@ -137,33 +142,28 @@ class NumberEntryPart(TextEntryPart):
         return 'break'  # Prevent default behavior
 
     def _handle_mouse_wheel(self, event):
-        """Handle mouse wheel on Windows/macOS."""
+        """Handle a wheel notch by stepping the value once."""
         if not self._is_interactive():
             return 'break'
-        try:
-            delta = int(event.delta)
-        except (AttributeError, ValueError):
-            delta = 0
-
-        if delta != 0:
-            if delta > 0:
-                self.event_generate('<<Increment>>', data={'value': self._value})
-            else:
-                self.event_generate('<<Decrement>>', data={'value': self._value})
+        notches = wheel.wheel_notches(self, event)
+        if notches:
+            name = '<<Increment>>' if notches > 0 else '<<Decrement>>'
+            self.event_generate(name, data={'value': self._value})
         return 'break'
 
-    def _handle_wheel_up(self, event):
-        """Handle mouse wheel up on Linux/X11."""
-        if not self._is_interactive():
-            return 'break'
-        self.event_generate('<<Increment>>', data={'value': self._value})
-        return 'break'
+    def _handle_touchpad_scroll(self, event):
+        """Step once per `_TOUCHPAD_STEP_PX` of trackpad travel.
 
-    def _handle_wheel_down(self, event):
-        """Handle mouse wheel down on Linux/X11."""
+        A trackpad reports around sixty events a second; stepping on each
+        one would run the value away from the user.
+        """
         if not self._is_interactive():
             return 'break'
-        self.event_generate('<<Decrement>>', data={'value': self._value})
+        _dx, dy = wheel.precise_deltas(event)
+        _sx, steps = self._touchpad.add(0, dy, 1, _TOUCHPAD_STEP_PX)
+        name = '<<Increment>>' if steps > 0 else '<<Decrement>>'
+        for _ in range(abs(steps)):
+            self.event_generate(name, data={'value': self._value})
         return 'break'
 
     def _handle_increment_event(self, event):

{bootstack-0.1.6 → bootstack-0.1.8}/src/bootstack/widgets/_impl/composites/gallery.py

@@ -20,6 +20,7 @@ from PIL import Image as PILImage, ImageDraw
 from PIL.Image import Resampling
 from PIL.ImageTk import PhotoImage
 
+from bootstack._runtime import wheel
 from bootstack.data import MemoryDataSource, DataSourceProtocol
 from bootstack.style.style import get_style
 from bootstack.widgets._impl.composites._image_fit import (
@@ -223,6 +224,7 @@ class Gallery(Frame):
         self._start_row = 0
         self._ring_photo: PhotoImage | None = None
         self._row_h = self._th + 2 * _RING_PAD + (_CAPTION_H if caption_field else 0) + gap
+        self._touchpad = wheel.PixelAccumulator()
 
         sb_surface = getattr(self, '_surface', None)
         sb_kw = {'surface': sb_surface} if sb_surface else {}
@@ -450,22 +452,32 @@ class Gallery(Frame):
         self._update_tiles()
 
     def _bind_scroll(self, widget) -> None:
-        widget.bind("<MouseWheel>", self._on_wheel, add="+")
-        widget.bind("<Button-4>", self._on_wheel, add="+")
-        widget.bind("<Button-5>", self._on_wheel, add="+")
+        for seq in wheel.wheel_sequences(self):
+            widget.bind(seq, self._on_wheel, add="+")
+        if wheel.has_touchpad_scroll():
+            widget.bind(wheel.TOUCHPAD_SCROLL, self._on_touchpad_scroll, add="+")
 
     def _on_wheel(self, event) -> None:
-        if getattr(event, "num", None) == 4:
-            delta = 1
-        elif getattr(event, "num", None) == 5:
-            delta = -1
-        else:
-            delta = 1 if event.delta < 0 else -1
-        self._start_row += delta
+        notches = wheel.wheel_notches(self, event)
+        if not notches:
+            return "break"
+        self._start_row += -1 if notches > 0 else 1
         self._clamp()
         self._update_tiles()
         return "break"
 
+    def _on_touchpad_scroll(self, event) -> None:
+        """Scroll by whole tile rows as a trackpad gesture accumulates pixels."""
+        _dx, dy = wheel.precise_deltas(event)
+        if not dy:
+            return "break"
+        _sx, rows = self._touchpad.add(0, dy, 1, self._row_h or 1)
+        if rows:
+            self._start_row -= rows
+            self._clamp()
+            self._update_tiles()
+        return "break"
+
     def scroll_to_top(self) -> None:
         self._start_row = 0
         self._update_tiles()

{bootstack-0.1.6 → bootstack-0.1.8}/src/bootstack/widgets/_impl/composites/list/listview.py

@@ -5,6 +5,7 @@ from tkinter import TclError
 from typing import Any, Callable, Literal
 from typing_extensions import Unpack
 
+from bootstack._runtime import wheel
 from bootstack.data import MemoryDataSource, DataSourceProtocol
 from bootstack.widgets._impl.composites.list.listitem import ListItem
 from bootstack.widgets._impl.primitives.frame import Frame, FrameKwargs
@@ -87,9 +88,8 @@ class ListView(Frame):
 
         self._accent = _user_accent or 'primary'
 
-        # Cache the windowing system so scroll bindings can dispatch
-        # platform-correctly: Aqua/Win send <MouseWheel>, X11 sends
-        # <Button-4>/<Button-5>.
+        # Cached for the platform branches elsewhere in this widget; scroll
+        # bindings resolve their own sequences through `_runtime.wheel`.
         self.winsys = self.tk.call('tk', 'windowingsystem')
 
         # Configuration
@@ -114,6 +114,7 @@ class ListView(Frame):
         self._prev_start_index = 0
         self._visible_rows = VISIBLE_ROWS
         self._row_height = ROW_HEIGHT
+        self._touchpad = wheel.PixelAccumulator()
         self._page_size = VISIBLE_ROWS + OVERSCAN_ROWS
 
         # Data source
@@ -570,49 +571,62 @@ class ListView(Frame):
     def _bind_scroll_events(self, widget) -> None:
         """Bind the platform-correct scroll-wheel events to `widget`.
 
-        On Aqua/Win the event is `<MouseWheel>` with `event.delta`
-        carrying direction and magnitude. On X11 there's no MouseWheel —
-        scroll up is `<Button-4>` and scroll down is `<Button-5>`.
+        A wheel arrives as `<MouseWheel>` everywhere except legacy X11,
+        where it is `<Button-4>`/`<Button-5>`. A trackpad or other
+        precise-delta device instead fires `<TouchpadScroll>` on Tk 8.7+.
         """
-        if self.winsys.lower() == 'x11':
-            widget.bind('<Button-4>', self._on_mousewheel, add='+')
-            widget.bind('<Button-5>', self._on_mousewheel, add='+')
-        else:
-            widget.bind('<MouseWheel>', self._on_mousewheel, add='+')
-
-    def _on_mousewheel(self, event):
-        """Handle mouse wheel scrolling.
+        for seq in wheel.wheel_sequences(self):
+            widget.bind(seq, self._on_mousewheel, add='+')
+        if wheel.has_touchpad_scroll():
+            widget.bind(wheel.TOUCHPAD_SCROLL, self._on_touchpad_scroll, add='+')
 
-        Args:
-            event: Tkinter mouse wheel event.
-        """
-        # Check if mouse is over this widget
+    def _pointer_within(self, event) -> bool:
+        """Whether the pointer is over this list or one of its descendants."""
         widget_under_mouse = self.winfo_containing(event.x_root, event.y_root)
         if widget_under_mouse is None:
-            return
-
-        # Check if the widget under mouse is a child of this ListView
+            return False
         current = widget_under_mouse
-        is_child = False
         while current is not None:
             if current == self:
-                is_child = True
-                break
+                return True
             try:
                 current = current.master
             except AttributeError:
                 break
+        return False
+
+    def _on_mousewheel(self, event):
+        """Handle mouse wheel scrolling.
 
-        if not is_child:
+        Args:
+            event: Tkinter mouse wheel event.
+        """
+        if not self._pointer_within(event):
             return
 
-        # Resolve scroll direction per platform: X11 carries it in event.num
-        # (4=up, 5=down) and has no event.delta; Aqua/Win use event.delta.
-        if self.winsys.lower() == 'x11':
-            delta = -1 if getattr(event, 'num', 0) == 4 else 1
-        else:
-            delta = -1 if event.delta > 0 else 1
-        self._start_index += delta
+        notches = wheel.wheel_notches(self, event)
+        if not notches:
+            return
+        self._start_index += -1 if notches > 0 else 1
+        self._clamp_indices()
+        self._update_rows()
+
+    def _on_touchpad_scroll(self, event):
+        """Scroll by whole rows as a trackpad gesture accumulates pixels.
+
+        Args:
+            event: Tkinter touchpad scroll event.
+        """
+        if not self._pointer_within(event):
+            return
+
+        _dx, dy = wheel.precise_deltas(event)
+        if not dy:
+            return
+        _sx, rows = self._touchpad.add(0, dy, 1, self._row_height or 1)
+        if not rows:
+            return
+        self._start_index -= rows
         self._clamp_indices()
         self._update_rows()
 

{bootstack-0.1.6 → bootstack-0.1.8}/src/bootstack/widgets/_impl/composites/scrolledtext.py

@@ -6,6 +6,7 @@ from bootstack.widgets._impl.primitives.frame import Frame
 from bootstack.widgets._impl.mixins.configure_mixin import configure_delegate
 from bootstack.widgets._impl.primitives.scrollbar import Scrollbar
 from bootstack.widgets.types import Master
+from bootstack._runtime import wheel
 
 ScrollDirection = Literal['horizontal', 'vertical', 'both']
 ScrollbarVisibility = Literal['always', 'never', 'hover', 'scroll']
@@ -176,14 +177,12 @@ class ScrolledText(Frame):
 
     def _setup_scroll_tag_bindings(self):
         """Setup bindings on our custom bind tag."""
-        if self.winsys.lower() == "x11":
-            self.bind_class(self._scroll_tag, "<Button-4>", self._on_mousewheel)
-            self.bind_class(self._scroll_tag, "<Button-5>", self._on_mousewheel)
-            self.bind_class(self._scroll_tag, "<Shift-Button-4>", self._on_shift_mousewheel)
-            self.bind_class(self._scroll_tag, "<Shift-Button-5>", self._on_shift_mousewheel)
-        else:
-            self.bind_class(self._scroll_tag, "<MouseWheel>", self._on_mousewheel)
-            self.bind_class(self._scroll_tag, "<Shift-MouseWheel>", self._on_shift_mousewheel)
+        for seq in wheel.wheel_sequences(self):
+            self.bind_class(self._scroll_tag, seq, self._on_mousewheel)
+        for seq in wheel.wheel_sequences(self, shift=True):
+            self.bind_class(self._scroll_tag, seq, self._on_shift_mousewheel)
+        if wheel.has_touchpad_scroll():
+            self.bind_class(self._scroll_tag, wheel.TOUCHPAD_SCROLL, self._on_touchpad_scroll)
 
     def _layout_widgets(self):
         """Layout the text widget and scrollbars."""
@@ -265,16 +264,7 @@ class ScrolledText(Frame):
                 self.after_cancel(self._hide_timer)
             self._hide_timer = self.after(self._autohide_delay, self._hide_scrollbars)
 
-        # Calculate delta based on platform
-        delta = 0
-        if self.winsys.lower() == "win32":
-            delta = -int(event.delta / 120)
-        elif self.winsys.lower() == "aqua":
-            delta = -event.delta
-        elif event.num == 4:
-            delta = -1
-        elif event.num == 5:
-            delta = 1
+        delta = -round(wheel.wheel_notches(self, event))
 
         # Scroll vertically
         if self._direction in ('vertical', 'both') and delta != 0:
@@ -289,21 +279,33 @@ class ScrolledText(Frame):
                 self.after_cancel(self._hide_timer)
             self._hide_timer = self.after(self._autohide_delay, self._hide_scrollbars)
 
-        # Calculate delta based on platform
-        delta = 0
-        if self.winsys.lower() == "win32":
-            delta = -int(event.delta / 120)
-        elif self.winsys.lower() == "aqua":
-            delta = -event.delta
-        elif event.num == 4:
-            delta = -1
-        elif event.num == 5:
-            delta = 1
+        delta = -round(wheel.wheel_notches(self, event))
 
         # Scroll horizontally
         if self._direction in ('horizontal', 'both') and delta != 0:
             self._text.xview_scroll(delta, 'units')
 
+    def _on_touchpad_scroll(self, event):
+        """Handle a precise-delta scroll gesture (trackpad).
+
+        A text widget scrolls by pixels directly, so the deltas are spent
+        as they arrive rather than accumulated into whole lines.
+        """
+        dx, dy = wheel.precise_deltas(event)
+        if not dx and not dy:
+            return
+
+        if self._scrollbar_visibility == 'scroll':
+            self._show_scrollbars()
+            if self._hide_timer:
+                self.after_cancel(self._hide_timer)
+            self._hide_timer = self.after(self._autohide_delay, self._hide_scrollbars)
+
+        if dy and self._direction in ('vertical', 'both'):
+            self._text.yview_scroll(wheel.scale_num(self, -dy), 'pixels')
+        if dx and self._direction in ('horizontal', 'both'):
+            self._text.xview_scroll(wheel.scale_num(self, -dx), 'pixels')
+
     def _add_scroll_binding(self, widget):
         """Add scroll bind tag to widget."""
         try:
@@ -325,14 +327,10 @@ class ScrolledText(Frame):
             self._hide_timer = None
 
         # Unbind class bindings for the scroll tag
-        if self.winsys.lower() == "x11":
-            self.unbind_class(self._scroll_tag, "<Button-4>")
-            self.unbind_class(self._scroll_tag, "<Button-5>")
-            self.unbind_class(self._scroll_tag, "<Shift-Button-4>")
-            self.unbind_class(self._scroll_tag, "<Shift-Button-5>")
-        else:
-            self.unbind_class(self._scroll_tag, "<MouseWheel>")
-            self.unbind_class(self._scroll_tag, "<Shift-MouseWheel>")
+        for seq in wheel.wheel_sequences(self) + wheel.wheel_sequences(self, shift=True):
+            self.unbind_class(self._scroll_tag, seq)
+        if wheel.has_touchpad_scroll():
+            self.unbind_class(self._scroll_tag, wheel.TOUCHPAD_SCROLL)
 
         # Call parent destroy
         super().destroy()