Adds object binding with change watching support

Author: Licini

src/compas_viewer/components/boundcomponent.py

@@ -21,6 +21,9 @@ class BoundComponent(Component):
         The name of the attribute/key to be bound.
     action : Callable[[Component, float], None]
         A function to call when the value changes. Receives the component and new value.
+    watch_interval : int, optional
+        Interval in milliseconds to check for changes in the bound object.
+        If None, watching is disabled. Default is 100.
 
     Attributes
     ----------
@@ -30,6 +33,12 @@ class BoundComponent(Component):
         The name of the attribute/key being bound.
     action : Callable[[Component, float], None]
         The action function to call when the value changes.
+    watch_interval : int or None
+        The watching interval in milliseconds, or None if watching is disabled. Default is 100.
+    _watch_timer : Timer or None
+        The timer used for watching changes in the bound object.
+    _last_watched_value : Any
+        The last known value of the bound attribute from watching.
 
     Example
     -------
@@ -39,17 +48,28 @@ class BoundComponent(Component):
     >>> def my_action(component, value):
     ...     print(f"Value changed to: {value}")
     >>> obj = MyObject()
+    >>> # Component with default watcher (100ms)
     >>> component = BoundComponent(obj, "value", my_action)
-    >>> component.set_attr(20.0)
-    >>> print(component.get_attr())  # prints 20.0
+    >>> # Component without watcher
+    >>> component = BoundComponent(obj, "value", my_action, watch_interval=None)
+    >>> # Component with custom watcher interval
+    >>> component = BoundComponent(obj, "value", my_action, watch_interval=200)
     """
 
-    def __init__(self, obj: Union[object, dict], attr: str, action: Callable[[Component, float], None]):
+    def __init__(self, obj: Union[object, dict], attr: str, action: Callable[[Component, float], None], watch_interval: int = 100):
         super().__init__()
 
         self.obj = obj
         self.attr = attr
         self.action = action
+        self.watch_interval = watch_interval
+        self._watch_timer = None
+        self._last_watched_value = None
+        self._updating_from_watch = False
+
+        # Start watching if interval is provided
+        if self.watch_interval is not None:
+            self.start_watching()
 
     def get_attr(self):
         """
@@ -98,3 +118,86 @@ def on_value_changed(self, value: Any):
         self.set_attr(value)
         if self.action is not None:
             self.action(self, value)
+
+    def start_watching(self):
+        """
+        Start watching the bound object for changes.
+
+        This method starts a timer that periodically checks if the bound attribute
+        has changed and updates the component accordingly.
+        """
+        if self.watch_interval is None:
+            return
+
+        if self._watch_timer is not None:
+            self.stop_watching()
+
+        from compas_viewer.timer import Timer
+
+        self._last_watched_value = self.get_attr()
+        self._watch_timer = Timer(self.watch_interval, self._check_for_changes)
+
+    def stop_watching(self):
+        """
+        Stop watching the bound object for changes.
+        """
+        if self._watch_timer is not None:
+            self._watch_timer.stop()
+            self._watch_timer = None
+
+    def _check_for_changes(self):
+        """
+        Check if the bound attribute has changed and update the component if needed.
+
+        This method is called periodically by the watch timer.
+        """
+        if self._updating_from_watch:
+            return
+
+        # Skip checking if widget is not visible to save resources
+        if not self.widget.isVisible():
+            return
+
+        current_value = self.get_attr()
+        if current_value != self._last_watched_value:
+            self._last_watched_value = current_value
+            self._updating_from_watch = True
+            try:
+                print("sync from bound object", self.obj, self.attr)
+                self.sync_from_bound_object(current_value)
+            finally:
+                self._updating_from_watch = False
+
+    def sync_from_bound_object(self, value: Any):
+        """
+        Sync the component's display with the bound object's value.
+
+        This method should be overridden by subclasses to update their
+        specific UI elements when the bound object changes.
+
+        Parameters
+        ----------
+        value : Any
+            The new value from the bound object.
+        """
+        # Base implementation does nothing - subclasses should override
+        pass
+
+    def set_watch_interval(self, interval: int):
+        """
+        Set or change the watch interval.
+
+        Parameters
+        ----------
+        interval : int or None
+            The new interval in milliseconds, or None to disable watching.
+        """
+        was_watching = self._watch_timer is not None
+
+        if was_watching:
+            self.stop_watching()
+
+        self.watch_interval = interval
+
+        if interval is not None:
+            self.start_watching()

