Add generic call_method() for remote control API

Add call_method() to enable calling any public panel/window method from macros
and remote clients. Includes intelligent method resolution and thread-safe
execution via signal-based dispatch.

Author: PierreRaybaut

.github/copilot-instructions.md

@@ -337,7 +337,19 @@ proxy.calc("moving_average", sigima.params.MovingAverageParam.create(n=5))
 - `proxy.add_signal()`, `proxy.add_image()`: Create objects
 - `proxy.calc()`: Run processor methods
 - `proxy.get_object()`: Retrieve data
-- `proxy.delete_object()`: Remove objects
+- `proxy.call_method()`: Call any public panel or window method
+
+**Generic Method Calling**:
+```python
+# Remove objects from current panel
+proxy.call_method("remove_object", force=True)
+
+# Call method on specific panel
+proxy.call_method("delete_all_objects", panel="signal")
+
+# Call main window method
+panel_name = proxy.call_method("get_current_panel")
+```
 
 ### 6. Remote Control API
 

datalab/control/baseproxy.py

@@ -519,6 +519,50 @@ def calc(self, name: str, param: gds.DataSet | None = None) -> gds.DataSet:
             ValueError: unknown function
         """
 
+    @abc.abstractmethod
+    def call_method(
+        self,
+        method_name: str,
+        *args,
+        panel: str | None = None,
+        **kwargs,
+    ):
+        """Call a public method on a panel or main window.
+
+        This generic method allows calling any public method that is not explicitly
+        exposed in the proxy API. The method resolution follows this order:
+
+        1. If panel is specified: call method on that specific panel
+        2. If panel is None:
+           a. Try to call method on main window (DLMainWindow)
+           b. If not found, try to call method on current panel (BaseDataPanel)
+
+        This makes it convenient to call panel methods without specifying the panel
+        parameter when working on the current panel.
+
+        Args:
+            method_name: Name of the method to call
+            *args: Positional arguments to pass to the method
+            panel: Panel name ("signal", "image", or None for auto-detection).
+             Defaults to None.
+            **kwargs: Keyword arguments to pass to the method
+
+        Returns:
+            The return value of the called method
+
+        Raises:
+            AttributeError: If the method does not exist or is not public
+            ValueError: If the panel name is invalid
+
+        Examples:
+            >>> # Call remove_object on current panel (auto-detected)
+            >>> proxy.call_method("remove_object", force=True)
+            >>> # Call a signal panel method specifically
+            >>> proxy.call_method("delete_all_objects", panel="signal")
+            >>> # Call main window method
+            >>> proxy.call_method("raise_window")
+        """
+
 
 class BaseProxy(AbstractDLControl, metaclass=abc.ABCMeta):
     """Common base class for DataLab proxies
@@ -790,3 +834,32 @@ def import_macro_from_file(self, filename: str) -> None:
             filename: Filename.
         """
         return self._datalab.import_macro_from_file(filename)
+
+    def call_method(
+        self,
+        method_name: str,
+        *args,
+        panel: str | None = None,
+        **kwargs,
+    ):
+        """Call a public method on a panel or main window.
+
+        Method resolution order when panel is None:
+        1. Try main window (DLMainWindow)
+        2. If not found, try current panel (BaseDataPanel)
+
+        Args:
+            method_name: Name of the method to call
+            *args: Positional arguments to pass to the method
+            panel: Panel name ("signal", "image", or None for auto-detection).
+             Defaults to None.
+            **kwargs: Keyword arguments to pass to the method
+
+        Returns:
+            The return value of the called method
+
+        Raises:
+            AttributeError: If the method does not exist or is not public
+            ValueError: If the panel name is invalid
+        """
+        return self._datalab.call_method(method_name, *args, panel=panel, **kwargs)

datalab/control/remote.py

@@ -89,6 +89,7 @@ class RemoteServer(QC.QThread):
     SIG_RUN_MACRO = QC.Signal(str)
     SIG_STOP_MACRO = QC.Signal(str)
     SIG_IMPORT_MACRO_FROM_FILE = QC.Signal(str)
+    SIG_CALL_METHOD = QC.Signal(str, list, object, dict)
 
     def __init__(self, win: DLMainWindow) -> None:
         QC.QThread.__init__(self)
@@ -120,6 +121,7 @@ def __init__(self, win: DLMainWindow) -> None:
         self.SIG_RUN_MACRO.connect(win.run_macro)
         self.SIG_STOP_MACRO.connect(win.stop_macro)
         self.SIG_IMPORT_MACRO_FROM_FILE.connect(win.import_macro_from_file)
+        self.SIG_CALL_METHOD.connect(win.call_method_slot)
 
     def serve(self) -> None:
         """Start server and serve forever"""
@@ -635,6 +637,38 @@ def import_macro_from_file(self, filename: str) -> None:
         """
         self.SIG_IMPORT_MACRO_FROM_FILE.emit(filename)
 
+    @remote_call
+    def call_method(
+        self,
+        method_name: str,
+        call_params: dict,
+    ):
+        """Call a public method on a panel or main window.
+
+        Method resolution order when panel is None:
+        1. Try main window (DLMainWindow)
+        2. If not found, try current panel (BaseDataPanel)
+
+        Args:
+            method_name: Name of the method to call
+            call_params: Dictionary with keys 'args' (list), 'panel' (str|None),
+             'kwargs' (dict). Defaults to empty for missing keys.
+
+        Returns:
+            The return value of the called method
+
+        Raises:
+            AttributeError: If the method does not exist or is not public
+            ValueError: If the panel name is invalid
+
+        """
+        args = call_params.get("args", [])
+        panel = call_params.get("panel")
+        kwargs = call_params.get("kwargs", {})
+        self.result = None
+        self.SIG_CALL_METHOD.emit(method_name, args, panel, kwargs)
+        return self.result
+
 
 RemoteServer.check_remote_functions()
 
