bec-widgets 3.40.2__tar.gz → 3.40.3__tar.gz

{bec_widgets-3.40.2 → bec_widgets-3.40.3}/CHANGELOG.md

@@ -1,6 +1,17 @@
 # CHANGELOG
 
 
+## v3.40.3 (2026-10-16)
+
+### Bug Fixes
+
+- **dock_area**: Bind deferred splitter callbacks and stop busy polling
+  ([`7ce6bf2`](https://github.com/bec-project/bec_widgets/commit/7ce6bf2a5ab07a566d46e97e8199974f5b667633))
+
+- **dock_area**: Skip superseded deferred layout ratio requests
+  ([`4cfb49f`](https://github.com/bec-project/bec_widgets/commit/4cfb49ff9538415530cd12377650c4957b097769))
+
+
 ## v3.40.2 (2026-10-15)
 
 ### Bug Fixes

{bec_widgets-3.40.2 → bec_widgets-3.40.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bec_widgets
-Version: 3.40.2
+Version: 3.40.3
 Summary: BEC Widgets
 Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec_widgets/issues
 Project-URL: Homepage, https://gitlab.psi.ch/bec/bec_widgets

{bec_widgets-3.40.2 → bec_widgets-3.40.3}/bec_widgets/widgets/containers/dock_area/basic_dock_area.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 import inspect
+import itertools
 from dataclasses import dataclass
 from typing import Any, Callable, Literal, Mapping, Sequence, cast
 
 from bec_lib import bec_logger
 from bec_qthemes import material_icon
-from qtpy.QtCore import QByteArray, QSettings, QSize, Qt, QTimer
+from qtpy.QtCore import QByteArray, QEvent, QObject, QSettings, QSize, Qt, QTimer
 from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QApplication, QDialog, QVBoxLayout, QWidget
 from shiboken6 import isValid
@@ -26,6 +27,11 @@ from bec_widgets.widgets.containers.qt_ads import (
 
 logger = bec_logger.logger
 
+# Dynamic property tagging a splitter with its latest layout-ratio request; deferred applies of
+# older requests compare against it and skip themselves.
+_RATIO_REQUEST_PROPERTY = "_bec_layout_ratio_request"
+_ratio_requests = itertools.count(1)
+
 
 class DockSettingsDialog(QDialog):
     """Generic settings editor shown from dock title bar actions."""
@@ -39,6 +45,60 @@ class DockSettingsDialog(QDialog):
         layout.addWidget(self.prop_editor)
 
 
+class _ResizeWatcher(QObject):
+    """
+    One-shot event filter that runs a callback after the watched widget was resized.
+
+    Used to defer work that needs real geometry (e.g. splitter ratios) without polling the
+    event loop. The watcher is parented to the watched widget, so it dies with it.
+    """
+
+    def __init__(self, target: QWidget, callback: Callable[[], None]):
+        super().__init__(target)
+        self._callback = callback
+        target.installEventFilter(self)
+
+    @classmethod
+    def watch(cls, target: QWidget, callback: Callable[[], None]) -> _ResizeWatcher:
+        """
+        Run ``callback`` once after ``target`` is next resized, replacing a pending watcher.
+
+        Args:
+            target(QWidget): Widget to watch.
+            callback(Callable[[], None]): Called (deferred, bound to ``target``) after the resize.
+
+        Returns:
+            _ResizeWatcher: The new watcher.
+        """
+        cls.cancel_pending(target)
+        return cls(target, callback)
+
+    @classmethod
+    def cancel_pending(cls, target: QWidget) -> None:
+        """
+        Cancel every watcher still waiting for a resize of ``target``.
+
+        Args:
+            target(QWidget): Widget whose pending watchers are cancelled.
+        """
+        for pending in target.findChildren(cls, options=Qt.FindChildOption.FindDirectChildrenOnly):
+            pending.cancel()
+
+    def cancel(self) -> None:
+        """Stop watching and schedule the watcher for deletion."""
+        target = self.parent()
+        if target is not None:
+            target.removeEventFilter(self)
+        self.deleteLater()
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        if event.type() == QEvent.Type.Resize:
+            self.cancel()
+            # Deferred so the widget finishes its own resize handling first.
+            QTimer.singleShot(0, watched, self._callback)
+        return False
+
+
 class DockAreaWidget(BECWidget, QWidget):
     """
     Lightweight dock area that exposes the core Qt ADS docking helpers without any
@@ -690,6 +750,12 @@ class DockAreaWidget(BECWidget, QWidget):
         """
         Apply weight ratios to a splitter once geometry is available.
 
+        The deferred callback is bound to the splitter as context object, so Qt drops it
+        if the splitter is deleted (e.g. by ADS while the layout changes) before it runs.
+        While the splitter has no usable size, the ratios wait for its next resize. Every request
+        tags the splitter, so a deferred apply of an older request skips itself once a newer one
+        for the same splitter exists.
+
         Args:
             splitter(QtAds.CDockSplitter): Target splitter.
             weights(Sequence[float] | Mapping[int | str, float] | None): Weight specification.
@@ -701,7 +767,12 @@ class DockAreaWidget(BECWidget, QWidget):
         if not ratios:
             return
 
+        request = next(_ratio_requests)
+        splitter.setProperty(_RATIO_REQUEST_PROPERTY, request)
+
         def apply():
+            if splitter.property(_RATIO_REQUEST_PROPERTY) != request:
+                return  # superseded by a newer request for this splitter
             count = splitter.count()
             if count != len(ratios):
                 return
@@ -711,7 +782,10 @@ class DockAreaWidget(BECWidget, QWidget):
                 splitter.width() if orientation == Qt.Orientation.Horizontal else splitter.height()
             )
             if total_px <= count:
-                QTimer.singleShot(0, apply)
+                # No usable geometry yet (e.g. the dock area is collapsed to zero size). Retry
+                # when the splitter is resized instead of re-arming a 0 ms timer, which would
+                # busy-poll the event loop for as long as the splitter stays empty.
+                _ResizeWatcher.watch(splitter, apply)
                 return
 
             total = sum(ratios)
@@ -726,7 +800,9 @@ class DockAreaWidget(BECWidget, QWidget):
             for i, weight in enumerate(ratios):
                 splitter.setStretchFactor(i, max(1, int(round(weight * 100))))
 
-        QTimer.singleShot(0, apply)
+        # A retry still waiting for an earlier request's resize must not overwrite these ratios.
+        _ResizeWatcher.cancel_pending(splitter)
+        QTimer.singleShot(0, splitter, apply)
 
     def _normalize_override_keys(
         self,
@@ -1001,8 +1077,11 @@ class DockAreaWidget(BECWidget, QWidget):
             return
 
         def schedule(next_attempt: int):
+            # Bound to the dock: Qt drops the retry if the dock is deleted before it fires.
             QTimer.singleShot(
-                50, lambda: self._apply_floating_state_to_dock(dock, state, attempt=next_attempt)
+                50,
+                dock,
+                lambda: self._apply_floating_state_to_dock(dock, state, attempt=next_attempt),
             )
 
         container = dock.floatingDockContainer()

{bec_widgets-3.40.2 → bec_widgets-3.40.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bec_widgets"
-version = "3.40.2"
+version = "3.40.3"
 description = "BEC Widgets"
 requires-python = ">=3.11"
 classifiers = [