src/compas_viewer/components/numberedit.py

@@ -34,6 +34,11 @@ class NumberEdit(BoundComponent):
         The number of decimal places to display. Defaults to 1.
     action : Callable[[Component, float], None], optional
         A function to call when the value changes. Receives the component and new value.
+    **kwargs
+        Additional keyword arguments passed to BoundComponent, including:
+        - watch_interval : int, optional
+            Interval in milliseconds to check for changes in the bound object.
+            If None, watching is disabled. Default is 100.
 
     Attributes
     ----------
@@ -58,7 +63,10 @@ class NumberEdit(BoundComponent):
     ...     def __init__(self):
     ...         self.x = 5.0
     >>> obj = MyObject()
+    >>> # Component with default watcher (100ms)
     >>> component = NumberEdit(obj, "x", title="X Coordinate", min_val=0.0, max_val=10.0)
+    >>> # Component without watcher
+    >>> component = NumberEdit(obj, "x", title="X Coordinate", min_val=0.0, max_val=10.0, watch_interval=None)
     """
 
     def __init__(
@@ -71,8 +79,9 @@ def __init__(
         step: float = 0.1,
         decimals: int = 1,
         action: Callable[[Component, float], None] = None,
+        **kwargs,
     ):
-        super().__init__(obj, attr, action=action)
+        super().__init__(obj, attr, action=action, **kwargs)
 
         self.widget = QWidget()
         self.layout = QHBoxLayout()
@@ -99,3 +108,22 @@ def __init__(
         self.layout.addWidget(self.spinbox)
         self.widget.setLayout(self.layout)
         self.spinbox.valueChanged.connect(self.on_value_changed)
+
+    def sync_from_bound_object(self, value: float):
+        """
+        Sync the spinbox value with the bound object's value.
+
+        This method is called when the bound object's value changes externally.
+
+        Parameters
+        ----------
+        value : float
+            The new value from the bound object.
+        """
+        # Temporarily disconnect the signal to prevent infinite loops
+        self.spinbox.valueChanged.disconnect(self.on_value_changed)
+        try:
+            self.spinbox.setValue(value)
+        finally:
+            # Reconnect the signal
+            self.spinbox.valueChanged.connect(self.on_value_changed)

src/compas_viewer/components/slider.py

@@ -42,6 +42,11 @@ class Slider(BoundComponent):
         Interval between tick marks. No ticks if None. Defaults to None.
     action : Callable[[Component, float], None], optional
         A function to call when the value changes. Receives the component and new value.
+    **kwargs
+        Additional keyword arguments passed to BoundComponent, including:
+        - watch_interval : int, optional
+            Interval in milliseconds to check for changes in the bound object.
+            If None, watching is disabled. Default is 100.
 
     Attributes
     ----------
@@ -96,8 +101,9 @@ def __init__(
         step: float = 1,
         tick_interval: Optional[float] = None,
         action: Callable[[Component, float], None] = None,
+        **kwargs,
     ):
-        super().__init__(obj, attr, action=action)
+        super().__init__(obj, attr, action=action, **kwargs)
 
         self.title = title if title is not None else (attr if attr is not None else "Value")
         self.min_val = min_val
@@ -196,3 +202,28 @@ def on_text_changed(self):
         except ValueError:
             pass  # Handle cases where the text is not a valid number
         self._updating = False
+
+    def sync_from_bound_object(self, value: float):
+        """
+        Sync the slider and text input with the bound object's value.
+
+        This method is called when the bound object's value changes externally.
+
+        Parameters
+        ----------
+        value : float
+            The new value from the bound object.
+        """
+        if self._updating:
+            return
+
+        self._updating = True
+        try:
+            # Clamp value to valid range
+            clamped_value = max(self.min_val, min(self.max_val, value))
+
+            # Update both the slider and the text input
+            self.slider.setValue(self._scale_value(clamped_value))
+            self.line_edit.setText(str(clamped_value))
+        finally:
+            self._updating = False