@@ -1014,3 +1048,39 @@ def add_annotations_from_items(
         items_json = items_to_json(items)
         if items_json is not None:
             self._datalab.add_annotations_from_items(items_json, refresh_plot, panel)
+
+    def call_method(
+        self,
+        method_name: str,
+        *args,
+        panel: str | None = None,
+        **kwargs,
+    ):
+        """Call a public method on a panel or main window.
+
+        Method resolution order when panel is None:
+        1. Try main window (DLMainWindow)
+        2. If not found, try current panel (BaseDataPanel)
+
+        Args:
+            method_name: Name of the method to call
+            *args: Positional arguments to pass to the method
+            panel: Panel name ("signal", "image", or None for auto-detection).
+             Defaults to None.
+            **kwargs: Keyword arguments to pass to the method
+
+        Returns:
+            The return value of the called method
+
+        Raises:
+            AttributeError: If the method does not exist or is not public
+            ValueError: If the panel name is invalid
+        """
+        # Convert args/kwargs to single dict for XML-RPC serialization
+        # This avoids XML-RPC signature mismatch issues with default parameters
+        call_params = {
+            "args": list(args) if args else [],
+            "panel": panel,
+            "kwargs": dict(kwargs) if kwargs else {},
+        }
+        return self._datalab.call_method(method_name, call_params)

datalab/gui/main.py

@@ -448,6 +448,109 @@ def delete_metadata(
         panel = self.__get_current_basedatapanel()
         panel.delete_metadata(refresh_plot, keep_roi)
 
+    @remote_controlled
+    def call_method(
+        self,
+        method_name: str,
+        *args,
+        panel: Literal["signal", "image"] | None = None,
+        **kwargs,
+    ):
+        """Call a public method on a panel or main window.
+
+        This generic method allows calling any public method that is not explicitly
+        exposed in the proxy API. The method resolution follows this order:
+
+        1. If panel is specified: call method on that specific panel
+        2. If panel is None:
+           a. Try to call method on main window (DLMainWindow)
+           b. If not found, try to call method on current panel (BaseDataPanel)
+
+        This makes it convenient to call panel methods without specifying the panel
+        parameter when working on the current panel.
+
+        Args:
+            method_name: Name of the method to call
+            *args: Positional arguments to pass to the method
+            panel: Panel name ("signal", "image", or None for auto-detection).
+             Defaults to None.
+            **kwargs: Keyword arguments to pass to the method
+
+        Returns:
+            The return value of the called method
+
+        Raises:
+            AttributeError: If the method does not exist or is not public
+            ValueError: If the panel name is invalid
+
+        Examples:
+            >>> # Call remove_object on current panel (auto-detected)
+            >>> win.call_method("remove_object", force=True)
+            >>> # Call a signal panel method specifically
+            >>> win.call_method("delete_all_objects", panel="signal")
+            >>> # Call main window method
+            >>> win.call_method("get_current_panel")
+        """
+        # Security check: only allow public methods (not starting with _)
+        if method_name.startswith("_"):
+            raise AttributeError(
+                f"Cannot call private method '{method_name}' through proxy"
+            )
+
+        # If panel is specified, use that panel directly
+        if panel is not None:
+            target = self.__get_datapanel(panel)
+            if not hasattr(target, method_name):
+                raise AttributeError(
+                    f"Method '{method_name}' does not exist on {panel} panel"
+                )
+            method = getattr(target, method_name)
+            if not callable(method):
+                raise AttributeError(f"'{method_name}' is not a callable method")
+            return method(*args, **kwargs)
+
+        # Panel is None: try main window first, then current panel
+        # Try main window first
+        if hasattr(self, method_name):
+            method = getattr(self, method_name)
+            if callable(method):
+                return method(*args, **kwargs)
+
+        # Method not found on main window, try current panel
+        current_panel = self.__get_current_basedatapanel()
+        if hasattr(current_panel, method_name):
+            method = getattr(current_panel, method_name)
+            if callable(method):
+                return method(*args, **kwargs)
+
+        # Method not found anywhere
+        raise AttributeError(
+            f"Method '{method_name}' does not exist on main window or current panel"
+        )
+
+    def call_method_slot(
+        self,
+        method_name: str,
+        args: list,
+        panel: Literal["signal", "image"] | None,
+        kwargs: dict,
+    ) -> None:
+        """Slot to call a method from RemoteServer thread in GUI thread.
+
+        This slot receives signals from RemoteServer and executes the method in
+        the GUI thread, avoiding thread-safety issues with Qt widgets and dialogs.
+
+        Args:
+            method_name: Name of the method to call
+            args: Positional arguments as a list
+            panel: Panel name or None for auto-detection
+            kwargs: Keyword arguments as a dict
+        """
+        # Call the method and store result in RemoteServer
+        result = self.call_method(method_name, *args, panel=panel, **kwargs)
+        # Store result in RemoteServer for retrieval by XML-RPC thread
+        self.remote_server.result = result
+
     @remote_controlled
     def get_object_shapes(
         self,