fix: make main() function working, to be able to test out of Qt Designer

Inheriting from QTreeWidget causes havoc with display (see #245),
also it is important to parent items OR to give them a label (weird)
otherwise it also has display glitches.

Most of the time, composition has to be preferred over inheritance ;
inheritance is a question of behaviour - is the behaviour the same ?
Here, a widget is really not a BECConnector, but uses a BECConnector
(at least this is my understanding). Because a Widget and BECConnector
do not behave the same. It is easier, lighter to deal with single
inheritance.

The singleton usage is superfluous, since the underlying client is already
a singleton. Multiple BECConnector objects can be created, there won't
be more connections.

BECServiceStatusMixin has been removed in favor of the widget's own timer,
since it was causing "QObject::killTimer: Timers cannot be stopped from
another thread" errors (at least on my computer).

Also removes "redundant items check" ; where do those would come from?

CHANGELOG.md

@@ -1,5 +1,109 @@
 # CHANGELOG
 
+## v0.79.1 (2024-07-03)
+
+### Fix
+
+* fix: use libdir env var to preload Python library, also for Linux platform ([`d7718d4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d7718d4dcb9728c050b6421388af4d484f3741f2))
+
+## v0.79.0 (2024-07-03)
+
+### Feature
+
+* feat(motor_map_widget): standalone MotorMap Widget with toolbar + plugin ([`6e75642`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6e756420907d7093557e945bc92bc4cfc0138d07))
+
+* feat(motor_map): method to reset history trace ([`5960918`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5960918137dd41cdeb94e50f8abc4f169cf45c11))
+
+### Fix
+
+* fix(toolbar): change default color to black to match BECFigure theme ([`b8774e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b8774e0b0bc43dcd00f94f42539a778e507ca27d))
+
+* fix(motor_map): fixed bug with residual trace after changing motors ([`aaa0d10`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/aaa0d1003d2e94b45bafe4f700852c2c05288aea))
+
+* fix(widget_io): widget handler adjusted for spinboxes and comboboxes ([`3dc0532`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3dc0532df05b6ec0a2522107fa0b1e210ce7d91b))
+
+### Refactor
+
+* refactor(toolbar): cleanup and adjusted colors ([`96863ad`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/96863adf53c15112645d20eb6200733617801c6d))
+
+## v0.78.1 (2024-07-02)
+
+### Fix
+
+* fix(ui_loader): ui loader is compatible with bec plugins ([`b787759`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b787759f44486dc7af2c03811efb156041e4b6cb))
+
+## v0.78.0 (2024-07-02)
+
+### Feature
+
+* feat(color_button): patched ColorButton from pyqtgraph to be able to be opened in another QDialog ([`c36bb80`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c36bb80d6a4939802a4a1c8e5452c7b94bac185e))
+
+## v0.77.0 (2024-07-02)
+
+### Feature
+
+* feat(bec_connector): export config to yaml ([`a391f30`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a391f3018c50fee6a4a06884491b957df80c3cd3))
+
+* feat(utils): colors added convertor for rgba to hex ([`572f2fb`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/572f2fb8110d5cb0e80f3ca45ce57ef405572456))
+
+### Fix
+
+* fix(waveform): scatter 2D brush error ([`215d59c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/215d59c8bfe7fda9aff8cec8353bef9e1ce2eca1))
+
+* fix(figure): API cleanup ([`008a33a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/008a33a9b192473cc58e90cd6d98c5bcb5f7b8c0))
+
+* fix(figure): if/else logic corrected in subplot_factory ([`3e78723`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3e787234c7274b0698423d7bf9a4c54ec46bad5f))
+
+* fix(image): processing of already displayed data; closes #106 ([`1173510`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1173510105d2d70d7e498c2ac1e122cea3a16597))
+
+* fix(bec_figure): full reconstruction with config from other bec figure ([`b6e1e20`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b6e1e20b7c8549bb092e981062329e601411dda6))
+
+* fix(motor_map): API changes updates current visualisation; motor_map can be initialised from config ([`2e2d422`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2e2d422910685a2527a3d961a468c787f771ca44))
+
+* fix(image): image add_custom_image fixed, closes #225 ([`f0556e4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f0556e44113ffee66cf735aa2dd758c62cb634f4))
+
+* fix(figure): subplot methods consolidated; added subplot factory ([`4a97105`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4a97105e4bd2ce77d72dfe5f8307dd9ee65b21b0))
+
+* fix(image): image can be fully reconstructed from config ([`797f73c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/797f73c39aa73e07d6311f3de4baea53f6c380e0))
+
+* fix(image_item): vrange added int for pydantic model check ([`b8f796f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b8f796fd3fcc15641e8fc6a3ca75c344ce90fc45))
+
+* fix(bec_figure): waveforms can be initialised from the config; widgets are deleteLater after removal ([`78673ea`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/78673ea11a47aad878128197ae6213925228ed59))
+
+### Unknown
+
+* Resolve "add VT100 console executing BEC as a widget" ([`c6a14c0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c6a14c0768a90695567a83a7895247ed0c64f3ce))
+
+## v0.76.1 (2024-06-29)
+
+### Fix
+
+* fix(plugins): fixes and tests for auto-gen plugins ([`c42511d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c42511dd44cc13577e108a6cef3166376e594f54))
+
+## v0.76.0 (2024-06-28)
+
+### Feature
+
+* feat(designer): added support for creating designer plugins automatically ([`c1dd0ee`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c1dd0ee1906dba1f2e2ae9ce40a84d55c26a1cce))
+
+### Fix
+
+* fix: fixed qwidget inheritance for ring progress bar ([`0610d2f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0610d2f9f027f8659e7149f2dfbb316ff30e337d))
+
+### Unknown
+
+* fix:parent set as first kwarg TextBox and WebsiteWidget ([`a45c407`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a45c4075684b93bfdcee03e5a416b84f61d3bc6f))
+
+## v0.75.0 (2024-06-26)
+
+### Feature
+
+* feat(widgets): added simple bec queue widget ([`3faee98`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3faee98ec80041a27e4c1f1156178de6f9dcdc63))
+
+### Refactor
+
+* refactor(dispatcher): cleanup ([`ca02132`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ca02132c8d18535b37e9192e00459d2aca6ba5cf))
+
 ## v0.74.1 (2024-06-26)
 
 ### Build
@@ -45,109 +149,3 @@
 ### Fix
 
 * fix(vscode): only run terminate if the process is still alive ([`7120f3e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7120f3e93b054b788f15e2d5bcd688e3c140c1ce))
-
-* fix(rpc): trigger shutdown of server when gui is terminated ([`acc1318`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/acc13183e28030e3ca9af21bb081e1eed081622b))
-
-* fix(rpc): remove of calling "close" and waiting for gui_is_alive ([`f75fc19`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f75fc19c5b10022763252917ca473f404a25165a))
-
-## v0.73.1 (2024-06-25)
-
-### Fix
-
-* fix(ringprogressbar): removed hard-coded endpoint strings ([`1de3cbf`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1de3cbf65a1832150917a7549a1bf3efdee6371a))
-
-## v0.73.0 (2024-06-25)
-
-### Feature
-
-* feat: add new default scaling of image_item ([`df812ea`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/df812eaad5989f2930dde41d87491868505af946))
-
-### Test
-
-* test: add test for imageitem ([`88ecd05`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/88ecd05b95974938ef1efff40e81854baf004cb4))
-
-## v0.72.2 (2024-06-25)
-
-### Fix
-
-* fix(designer): fixed designer for pyenv and venv; closes #237 ([`e631fc1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e631fc15d8707b73d58cb64316e115a7e43961ea))
-
-## v0.72.1 (2024-06-24)
-
-### Fix
-
-* fix: renamed spiral progress bar to ring progress bar; closes #235 ([`e5c0087`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e5c0087c9aed831edbe1c172746325a772a3bafa))
-
-### Test
-
-* test: bugfix to prohibit leackage of mock ([`4348ed1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4348ed1bb2182da6bdecaf372d6db85279e60af8))
-
-## v0.72.0 (2024-06-24)
-
-### Feature
-
-* feat(connector): added threadpool wrapper ([`4ca1efe`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4ca1efeeb8955604069f7b98374c7f82e1a8da67))
-
-### Unknown
-
-* tests(status_box_test): temporary disabled tests for status_box due to high rate of failures ([`aa7ce2e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/aa7ce2ea27bb9564d4f5104bbff30725b8656453))
-
-## v0.71.1 (2024-06-23)
-
-### Fix
-
-* fix: don't print exception if the auto-update module cannot be found in plugins ([`860517a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/860517a3211075d1f6e2af7fa6a567b9e0cd77f3))
-
-## v0.71.0 (2024-06-23)
-
-### Feature
-
-* feat(scan_group_box): scan box for args and kwargs separated from ScanControlGUI code ([`d8cf441`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d8cf44134c30063e586771f9068947fef7a306d1))
-
-### Fix
-
-* fix(cleanup): cleanup added to device_input widgets and scan_control ([`8badb6a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8badb6adc1d003dbf0b2b1a800c34821f3fc9aa3))
-
-* fix(scan_group_box): added row counter based on widgets ([`37682e7`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/37682e7b8a6ede38308880d285e41a948d6fe831))
-
-* fix(scan_control): added default min limit for args bundle if specified ([`ec4574e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ec4574ed5c2c85ea6fbbe2b98f162a8e1220653b))
-
-* fix(scan_control): argbox delete later added to prevent overlapping gui if scan changed ([`7ce3a83`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7ce3a83c58cb69c2bf7cb7f4eaba7e6a2ca6c546))
-
-* fix(scan_control): only scans with defined gui_config are allowed ([`6dff187`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6dff1879c4178df0f8ebfd35101acdebb028d572))
-
-* fix(WidgetIO): find handlers within base classes ([`ca85638`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ca856384f380dabf28d43f1cd48511af784c035b))
-
-* fix(scan_control): adapted widget to scan BEC gui config ([`8b822e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8b822e0fa8e28f080b9a4bf81948a7280a4c07bf))
-
-* fix(scan_control): scan_control.py combatible with the newest BEC versions, test disabled ([`67d398c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/67d398caf74e08ab25a70cc5d85a5f0c2de8212d))
-
-### Refactor
-
-* refactor(device_line_edit): renamed default_device to default ([`4e2c9df`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4e2c9df6a4979d935285fd7eba17fd7fd455a35c))
-
-### Test
-
-* test(scan_control): tests added ([`56e74a0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/56e74a0e7da72d18e89bc30d1896dbf9ef97cd6b))
-
-### Unknown
-
-* test(scan_control):e2e tests added ([`83001a0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/83001a0d8267e1320549b07032857dcf46ecd293))
-
-* doc(scan_control): docs added ([`1b7921a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1b7921a7f2e3bcc846219a2a7aa0de0fd27bb8fe))
-
-* fix(device_line_edit):SizePolicy fixed for 100 horizontal ([`21d20e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/21d20e0fc78e9a3853abe802733388cce119ce20))
-
-* tests WIP ([`c09644b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c09644b29ddb291c91dc58bcd6ebf02ff45cab36))
-
-## v0.70.0 (2024-06-21)
-
-### Feature
-
-* feat(bec-designer): automatic plugin discovery ([`4639eee`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4639eee0b975ebd7a946e0e290449f5b88c372eb))
-
-* feat(device_line_edit): plugin added to bec-designer ([`b4b27ae`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b4b27aea3d8c08fa3d5d5514c69dbde32721d1dc))
-
-### Fix
-
-* fix(bec-desiger+plugins): imports fixed, PYSIDE6 check to not enable run plugins with pyqt6 ([`50b3422`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/50b3422528d46d74317e8c903b6286e868ab7fe0))

bec_widgets/cli/client.py

@@ -13,10 +13,12 @@ class Widgets(str, enum.Enum):
     Enum for the available widgets.
     """
 
+    BECQueue = "BECQueue"
     BECStatusBox = "BECStatusBox"
     BECDock = "BECDock"
     BECDockArea = "BECDockArea"
     BECFigure = "BECFigure"
+    BECMotorMapWidget = "BECMotorMapWidget"
     RingProgressBar = "RingProgressBar"
     ScanControl = "ScanControl"
     TextBox = "TextBox"
@@ -40,14 +42,14 @@ class BECCurve(RPCBase):
 
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -161,7 +163,7 @@ class BECCurve(RPCBase):
 class BECDock(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -171,7 +173,7 @@ class BECDock(RPCBase):
 
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
@@ -289,7 +291,7 @@ class BECDock(RPCBase):
 class BECDockArea(RPCBase, BECGuiClientMixin):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -397,7 +399,7 @@ class BECDockArea(RPCBase, BECGuiClientMixin):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -416,14 +418,14 @@ class BECDockArea(RPCBase, BECGuiClientMixin):
 class BECFigure(RPCBase):
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -431,6 +433,12 @@ class BECFigure(RPCBase):
             dict: The configuration of the widget.
         """
 
+    @rpc_call
+    def _get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
     @rpc_call
     def axes(self, row: "int", col: "int") -> "BECPlotBase":
         """
@@ -453,103 +461,6 @@ class BECFigure(RPCBase):
             dict: All widgets within the figure.
         """
 
-    @rpc_call
-    def add_plot(
-        self,
-        x: "list | np.ndarray" = None,
-        y: "list | np.ndarray" = None,
-        x_name: "str" = None,
-        y_name: "str" = None,
-        z_name: "str" = None,
-        x_entry: "str" = None,
-        y_entry: "str" = None,
-        z_entry: "str" = None,
-        color: "Optional[str]" = None,
-        color_map_z: "Optional[str]" = "plasma",
-        label: "Optional[str]" = None,
-        validate: "bool" = True,
-        row: "int" = None,
-        col: "int" = None,
-        config=None,
-        dap: "str | None" = None,
-        **axis_kwargs,
-    ) -> "BECWaveform":
-        """
-        Add a Waveform1D plot to the figure at the specified position.
-
-        Args:
-            x(list | np.ndarray): Custom x data to plot.
-            y(list | np.ndarray): Custom y data to plot.
-            x_name(str): The name of the device for the x-axis.
-            y_name(str): The name of the device for the y-axis.
-            z_name(str): The name of the device for the z-axis.
-            x_entry(str): The name of the entry for the x-axis.
-            y_entry(str): The name of the entry for the y-axis.
-            z_entry(str): The name of the entry for the z-axis.
-            color(str): The color of the curve.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str): The label of the curve.
-            validate(bool): If True, validate the device names and entries.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
-        """
-
-    @rpc_call
-    def add_image(
-        self,
-        monitor: "str" = None,
-        color_bar: "Literal['simple', 'full']" = "full",
-        color_map: "str" = "magma",
-        data: "np.ndarray" = None,
-        vrange: "tuple[float, float]" = None,
-        row: "int" = None,
-        col: "int" = None,
-        config=None,
-        **axis_kwargs,
-    ) -> "BECImageShow":
-        """
-        Add an image to the figure at the specified position.
-
-        Args:
-            monitor(str): The name of the monitor to display.
-            color_bar(Literal["simple","full"]): The type of color bar to display.
-            color_map(str): The color map to use for the image.
-            data(np.ndarray): Custom data to display.
-            vrange(tuple[float, float]): The range of values to display.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs: Additional axis properties to set on the widget after creation.
-
-        Returns:
-            BECImageShow: The image widget.
-        """
-
-    @rpc_call
-    def add_motor_map(
-        self,
-        motor_x: "str" = None,
-        motor_y: "str" = None,
-        row: "int" = None,
-        col: "int" = None,
-        config=None,
-        **axis_kwargs,
-    ) -> "BECMotorMap":
-        """
-        Args:
-            motor_x(str): The name of the motor for the X axis.
-            motor_y(str): The name of the motor for the Y axis.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs:
-
-        Returns:
-            BECMotorMap: The motor map widget.
-        """
-
     @rpc_call
     def plot(
         self,
@@ -565,7 +476,11 @@ class BECFigure(RPCBase):
         color_map_z: "str | None" = "plasma",
         label: "str | None" = None,
         validate: "bool" = True,
+        new: "bool" = False,
+        row: "int | None" = None,
+        col: "int | None" = None,
         dap: "str | None" = None,
+        config: "dict | None" = None,
         **axis_kwargs,
     ) -> "BECWaveform":
         """
@@ -584,7 +499,11 @@ class BECFigure(RPCBase):
             color_map_z(str): The color map to use for the z-axis.
             label(str): The label of the curve.
             validate(bool): If True, validate the device names and entries.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
             dap(str): The DAP model to use for the curve.
+            config(dict): Recreates the whole BECWaveform widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
@@ -599,6 +518,10 @@ class BECFigure(RPCBase):
         color_map: "str" = "magma",
         data: "np.ndarray" = None,
         vrange: "tuple[float, float]" = None,
+        new: "bool" = False,
+        row: "int | None" = None,
+        col: "int | None" = None,
+        config: "dict | None" = None,
         **axis_kwargs,
     ) -> "BECImageShow":
         """
@@ -610,6 +533,10 @@ class BECFigure(RPCBase):
             color_map(str): The color map to use for the image.
             data(np.ndarray): Custom data to display.
             vrange(tuple[float, float]): The range of values to display.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Recreates the whole BECImageShow widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
@@ -618,7 +545,14 @@ class BECFigure(RPCBase):
 
     @rpc_call
     def motor_map(
-        self, motor_x: "str" = None, motor_y: "str" = None, **axis_kwargs
+        self,
+        motor_x: "str" = None,
+        motor_y: "str" = None,
+        new: "bool" = False,
+        row: "int | None" = None,
+        col: "int | None" = None,
+        config: "dict | None" = None,
+        **axis_kwargs,
     ) -> "BECMotorMap":
         """
         Add a motor map to the figure. Always access the first motor map widget in the figure.
@@ -626,6 +560,10 @@ class BECFigure(RPCBase):
         Args:
             motor_x(str): The name of the motor for the X axis.
             motor_y(str): The name of the motor for the Y axis.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Recreates the whole BECImageShow widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
@@ -676,12 +614,6 @@ class BECFigure(RPCBase):
         Clear all widgets from the figure and reset to default state
         """
 
-    @rpc_call
-    def get_all_rpc(self) -> "dict":
-        """
-        Get all registered RPC objects.
-        """
-
     @property
     @rpc_call
     def widget_list(self) -> "list[BECPlotBase]":
@@ -695,14 +627,14 @@ class BECFigure(RPCBase):
 class BECImageItem(RPCBase):
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -849,14 +781,14 @@ class BECImageItem(RPCBase):
 class BECImageShow(RPCBase):
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -876,34 +808,12 @@ class BECImageShow(RPCBase):
             BECImageItem: The image object.
         """
 
-    @rpc_call
-    def get_image_config(self, image_id, dict_output: "bool" = True) -> "ImageItemConfig | dict":
-        """
-        Get the configuration of the image.
-
-        Args:
-            image_id(str): The ID of the image.
-            dict_output(bool): Whether to return the configuration as a dictionary. Defaults to True.
-
-        Returns:
-            ImageItemConfig|dict: The configuration of the image.
-        """
-
-    @rpc_call
-    def get_image_dict(self) -> "dict[str, dict[str, BECImageItem]]":
-        """
-        Get all images.
-
-        Returns:
-            dict[str, dict[str, BECImageItem]]: The dictionary of images.
-        """
-
     @rpc_call
     def add_monitor_image(
         self,
         monitor: "str",
         color_map: "Optional[str]" = "magma",
-        color_bar: "Optional[Literal['simple', 'full']]" = "simple",
+        color_bar: "Optional[Literal['simple', 'full']]" = "full",
         downsample: "Optional[bool]" = True,
         opacity: "Optional[float]" = 1.0,
         vrange: "Optional[tuple[int, int]]" = None,
@@ -919,7 +829,7 @@ class BECImageShow(RPCBase):
         name: "str",
         data: "Optional[np.ndarray]" = None,
         color_map: "Optional[str]" = "magma",
-        color_bar: "Optional[Literal['simple', 'full']]" = "simple",
+        color_bar: "Optional[Literal['simple', 'full']]" = "full",
         downsample: "Optional[bool]" = True,
         opacity: "Optional[float]" = 1.0,
         vrange: "Optional[tuple[int, int]]" = None,
@@ -1064,15 +974,6 @@ class BECImageShow(RPCBase):
             name(str): The name of the image. If None, apply to all images.
         """
 
-    @rpc_call
-    def toggle_threading(self, use_threading: "bool"):
-        """
-        Toggle threading for the widgets postprocessing and updating.
-
-        Args:
-            use_threading(bool): Whether to use threading.
-        """
-
     @rpc_call
     def set(self, **kwargs) -> "None":
         """
@@ -1208,14 +1109,14 @@ class BECImageShow(RPCBase):
 class BECMotorMap(RPCBase):
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1292,6 +1193,7 @@ class BECMotorMap(RPCBase):
     def get_data(self) -> "dict":
         """
         Get the data of the motor map.
+
         Returns:
             dict: Data of the motor map.
         """
@@ -1302,11 +1204,99 @@ class BECMotorMap(RPCBase):
         Remove the plot widget from the figure.
         """
 
+    @rpc_call
+    def reset_history(self):
+        """
+        Reset the history of the motor map.
+        """
+
+
+class BECMotorMapWidget(RPCBase):
+    @rpc_call
+    def change_motors(
+        self,
+        motor_x: "str",
+        motor_y: "str",
+        motor_x_entry: "str" = None,
+        motor_y_entry: "str" = None,
+        validate_bec: "bool" = True,
+    ) -> "None":
+        """
+        Change the active motors for the plot.
+
+        Args:
+            motor_x(str): Motor name for the X axis.
+            motor_y(str): Motor name for the Y axis.
+            motor_x_entry(str): Motor entry for the X axis.
+            motor_y_entry(str): Motor entry for the Y axis.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        """
+
+    @rpc_call
+    def set_max_points(self, max_points: "int") -> "None":
+        """
+        Set the maximum number of points to display on the motor map.
+
+        Args:
+            max_points(int): Maximum number of points to display.
+        """
+
+    @rpc_call
+    def set_precision(self, precision: "int") -> "None":
+        """
+        Set the precision of the motor map.
+
+        Args:
+            precision(int): Precision to set.
+        """
+
+    @rpc_call
+    def set_num_dim_points(self, num_dim_points: "int") -> "None":
+        """
+        Set the number of points to display on the motor map.
+
+        Args:
+            num_dim_points(int): Number of points to display.
+        """
+
+    @rpc_call
+    def set_background_value(self, background_value: "int") -> "None":
+        """
+        Set the background value of the motor map.
+
+        Args:
+            background_value(int): Background value of the motor map.
+        """
+
+    @rpc_call
+    def set_scatter_size(self, scatter_size: "int") -> "None":
+        """
+        Set the scatter size of the motor map.
+
+        Args:
+            scatter_size(int): Scatter size of the motor map.
+        """
+
+    @rpc_call
+    def get_data(self) -> "dict":
+        """
+        Get the data of the motor map.
+
+        Returns:
+            dict: Data of the motor map.
+        """
+
+    @rpc_call
+    def reset_history(self) -> "None":
+        """
+        Reset the history of the motor map.
+        """
+
 
 class BECPlotBase(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1446,10 +1436,10 @@ class BECPlotBase(RPCBase):
         """
 
 
-class BECStatusBox(RPCBase):
+class BECQueue(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1458,7 +1448,25 @@ class BECStatusBox(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
+
+class BECStatusBox(RPCBase):
+    @property
+    @rpc_call
+    def _config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -1467,14 +1475,14 @@ class BECStatusBox(RPCBase):
 class BECWaveform(RPCBase):
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1599,28 +1607,6 @@ class BECWaveform(RPCBase):
             BECCurve: The curve object.
         """
 
-    @rpc_call
-    def get_curve_config(self, curve_id: "str", dict_output: "bool" = True) -> "CurveConfig | dict":
-        """
-        Get the configuration of a curve by its ID.
-
-        Args:
-            curve_id(str): ID of the curve.
-
-        Returns:
-            CurveConfig|dict: Configuration of the curve.
-        """
-
-    @rpc_call
-    def apply_config(self, config: "dict | SubplotConfig", replot_last_scan: "bool" = False):
-        """
-        Apply the configuration to the 1D waveform widget.
-
-        Args:
-            config(dict|SubplotConfig): Configuration settings.
-            replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
-        """
-
     @rpc_call
     def get_all_data(self, output: "Literal['dict', 'pandas']" = "dict") -> "dict | pd.DataFrame":
         """
@@ -1768,7 +1754,7 @@ class BECWaveform(RPCBase):
 class DeviceComboBox(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1777,7 +1763,7 @@ class DeviceComboBox(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -1786,7 +1772,7 @@ class DeviceComboBox(RPCBase):
 class DeviceInputBase(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1795,7 +1781,7 @@ class DeviceInputBase(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -1804,7 +1790,7 @@ class DeviceInputBase(RPCBase):
 class DeviceLineEdit(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1813,7 +1799,7 @@ class DeviceLineEdit(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -1821,21 +1807,21 @@ class DeviceLineEdit(RPCBase):
 
 class Ring(RPCBase):
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
 
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1921,21 +1907,21 @@ class Ring(RPCBase):
 
 class RingProgressBar(RPCBase):
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
 
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -2101,7 +2087,7 @@ class RingProgressBar(RPCBase):
 class ScanControl(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -2110,7 +2096,7 @@ class ScanControl(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -2119,7 +2105,7 @@ class ScanControl(RPCBase):
 class StopButton(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -2128,7 +2114,7 @@ class StopButton(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """

bec_widgets/cli/generate_cli.py

@@ -10,6 +10,7 @@ from typing import Literal
 import black
 import isort
 
+from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator
 from bec_widgets.utils.plugin_utils import get_rpc_classes
 
 if sys.version_info >= (3, 11):
@@ -161,6 +162,26 @@ def main():
         generator.generate_client(rpc_classes)
         generator.write(client_path)
 
+        for cls in rpc_classes["top_level_classes"]:
+            plugin = DesignerPluginGenerator(cls)
+            if not hasattr(plugin, "info"):
+                continue
+
+            # if the class directory already has a register, plugin and pyproject file, skip
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"register_{plugin.info.plugin_name_snake}.py")
+            ):
+                continue
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"{plugin.info.plugin_name_snake}_plugin.py")
+            ):
+                continue
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"{plugin.info.plugin_name_snake}.pyproject")
+            ):
+                continue
+            plugin.run()
+
 
 if __name__ == "__main__":  # pragma: no cover
     sys.argv = ["generate_cli.py", "--core"]

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -40,12 +40,13 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     "w1": self.w1,
                     "w2": self.w2,
                     "w3": self.w3,
+                    "w1_c": self.w1_c,
+                    "w2_c": self.w2_c,
+                    "w3_c": self.w3_c,
+                    "w4": self.w4,
                     "d0": self.d0,
                     "d1": self.d1,
                     "d2": self.d2,
-                    "fig0": self.fig0,
-                    "fig1": self.fig1,
-                    "fig2": self.fig2,
                     "plt": self.plt,
                     "bar": self.bar,
                 }
@@ -75,17 +76,37 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.figure.plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="cividis")
         self.figure.motor_map("samx", "samy")
         self.figure.image("eiger", color_map="viridis", vrange=(0, 100))
-        self.figure.add_plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="magma")
+        self.figure.plot(
+            x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="magma", new=True
+        )
 
         self.figure.change_layout(2, 2)
 
         self.w1 = self.figure[0, 0]
         self.w2 = self.figure[0, 1]
         self.w3 = self.figure[1, 0]
+        self.w4 = self.figure[1, 1]
+
+        # Plot Customisation
+        self.w1.set_title("Waveform 1")
+        self.w1.set_x_label("Motor Position (samx)")
+        self.w1.set_y_label("Intensity A.U.")
+
+        # Image Customisation
+        self.w3.set_title("Eiger Image")
+        self.w3.set_x_label("X")
+        self.w3.set_y_label("Y")
+
+        # Configs to try to pass
+        self.w1_c = self.w1._config_dict
+        self.w2_c = self.w2._config_dict
+        self.w3_c = self.w3._config_dict
 
         # curves for w1
         self.c1 = self.w1.get_config()
 
+        self.fig_c = self.figure._config_dict
+
     def _init_dock(self):
 
         self.d0 = self.dock.add_dock(name="dock_0")

bec_widgets/utils/bec_connector.py

@@ -1,15 +1,19 @@
 # pylint: disable = no-name-in-module,missing-module-docstring
 from __future__ import annotations
 
+import os
 import time
+import uuid
 from typing import Optional
 
+import yaml
 from bec_lib.utils.import_utils import lazy_import_from
 from pydantic import BaseModel, Field, field_validator
 from qtpy.QtCore import QObject, QRunnable, QThreadPool, Signal
 from qtpy.QtCore import Slot as pyqtSlot
 
 from bec_widgets.cli.rpc_register import RPCRegister
+from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui
 
 BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
 
@@ -62,7 +66,7 @@ class Worker(QRunnable):
 class BECConnector:
     """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
 
-    USER_ACCESS = ["config_dict", "get_all_rpc"]
+    USER_ACCESS = ["_config_dict", "_get_all_rpc"]
 
     def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
         # BEC related connections
@@ -126,23 +130,23 @@ class BECConnector:
         self._thread_pool.start(worker)
         return worker
 
-    def get_all_rpc(self) -> dict:
+    def _get_all_rpc(self) -> dict:
         """Get all registered RPC objects."""
         all_connections = self.rpc_register.list_all_connections()
         return dict(all_connections)
 
     @property
-    def rpc_id(self) -> str:
+    def _rpc_id(self) -> str:
         """Get the RPC ID of the widget."""
         return self.gui_id
 
-    @rpc_id.setter
-    def rpc_id(self, rpc_id: str) -> None:
+    @_rpc_id.setter
+    def _rpc_id(self, rpc_id: str) -> None:
         """Set the RPC ID of the widget."""
         self.gui_id = rpc_id
 
     @property
-    def config_dict(self) -> dict:
+    def _config_dict(self) -> dict:
         """
         Get the configuration of the widget.
 
@@ -151,8 +155,8 @@ class BECConnector:
         """
         return self.config.model_dump()
 
-    @config_dict.setter
-    def config_dict(self, config: BaseModel) -> None:
+    @_config_dict.setter
+    def _config_dict(self, config: BaseModel) -> None:
         """
         Get the configuration of the widget.
 
@@ -161,6 +165,60 @@ class BECConnector:
         """
         self.config = config
 
+    def apply_config(self, config: dict, generate_new_id: bool = True) -> None:
+        """
+        Apply the configuration to the widget.
+
+        Args:
+            config(dict): Configuration settings.
+            generate_new_id(bool): If True, generate a new GUI ID for the widget.
+        """
+        self.config = ConnectionConfig(**config)
+        if generate_new_id is True:
+            gui_id = str(uuid.uuid4())
+            self.rpc_register.remove_rpc(self)
+            self.set_gui_id(gui_id)
+            self.rpc_register.add_rpc(self)
+        else:
+            self.gui_id = self.config.gui_id
+
+    def load_config(self, path: str | None = None, gui: bool = False):
+        """
+        Load the configuration of the widget from YAML.
+
+        Args:
+            path(str): Path to the configuration file for non-GUI dialog mode.
+            gui(bool): If True, use the GUI dialog to load the configuration file.
+        """
+        if gui is True:
+            config = load_yaml_gui(self)
+        else:
+            config = load_yaml(path)
+
+        if config is not None:
+            if config.get("widget_class") != self.__class__.__name__:
+                raise ValueError(
+                    f"Configuration file is not for {self.__class__.__name__}. Got configuration for {config.get('widget_class')}."
+                )
+            self.apply_config(config)
+
+    def save_config(self, path: str | None = None, gui: bool = False):
+        """
+        Save the configuration of the widget to YAML.
+
+        Args:
+            path(str): Path to save the configuration file for non-GUI dialog mode.
+            gui(bool): If True, use the GUI dialog to save the configuration file.
+        """
+        if gui is True:
+            save_yaml_gui(self, self._config_dict)
+        else:
+            if path is None:
+                path = os.getcwd()
+            file_path = os.path.join(path, f"{self.__class__.__name__}_config.yaml")
+
+            save_yaml(file_path, self._config_dict)
+
     @pyqtSlot(str)
     def set_gui_id(self, gui_id: str) -> None:
         """

bec_widgets/utils/bec_designer.py

@@ -73,26 +73,28 @@ def patch_designer():  # pragma: no cover
     os.environ["PY_MAJOR_VERSION"] = str(major_version)
     os.environ["PY_MINOR_VERSION"] = str(minor_version)
 
-    if sys.platform == "linux":
+    if sys.platform == "win32":
+        if is_virtual_env():
+            _extend_path_var("PATH", os.fspath(Path(sys._base_executable).parent), True)
+    else:
+        if sys.platform == "linux":
+            suffix = f"{sys.abiflags}.so"
+            env_var = "LD_PRELOAD"
+        elif sys.platform == "darwin":
+            suffix = ".dylib"
+            env_var = "DYLD_INSERT_LIBRARIES"
+        else:
+            raise RuntimeError(f"Unsupported platform: {sys.platform}")
         version = f"{major_version}.{minor_version}"
-        library_name = f"libpython{version}{sys.abiflags}.so"
-        if is_pyenv_python():
-            library_name = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
-        os.environ["LD_PRELOAD"] = library_name
-    elif sys.platform == "darwin":
-        library_name = f"libpython{major_version}.{minor_version}.dylib"
+        library_name = f"libpython{version}{suffix}"
         lib_path = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
-        os.environ["DYLD_INSERT_LIBRARIES"] = lib_path
+        os.environ[env_var] = lib_path
 
         if is_pyenv_python() or is_virtual_env():
             # append all editable packages to the PYTHONPATH
             editable_packages = list_editable_packages()
             for pckg in editable_packages:
                 _extend_path_var("PYTHONPATH", pckg, True)
-    elif sys.platform == "win32":
-        if is_virtual_env():
-            _extend_path_var("PATH", os.fspath(Path(sys._base_executable).parent), True)
-
     qt_tool_wrapper(ui_tool_binary("designer"), sys.argv[1:])
 
 

bec_widgets/utils/bec_dispatcher.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import argparse
 import collections
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Union

bec_widgets/utils/colors.py

@@ -67,6 +67,44 @@ class Colors:
                 raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
         return colors
 
+    @staticmethod
+    def hex_to_rgba(hex_color: str, alpha=255) -> tuple:
+        """
+        Convert HEX color to RGBA.
+
+        Args:
+            hex_color(str): HEX color string.
+            alpha(int): Alpha value (0-255). Default is 255 (opaque).
+
+        Returns:
+            tuple: RGBA color tuple (r, g, b, a).
+        """
+        hex_color = hex_color.lstrip("#")
+        if len(hex_color) == 6:
+            r, g, b = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
+        elif len(hex_color) == 8:
+            r, g, b, a = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4, 6))
+            return (r, g, b, a)
+        else:
+            raise ValueError("HEX color must be 6 or 8 characters long.")
+        return (r, g, b, alpha)
+
+    @staticmethod
+    def rgba_to_hex(r: int, g: int, b: int, a: int = 255) -> str:
+        """
+        Convert RGBA color to HEX.
+
+        Args:
+            r(int): Red value (0-255).
+            g(int): Green value (0-255).
+            b(int): Blue value (0-255).
+            a(int): Alpha value (0-255). Default is 255 (opaque).
+
+        Returns:
+            hec_color(str): HEX color string.
+        """
+        return "#{:02X}{:02X}{:02X}{:02X}".format(r, g, b, a)
+
     @staticmethod
     def validate_color(color: tuple | str) -> tuple | str:
         """

bec_widgets/utils/generate_designer_plugin.py

@@ -0,0 +1,148 @@
+import inspect
+import os
+import re
+
+from qtpy.QtCore import QObject
+
+EXCLUDED_PLUGINS = ["BECConnector", "BECDockArea", "BECDock"]
+
+
+class DesignerPluginInfo:
+    def __init__(self, plugin_class):
+        self.plugin_class = plugin_class
+        self.plugin_name_pascal = plugin_class.__name__
+        self.plugin_name_snake = self.pascal_to_snake(self.plugin_name_pascal)
+        self.widget_import = f"from {plugin_class.__module__} import {self.plugin_name_pascal}"
+        plugin_module = (
+            ".".join(plugin_class.__module__.split(".")[:-1]) + f".{self.plugin_name_snake}_plugin"
+        )
+        self.plugin_import = f"from {plugin_module} import {self.plugin_name_pascal}Plugin"
+
+        # first sentence / line of the docstring is used as tooltip
+        self.plugin_tooltip = (
+            plugin_class.__doc__.split("\n")[0].strip().replace('"', "'")
+            if plugin_class.__doc__
+            else self.plugin_name_pascal
+        )
+
+        self.base_path = os.path.dirname(inspect.getfile(plugin_class))
+
+    @staticmethod
+    def pascal_to_snake(name: str) -> str:
+        """
+        Convert PascalCase to snake_case.
+
+        Args:
+            name (str): The name to be converted.
+
+        Returns:
+            str: The converted name.
+        """
+        s1 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+        s2 = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", s1)
+        return s2.lower()
+
+
+class DesignerPluginGenerator:
+    def __init__(self, widget: type):
+        self._excluded = False
+        self.widget = widget
+        self.info = DesignerPluginInfo(widget)
+        if widget.__name__ in EXCLUDED_PLUGINS:
+
+            self._excluded = True
+            return
+
+        self.templates = {}
+        self.template_path = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), "plugin_templates"
+        )
+
+    def run(self):
+        if self._excluded:
+            print(f"Plugin {self.widget.__name__} is excluded from generation.")
+            return
+        self._check_class_validity()
+        self._load_templates()
+        self._write_templates()
+
+    def _check_class_validity(self):
+
+        # Check if the widget is a QWidget subclass
+        if not issubclass(self.widget, QObject):
+            return
+
+        # Check if the widget class has parent as the first argument. This is a strict requirement of Qt!
+        signature = list(inspect.signature(self.widget.__init__).parameters.values())
+        if len(signature) == 1 or signature[1].name != "parent":
+            raise ValueError(
+                f"Widget class {self.widget.__name__} must have parent as the first argument."
+            )
+
+        base_cls = [val for val in self.widget.__bases__ if issubclass(val, QObject)]
+        if not base_cls:
+            raise ValueError(
+                f"Widget class {self.widget.__name__} must inherit from a QObject subclass."
+            )
+
+        # Check if the widget class calls the super constructor with parent argument
+        init_source = inspect.getsource(self.widget.__init__)
+        cls_init_found = (
+            bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent=parent") > 0)
+            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent)") > 0)
+            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent,") > 0)
+        )
+        super_init_found = (
+            bool(
+                init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent=parent") > 0
+            )
+            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent,") > 0)
+            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent)") > 0)
+        )
+        if issubclass(self.widget.__bases__[0], QObject) and not super_init_found:
+            super_init_found = (
+                bool(init_source.find("super().__init__(parent=parent") > 0)
+                or bool(init_source.find("super().__init__(parent,") > 0)
+                or bool(init_source.find("super().__init__(parent)") > 0)
+            )
+
+        if not cls_init_found and not super_init_found:
+            raise ValueError(
+                f"Widget class {self.widget.__name__} must call the super constructor with parent."
+            )
+
+    def _write_templates(self):
+        self._write_register()
+        self._write_plugin()
+        self._write_pyproject()
+
+    def _write_register(self):
+        file_path = os.path.join(self.info.base_path, f"register_{self.info.plugin_name_snake}.py")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(self.templates["register"].format(**self.info.__dict__))
+
+    def _write_plugin(self):
+        file_path = os.path.join(self.info.base_path, f"{self.info.plugin_name_snake}_plugin.py")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(self.templates["plugin"].format(**self.info.__dict__))
+
+    def _write_pyproject(self):
+        file_path = os.path.join(self.info.base_path, f"{self.info.plugin_name_snake}.pyproject")
+        out = {"files": [f"{self.info.plugin_class.__module__.split('.')[-1]}.py"]}
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(str(out))
+
+    def _load_templates(self):
+        for file in os.listdir(self.template_path):
+            if not file.endswith(".template"):
+                continue
+            with open(os.path.join(self.template_path, file), "r", encoding="utf-8") as f:
+                self.templates[file.split(".")[0]] = f.read()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
+    from bec_widgets.widgets.dock import BECDockArea
+
+    generator = DesignerPluginGenerator(BECDockArea)
+    generator.run()

bec_widgets/utils/plugin_templates/plugin.template

@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+{widget_import}
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='{plugin_name_pascal}' name='{plugin_name_snake}'>
+    </widget>
+</ui>
+"""
+
+
+class {plugin_name_pascal}Plugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = {plugin_name_pascal}(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "{plugin_name_snake}"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "{plugin_name_pascal}"
+
+    def toolTip(self):
+        return "{plugin_tooltip}"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/utils/plugin_templates/register.template

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    {plugin_import}
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget({plugin_name_pascal}Plugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/utils/ui_loader.py

@@ -1,6 +1,30 @@
-from qtpy import QT_VERSION
+from qtpy import PYQT6, PYSIDE6, QT_VERSION
 from qtpy.QtCore import QFile, QIODevice
 
+if PYSIDE6:
+    from PySide6.QtUiTools import QUiLoader
+
+    from bec_widgets.utils.plugin_utils import get_rpc_classes
+    from bec_widgets.widgets.buttons.color_button.color_button import ColorButton
+
+    class CustomUiLoader(QUiLoader):
+        def __init__(self, baseinstance):
+            super().__init__(baseinstance)
+            widgets = get_rpc_classes("bec_widgets").get("top_level_classes", [])
+
+            widgets.append(ColorButton)
+
+            self.custom_widgets = {widget.__name__: widget for widget in widgets}
+
+            self.baseinstance = baseinstance
+
+        def createWidget(self, class_name, parent=None, name=""):
+            if class_name in self.custom_widgets:
+                widget = self.custom_widgets[class_name](parent)
+                widget.setObjectName(name)
+                return widget
+            return super().createWidget(class_name, parent, name)
+
 
 class UILoader:
     """Universal UI loader for PyQt5, PyQt6, PySide2, and PySide6."""
@@ -14,14 +38,14 @@ class UILoader:
             self.loader = uic.loadUi
         elif QT_VERSION.startswith("6"):
             # PyQt6 or PySide6
-            try:
-                from PySide6.QtUiTools import QUiLoader
-
+            if PYSIDE6:
                 self.loader = self.load_ui_pyside6
-            except ImportError:
+            elif PYQT6:
                 from PyQt6.uic import loadUi
 
                 self.loader = loadUi
+            else:
+                raise ImportError("No compatible Qt bindings found.")
 
     def load_ui_pyside6(self, ui_file, parent=None):
         """
@@ -33,9 +57,8 @@ class UILoader:
         Returns:
             QWidget: The loaded widget.
         """
-        from PySide6.QtUiTools import QUiLoader
 
-        loader = QUiLoader(parent)
+        loader = CustomUiLoader(parent)
         file = QFile(ui_file)
         if not file.open(QIODevice.ReadOnly):
             raise IOError(f"Cannot open file: {ui_file}")

bec_widgets/utils/widget_io.py

@@ -44,8 +44,11 @@ class ComboBoxHandler(WidgetHandler):
     def get_value(self, widget: QComboBox) -> int:
         return widget.currentIndex()
 
-    def set_value(self, widget: QComboBox, value: int) -> None:
-        widget.setCurrentIndex(value)
+    def set_value(self, widget: QComboBox, value: int | str) -> None:
+        if isinstance(value, str):
+            value = widget.findText(value)
+        if isinstance(value, int):
+            widget.setCurrentIndex(value)
 
 
 class TableWidgetHandler(WidgetHandler):
@@ -142,6 +145,26 @@ class WidgetIO:
         elif not ignore_errors:
             raise ValueError(f"No handler for widget type: {type(widget)}")
 
+    @staticmethod
+    def check_and_adjust_limits(spin_box: QDoubleSpinBox, number: float):
+        """
+        Check if the new limits are within the current limits, if not adjust the limits.
+
+        Args:
+            number(float): The new value to check against the limits.
+        """
+
+        min_value = spin_box.minimum()
+        max_value = spin_box.maximum()
+
+        # Calculate the new limits
+        new_limit = number + 5 * number
+
+        if number < min_value:
+            spin_box.setMinimum(new_limit)
+        elif number > max_value:
+            spin_box.setMaximum(new_limit)
+
     @staticmethod
     def _find_handler(widget):
         """

bec_widgets/utils/yaml_dialog.py

@@ -6,7 +6,7 @@ import yaml
 from qtpy.QtWidgets import QFileDialog
 
 
-def load_yaml(instance) -> Union[dict, None]:
+def load_yaml_gui(instance) -> Union[dict, None]:
     """
     Load YAML file from disk.
 
@@ -20,12 +20,25 @@ def load_yaml(instance) -> Union[dict, None]:
     file_path, _ = QFileDialog.getOpenFileName(
         instance, "Load Settings", "", "YAML Files (*.yaml *.yml);;All Files (*)", options=options
     )
+    config = load_yaml(file_path)
+    return config
 
+
+def load_yaml(file_path: str) -> Union[dict, None]:
+    """
+    Load YAML file from disk.
+
+    Args:
+        file_path(str): Path to the YAML file.
+
+    Returns:
+        dict: Configuration data loaded from the YAML file.
+    """
     if not file_path:
         return None
     try:
         with open(file_path, "r") as file:
-            config = yaml.safe_load(file)
+            config = yaml.load(file, Loader=yaml.FullLoader)
         return config
 
     except FileNotFoundError:
@@ -38,7 +51,7 @@ def load_yaml(instance) -> Union[dict, None]:
         print(f"An error occurred while loading the settings from {file_path}: {e}")
 
 
-def save_yaml(instance, config: dict) -> None:
+def save_yaml_gui(instance, config: dict) -> None:
     """
     Save YAML file to disk.
 
@@ -51,6 +64,17 @@ def save_yaml(instance, config: dict) -> None:
         instance, "Save Settings", "", "YAML Files (*.yaml *.yml);;All Files (*)", options=options
     )
 
+    save_yaml(file_path, config)
+
+
+def save_yaml(file_path: str, config: dict) -> None:
+    """
+    Save YAML file to disk.
+
+    Args:
+        file_path(str): Path to the YAML file.
+        config(dict): Configuration data to be saved.
+    """
     if not file_path:
         return
     try:

bec_widgets/widgets/bec_queue/bec_queue.py

@@ -0,0 +1,111 @@
+from bec_lib.endpoints import MessageEndpoints
+from qtpy.QtCore import Qt, Slot
+from qtpy.QtWidgets import QHeaderView, QTableWidget, QTableWidgetItem, QWidget
+
+from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
+
+
+class BECQueue(BECConnector, QTableWidget):
+    """
+    Widget to display the BEC queue.
+    """
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        client=None,
+        config: ConnectionConfig = None,
+        gui_id: str = None,
+    ):
+        super().__init__(client, config, gui_id)
+        QTableWidget.__init__(self, parent=parent)
+        self.setColumnCount(3)
+        self.setHorizontalHeaderLabels(["Scan Number", "Type", "Status"])
+        header = self.horizontalHeader()
+        header.setSectionResizeMode(QHeaderView.Stretch)
+        self.bec_dispatcher.connect_slot(self.update_queue, MessageEndpoints.scan_queue_status())
+        self.reset_content()
+
+    @Slot(dict, dict)
+    def update_queue(self, content, _metadata):
+        """
+        Update the queue table with the latest queue information.
+
+        Args:
+            content (dict): The queue content.
+            _metadata (dict): The metadata.
+        """
+        # only show the primary queue for now
+        queue_info = content.get("queue", {}).get("primary", {}).get("info", [])
+        self.setRowCount(len(queue_info))
+        self.clearContents()
+
+        if not queue_info:
+            self.reset_content()
+            return
+
+        for index, item in enumerate(queue_info):
+            blocks = item.get("request_blocks", [])
+            scan_types = []
+            scan_numbers = []
+            status = item.get("status", "")
+            for request_block in blocks:
+                scan_type = request_block.get("content", {}).get("scan_type", "")
+                if scan_type:
+                    scan_types.append(scan_type)
+                scan_number = request_block.get("scan_number", "")
+                if scan_number:
+                    scan_numbers.append(str(scan_number))
+            if scan_types:
+                scan_types = ", ".join(scan_types)
+            if scan_numbers:
+                scan_numbers = ", ".join(scan_numbers)
+            self.set_row(index, scan_numbers, scan_types, status)
+
+    def format_item(self, content: str) -> QTableWidgetItem:
+        """
+        Format the content of the table item.
+
+        Args:
+            content (str): The content to be formatted.
+
+        Returns:
+            QTableWidgetItem: The formatted item.
+        """
+        item = QTableWidgetItem(content)
+        item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
+        return item
+
+    def set_row(self, index: int, scan_number: str, scan_type: str, status: str):
+        """
+        Set the row of the table.
+
+        Args:
+            index (int): The index of the row.
+            scan_number (str): The scan number.
+            scan_type (str): The scan type.
+            status (str): The status.
+        """
+
+        self.setItem(index, 0, self.format_item(scan_number))
+        self.setItem(index, 1, self.format_item(scan_type))
+        self.setItem(index, 2, self.format_item(status))
+
+    def reset_content(self):
+        """
+        Reset the content of the table.
+        """
+
+        self.setRowCount(1)
+        self.set_row(0, "", "", "")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = BECQueue()
+    widget.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/bec_queue/bec_queue.pyproject

@@ -0,0 +1 @@
+{'files': ['bec_queue.py']}

bec_widgets/widgets/bec_queue/bec_queue_plugin.py

@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECQueue' name='bec_queue'>
+    </widget>
+</ui>
+"""
+
+
+class BECQueuePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECQueue(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "bec_queue"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "BECQueue"
+
+    def toolTip(self):
+        return "Widget to display the BEC queue."
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/bec_queue/register_bec_queue.py

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.bec_queue.bec_queue_plugin import BECQueuePlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECQueuePlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/bec_status_box/bec_status_box.py

@@ -5,15 +5,16 @@ The widget automatically updates the status of all running BEC services, and dis
 from __future__ import annotations
 
 import sys
+from collections import defaultdict
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 import qdarktheme
 from bec_lib.utils.import_utils import lazy_import_from
-from pydantic import BaseModel, Field, field_validator
-from qtpy.QtCore import QObject, QTimer, Signal, Slot
-from qtpy.QtWidgets import QTreeWidget, QTreeWidgetItem
+from qtpy.QtCore import Signal, Slot
+from qtpy.QtWidgets import QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
 
-from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
+from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.widgets.bec_status_box.status_item import StatusItem
 
 if TYPE_CHECKING:
@@ -21,77 +22,25 @@ if TYPE_CHECKING:
 
 # TODO : Put normal imports back when Pydantic gets faster
 BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
+StatusMessage = lazy_import_from("bec_lib.messages", ("StatusMessage",))
 
 
-class BECStatusBoxConfig(ConnectionConfig):
-    pass
-
-
-class BECServiceInfoContainer(BaseModel):
+@dataclass
+class BECServiceInfoContainer:
     """Container to store information about the BEC services."""
 
     service_name: str
-    status: BECStatus | str = Field(
-        default="NOTCONNECTED",
-        description="The status of the service. Can be any of the BECStatus names, or NOTCONNECTED.",
-    )
+    status: str
     info: dict
     metrics: dict | None
-    model_config: dict = {"validate_assignment": True}
-
-    @field_validator("status")
-    @classmethod
-    def validate_status(cls, v):
-        """Validate input for status. Accept BECStatus and NOTCONNECTED.
-
-        Args:
-            v (BECStatus | str): The input value.
-
-        Returns:
-            str: The validated status.
-        """
-        if v in list(BECStatus.__members__.values()):
-            return v.name
-        if v in list(BECStatus.__members__.keys()) or v == "NOTCONNECTED":
-            return v
-        raise ValueError(
-            f"Status must be one of {BECStatus.__members__.values()} or 'NOTCONNECTED'. Input {v}"
-        )
 
 
-class BECServiceStatusMixin(QObject):
-    """A mixin class to update the service status, and metrics.
-    It emits a signal 'services_update' when the service status is updated.
-
-    Args:
-        client (BECClient): The client object to connect to the BEC server.
-    """
-
-    services_update = Signal(dict, dict)
-
-    def __init__(self, client: BECClient):
-        super().__init__()
-        self.client = client
-        self._service_update_timer = QTimer()
-        self._service_update_timer.timeout.connect(self._get_service_status)
-        self._service_update_timer.start(1000)
-
-    def _get_service_status(self):
-        """Pull latest service and metrics updates from REDIS for all services, and emit both via 'services_update' signal."""
-        # pylint: disable=protected-access
-        self.client._update_existing_services()
-        self.services_update.emit(self.client._services_info, self.client._services_metric)
-
-
-class BECStatusBox(BECConnector, QTreeWidget):
-    """A widget to display the status of different BEC services.
-    This widget automatically updates the status of all running BEC services, and displays their status.
-    Information about the individual services is collapsible, and double clicking on
-    the individual service will display the metrics about the service.
+class BECStatusBox(QWidget):
+    """An autonomous widget to display the status of BEC services.
 
     Args:
         parent Optional : The parent widget for the BECStatusBox. Defaults to None.
-        service_name Optional(str): The name of the top service label. Defaults to "BEC Server".
+        box_name Optional(str): The name of the top service label. Defaults to "BEC Server".
         client Optional(BECClient): The client object to connect to the BEC server. Defaults to None
         config Optional(BECStatusBoxConfig | dict): The configuration for the status box. Defaults to None.
         gui_id Optional(str): The unique id for the widget. Defaults to None.
@@ -99,58 +48,68 @@ class BECStatusBox(BECConnector, QTreeWidget):
 
     CORE_SERVICES = ["DeviceServer", "ScanServer", "SciHub", "ScanBundler", "FileWriterManager"]
 
-    service_update = Signal(dict)
+    service_update = Signal(BECServiceInfoContainer)
     bec_core_state = Signal(str)
 
     def __init__(
         self,
         parent=None,
-        service_name: str = "BEC Server",
+        box_name: str = "BEC Server",
         client: BECClient = None,
-        config: BECStatusBoxConfig | dict = None,
-        bec_service_status_mixin: BECServiceStatusMixin = None,
         gui_id: str = None,
     ):
-        if config is None:
-            config = BECStatusBoxConfig(widget_class=self.__class__.__name__)
-        else:
-            if isinstance(config, dict):
-                config = BECStatusBoxConfig(**config)
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QTreeWidget.__init__(self, parent=parent)
+        QWidget.__init__(self, parent=parent)
+        self.setLayout(QVBoxLayout(self))
+        self.tree = QTreeWidget(self)
+        self.layout().addWidget(self.tree)
+        self.tree.setHeaderHidden(True)
+        self.tree.setStyleSheet(
+            "QTreeWidget::item:!selected "
+            "{ "
+            "border: 1px solid gainsboro; "
+            "border-left: none; "
+            "border-top: none; "
+            "}"
+            "QTreeWidget::item:selected {}"
+        )
+        self.box_name = box_name
+        self.status_container = defaultdict(lambda: {"info": None, "item": None, "widget": None})
 
-        self.service_name = service_name
-        self.config = config
-
-        self.bec_service_info_container = {}
-        self.tree_items = {}
-        self.tree_top_item = None
-
-        if not bec_service_status_mixin:
-            bec_service_status_mixin = BECServiceStatusMixin(client=self.client)
-        self.bec_service_status = bec_service_status_mixin
+        self.connector = BECConnector(client=client, gui_id=gui_id)
 
         self.init_ui()
-        self.bec_service_status.services_update.connect(self.update_service_status)
+
         self.bec_core_state.connect(self.update_top_item_status)
-        self.itemDoubleClicked.connect(self.on_tree_item_double_clicked)
+        self.tree.itemDoubleClicked.connect(self.on_tree_item_double_clicked)
+        self.startTimer(
+            1000
+        )  # use qobject's own timer instead of creating one, which may be stopped from another thread(?)
+
+    def timerEvent(self, event):
+        """Get the latest service status from the BEC server."""
+        # pylint: disable=protected-access
+        self.connector.client._update_existing_services()
+        self.update_service_status(
+            self.connector.client._services_info, self.connector.client._services_metric
+        )
 
     def init_ui(self) -> None:
-        """Initialize the UI for the status box, and add QTreeWidget as the basis for the status box."""
-        self.init_ui_tree_widget()
-        top_label = self._create_status_widget(self.service_name, status=BECStatus.IDLE)
-        self.tree_top_item = QTreeWidgetItem()
-        self.tree_top_item.setExpanded(True)
-        self.tree_top_item.setDisabled(True)
-        self.addTopLevelItem(self.tree_top_item)
-        self.setItemWidget(self.tree_top_item, 0, top_label)
+        """Init the UI for the BECStatusBox widget"""
+        top_label = self._create_status_widget(self.box_name, status=BECStatus.IDLE)
+        tree_item = QTreeWidgetItem(self.tree)
+        tree_item.setExpanded(True)
+        tree_item.setDisabled(True)
+        self.status_container[self.box_name].update({"item": tree_item, "widget": top_label})
+        self.tree.setItemWidget(tree_item, 0, top_label)
+        self.tree.addTopLevelItem(tree_item)
         self.service_update.connect(top_label.update_config)
+        self._initialized = True
 
     def _create_status_widget(
         self, service_name: str, status=BECStatus, info: dict = None, metrics: dict = None
     ) -> StatusItem:
         """Creates a StatusItem (QWidget) for the given service, and stores all relevant
-        information about the service in the bec_service_info_container.
+        information about the service in the status_container.
 
         Args:
             service_name (str): The name of the service.
@@ -163,16 +122,8 @@ class BECStatusBox(BECConnector, QTreeWidget):
         """
         if info is None:
             info = {}
-        self._update_bec_service_container(service_name, status, info, metrics)
-        item = StatusItem(
-            parent=self,
-            config={
-                "service_name": service_name,
-                "status": status.name,
-                "info": info,
-                "metrics": metrics,
-            },
-        )
+        self._update_status_container(service_name, status, info, metrics)
+        item = StatusItem(parent=self.tree, config=self.status_container[service_name]["info"])
         return item
 
     @Slot(str)
@@ -183,30 +134,32 @@ class BECStatusBox(BECConnector, QTreeWidget):
         Args:
             status (BECStatus): The state of the core services.
         """
-        self.bec_service_info_container[self.service_name].status = status
-        self.service_update.emit(self.bec_service_info_container[self.service_name].model_dump())
+        self.status_container[self.box_name]["info"].status = status
+        self.service_update.emit(self.status_container[self.box_name]["info"])
 
-    def _update_bec_service_container(
+    def _update_status_container(
         self, service_name: str, status: BECStatus, info: dict, metrics: dict = None
     ) -> None:
-        """Update the bec_service_info_container with the newest status and metrics for the BEC service.
+        """Update the status_container with the newest status and metrics for the BEC service.
         If information about the service already exists, it will create a new entry.
 
         Args:
             service_name (str): The name of the service.
-            service_info (StatusMessage): A class containing the service status.
-            service_metric (ServiceMetricMessage): A class containing the service metrics.
+            status (BECStatus): The status of the service.
+            info (dict): The information about the service.
+            metrics (dict): The metrics of the service.
         """
-        container = self.bec_service_info_container.get(service_name, None)
+        container = self.status_container[service_name].get("info", None)
+
         if container:
-            container.status = status
+            container.status = status.name
             container.info = info
             container.metrics = metrics
             return
         service_info_item = BECServiceInfoContainer(
-            service_name=service_name, status=status, info=info, metrics=metrics
+            service_name=service_name, status=status.name, info=info, metrics=metrics
         )
-        self.bec_service_info_container.update({service_name: service_info_item})
+        self.status_container[service_name].update({"info": service_info_item})
 
     @Slot(dict, dict)
     def update_service_status(self, services_info: dict, services_metric: dict) -> None:
@@ -217,7 +170,7 @@ class BECStatusBox(BECConnector, QTreeWidget):
             services_info (dict): A dictionary containing the service status for all running BEC services.
             services_metric (dict): A dictionary containing the service metrics for all running BEC services.
         """
-        checked = []
+        checked = [self.box_name]
         services_info = self.update_core_services(services_info, services_metric)
         checked.extend(self.CORE_SERVICES)
 
@@ -225,28 +178,13 @@ class BECStatusBox(BECConnector, QTreeWidget):
             checked.append(service_name)
             metric_msg = services_metric.get(service_name, None)
             metrics = metric_msg.metrics if metric_msg else None
-            if service_name in self.tree_items:
-                self._update_bec_service_container(
-                    service_name=service_name, status=msg.status, info=msg.info, metrics=metrics
-                )
-                self.service_update.emit(self.bec_service_info_container[service_name].model_dump())
-                continue
-
-            item_widget = self._create_status_widget(
-                service_name=service_name, status=msg.status, info=msg.info, metrics=metrics
-            )
-            item = QTreeWidgetItem()
-            item.setDisabled(True)
-            self.service_update.connect(item_widget.update_config)
-            self.tree_top_item.addChild(item)
-            self.setItemWidget(item, 0, item_widget)
-            self.tree_items.update({service_name: (item, item_widget)})
-
-        self.check_redundant_tree_items(checked)
+            if service_name not in self.status_container:
+                self.add_tree_item(service_name, msg.status, msg.info, metrics)
+            self._update_status_container(service_name, msg.status, msg.info, metrics)
+            self.service_update.emit(self.status_container[service_name]["info"])
 
     def update_core_services(self, services_info: dict, services_metric: dict) -> dict:
-        """Method to process status and metrics updates of core services (stored in CORE_SERVICES).
-        If a core services is not connected, it should not be removed from the status widget
+        """Update the core services of BEC, and emit the updated status to the BECStatusBox.
 
         Args:
             services_info (dict): A dictionary containing the service status of different services.
@@ -255,42 +193,26 @@ class BECStatusBox(BECConnector, QTreeWidget):
         Returns:
             dict: The services_info dictionary after removing the info updates related to the CORE_SERVICES
         """
-        bec_core_state = "RUNNING"
+        core_state = BECStatus.RUNNING
         for service_name in sorted(self.CORE_SERVICES):
             metric_msg = services_metric.get(service_name, None)
             metrics = metric_msg.metrics if metric_msg else None
-            if service_name not in services_info:
-                self.bec_service_info_container[service_name].status = "NOTCONNECTED"
-                bec_core_state = "ERROR"
-            else:
-                msg = services_info.pop(service_name)
-                self._update_bec_service_container(
-                    service_name=service_name, status=msg.status, info=msg.info, metrics=metrics
-                )
-                bec_core_state = (
-                    "RUNNING" if (msg.status.value > 1 and bec_core_state == "RUNNING") else "ERROR"
-                )
+            msg = services_info.pop(service_name, None)
+            if msg is None:
+                msg = StatusMessage(name=service_name, status=BECStatus.ERROR, info={})
+            if service_name not in self.status_container:
+                self.add_tree_item(service_name, msg.status, msg.info, metrics)
 
-            if service_name in self.tree_items:
-                self.service_update.emit(self.bec_service_info_container[service_name].model_dump())
-                continue
-            self.add_tree_item(service_name, msg.status, msg.info, metrics)
+            self._update_status_container(service_name, msg.status, msg.info, metrics)
+            core_state = msg.status if msg.status.value < core_state.value else core_state
 
-        self.bec_core_state.emit(bec_core_state)
+            self.service_update.emit(self.status_container[service_name]["info"])
+
+            # self.add_tree_item(service_name, msg.status, msg.info, metrics)
+
+        self.bec_core_state.emit(core_state.name if core_state else "NOTCONNECTED")
         return services_info
 
-    def check_redundant_tree_items(self, checked: list) -> None:
-        """Utility method to check and remove redundant objects from the BECStatusBox.
-
-        Args:
-            checked (list): A list of services that are currently running.
-        """
-        to_be_deleted = [key for key in self.tree_items if key not in checked]
-
-        for key in to_be_deleted:
-            item, _ = self.tree_items.pop(key)
-            self.tree_top_item.removeChild(item)
-
     def add_tree_item(
         self, service_name: str, status: BECStatus, info: dict = None, metrics: dict = None
     ) -> None:
@@ -298,30 +220,18 @@ class BECStatusBox(BECConnector, QTreeWidget):
 
         Args:
             service_name (str): The name of the service.
-            service_status_msg (StatusMessage): The status of the service.
+            status (BECStatus): The status of the service.
+            info (dict): The information about the service.
             metrics (dict): The metrics of the service.
         """
-        item_widget = self._create_status_widget(
-            service_name=service_name, status=status, info=info, metrics=metrics
-        )
-        item = QTreeWidgetItem()
+        item_widget = self._create_status_widget(service_name, status, info, metrics)
+        toplevel_item = self.status_container[self.box_name]["item"]
+        item = QTreeWidgetItem(toplevel_item)  # setDisabled=True
+        toplevel_item.addChild(item)
+        self.tree.setItemWidget(item, 0, item_widget)
         self.service_update.connect(item_widget.update_config)
-        self.tree_top_item.addChild(item)
-        self.setItemWidget(item, 0, item_widget)
-        self.tree_items.update({service_name: (item, item_widget)})
 
-    def init_ui_tree_widget(self) -> None:
-        """Initialise the tree widget for the status box."""
-        self.setHeaderHidden(True)
-        self.setStyleSheet(
-            "QTreeWidget::item:!selected "
-            "{ "
-            "border: 1px solid gainsboro; "
-            "border-left: none; "
-            "border-top: none; "
-            "}"
-            "QTreeWidget::item:selected {}"
-        )
+        self.status_container[service_name].update({"item": item, "widget": item_widget})
 
     @Slot(QTreeWidgetItem, int)
     def on_tree_item_double_clicked(self, item: QTreeWidgetItem, column: int) -> None:
@@ -331,24 +241,47 @@ class BECStatusBox(BECConnector, QTreeWidget):
             item (QTreeWidgetItem): The item that was double clicked.
             column (int): The column that was double clicked.
         """
-        for _, (tree_item, status_widget) in self.tree_items.items():
-            if tree_item == item:
-                status_widget.show_popup()
+        for _, objects in self.status_container.items():
+            if objects["item"] == item:
+                objects["widget"].show_popup()
 
     def closeEvent(self, event):
-        super().cleanup()
-        QTreeWidget().closeEvent(event)
+        self.connector.cleanup()
 
 
 def main():
     """Main method to run the BECStatusBox widget."""
+
     # pylint: disable=import-outside-toplevel
+    from bec_lib.client import BECClient
+    from bec_lib.logger import bec_logger
+    from bec_lib.service_config import ServiceConfig
     from qtpy.QtWidgets import QApplication
 
+    from bec_widgets.utils.bec_dispatcher import QtRedisConnector
+
+    # logging has to be configured before create QApplication,
+    # otherwise it ends badly with segfault...
+    # (seems to be a threading issue with loguru and probably Redis connector,
+    # which has to be a QtRedisConnector for Qt apps... Otherwise it is not
+    # thread-safe somehow ; didn't want to debug all this now)
+    logger = bec_logger.logger
+
+    service_config = ServiceConfig()
+    bec_logger.configure(
+        service_config.redis,
+        QtRedisConnector,
+        service_name="test_status_box",
+        service_config=service_config.service_config,
+    )
+
     app = QApplication(sys.argv)
+
     qdarktheme.setup_theme("auto")
-    main_window = BECStatusBox()
-    main_window.show()
+
+    client = BECClient()
+    status = BECStatusBox(parent=None, client=client, gui_id="test")
+    status.show()
     sys.exit(app.exec())
 
 

bec_widgets/widgets/bec_status_box/bec_status_box.pyproject

@@ -0,0 +1 @@
+{'files': ['bec_status_box.py']}

bec_widgets/widgets/bec_status_box/bec_status_box_plugin.py

@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.bec_status_box.bec_status_box import BECStatusBox
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECStatusBox' name='bec_status_box'>
+    </widget>
+</ui>
+"""
+
+
+class BECStatusBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECStatusBox(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "bec_status_box"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "BECStatusBox"
+
+    def toolTip(self):
+        return "Widget to display the BECStatus from all active services."
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/bec_status_box/register_bec_status_box.py

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.bec_status_box.bec_status_box_plugin import BECStatusBoxPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECStatusBoxPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/bec_status_box/status_item.py

@@ -2,17 +2,12 @@
 The widget is bound to be used with the BECStatusBox widget."""
 
 import enum
-import sys
 from datetime import datetime
 
-import qdarktheme
 from bec_lib.utils.import_utils import lazy_import_from
-from pydantic import Field
 from qtpy.QtCore import Qt, Slot
 from qtpy.QtWidgets import QDialog, QHBoxLayout, QLabel, QStyle, QVBoxLayout, QWidget
 
-from bec_widgets.utils.bec_connector import ConnectionConfig
-
 # TODO : Put normal imports back when Pydantic gets faster
 BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
 
@@ -27,39 +22,29 @@ class IconsEnum(enum.Enum):
     NOTCONNECTED = "SP_TitleBarContextHelpButton"
 
 
-class StatusWidgetConfig(ConnectionConfig):
-    """Configuration class for the status item widget."""
-
-    service_name: str
-    status: str
-    info: dict
-    metrics: dict | None
-    icon_size: tuple = Field(default=(24, 24), description="The size of the icon in the widget.")
-    font_size: int = Field(16, description="The font size of the text in the widget.")
-
-
 class StatusItem(QWidget):
     """A widget to display the status of a service.
 
     Args:
         parent: The parent widget.
-        config (dict): The configuration for the service.
+        config (dict): The configuration for the service, must be a BECServiceInfoContainer.
     """
 
-    def __init__(self, parent=None, config: dict = None):
-        if config is None:
-            config = StatusWidgetConfig(widget_class=self.__class__.__name__)
-        else:
-            if isinstance(config, dict):
-                config = StatusWidgetConfig(**config)
-            self.config = config
+    def __init__(self, parent: QWidget = None, config=None):
         QWidget.__init__(self, parent=parent)
+        if config is None:
+            # needed because we need parent to be the first argument for QT Designer
+            raise ValueError(
+                "Please initialize the StatusItem with a BECServiceInfoContainer for config, received None."
+            )
+        self.config = config
         self.parent = parent
         self.layout = None
-        self.config = config
-        self._popup_label_ref = {}
         self._label = None
         self._icon = None
+        self.icon_size = (24, 24)
+
+        self._popup_label_ref = {}
         self.init_ui()
 
     def init_ui(self) -> None:
@@ -74,23 +59,21 @@ class StatusItem(QWidget):
         self.update_ui()
 
     @Slot(dict)
-    def update_config(self, config: dict) -> None:
-        """Update the configuration of the status item widget.
-        This method is invoked from the parent widget.
-        The UI values are later updated based on the new configuration.
+    def update_config(self, config) -> None:
+        """Update the config of the status item widget.
 
         Args:
-            config (dict): Config updates from parent widget.
+            config (dict): Config updates from parent widget, must be a BECServiceInfoContainer.
         """
-        if config["service_name"] != self.config.service_name:
+        if self.config is None or config.service_name != self.config.service_name:
             return
-        self.config.status = config["status"]
-        self.config.info = config["info"]
-        self.config.metrics = config["metrics"]
+        self.config = config
         self.update_ui()
 
     def update_ui(self) -> None:
         """Update the UI of the labels, and popup dialog."""
+        if self.config is None:
+            return
         self.set_text()
         self.set_status()
         self._set_popup_text()
@@ -99,8 +82,8 @@ class StatusItem(QWidget):
         """Set the text of the QLabel basae on the config."""
         service = self.config.service_name
         status = self.config.status
-        if "BECClient" in service.split("/"):
-            service = service.split("/")[0] + "/..." + service.split("/")[1][-4:]
+        if len(service.split("/")) > 1 and service.split("/")[0].startswith("BEC"):
+            service = service.split("/", maxsplit=1)[0] + "/..." + service.split("/")[1][-4:]
         if status == "NOTCONNECTED":
             status = "NOT CONNECTED"
         text = f"{service} is {status}"
@@ -110,7 +93,7 @@ class StatusItem(QWidget):
         """Set the status icon for the status item widget."""
         icon_name = IconsEnum[self.config.status].value
         icon = self.style().standardIcon(getattr(QStyle.StandardPixmap, icon_name))
-        self._icon.setPixmap(icon.pixmap(*self.config.icon_size))
+        self._icon.setPixmap(icon.pixmap(*self.icon_size))
         self._icon.setAlignment(Qt.AlignmentFlag.AlignRight)
 
     def show_popup(self) -> None:
@@ -153,19 +136,3 @@ class StatusItem(QWidget):
     def _cleanup_popup_label(self) -> None:
         """Cleanup the popup label."""
         self._popup_label_ref.clear()
-
-
-def main():
-    """Run the status item widget."""
-    # pylint: disable=import-outside-toplevel
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    qdarktheme.setup_theme("auto")
-    main_window = StatusItem()
-    main_window.show()
-    sys.exit(app.exec())
-
-
-if __name__ == "__main__":
-    main()

bec_widgets/widgets/buttons/color_button/color_button.py

@@ -0,0 +1,17 @@
+import pyqtgraph as pg
+
+
+class ColorButton(pg.ColorButton):
+    """
+    A ColorButton that opens a dialog to select a color. Inherits from pyqtgraph.ColorButton.
+    Patches event loop of the ColorDialog, if opened in another QDialog.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def selectColor(self):
+        self.origColor = self.color()
+        self.colorDialog.setCurrentColor(self.color())
+        self.colorDialog.open()
+        self.colorDialog.exec()

bec_widgets/widgets/buttons/color_button/color_button.pyproject

@@ -0,0 +1 @@
+{'files': ['color_button.py']}

bec_widgets/widgets/buttons/color_button/color_button_plugin.py

@@ -0,0 +1,55 @@
+import os
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.buttons.color_button.color_button import ColorButton
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='ColorButton' name='color_button'>
+    </widget>
+</ui>
+"""
+
+
+class ColorButtonPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = ColorButton(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Buttons"
+
+    def icon(self):
+        current_path = os.path.dirname(__file__)
+        icon_path = os.path.join(current_path, "assets", "color_button.png")
+        return QIcon(icon_path)
+
+    def includeFile(self):
+        return "color_button"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "ColorButton"
+
+    def toolTip(self):
+        return "ColorButton which opens a color dialog."
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/buttons/color_button/register_color_button.py

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.buttons.color_button.color_button_plugin import ColorButtonPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(ColorButtonPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/console/console.py

@@ -0,0 +1,496 @@
+"""
+BECConsole is a Qt widget that runs a Bash shell. The widget can be used and
+embedded like any other Qt widget.
+
+BECConsole is powered by Pyte, a Python based terminal emulator
+(https://github.com/selectel/pyte).
+"""
+
+import fcntl
+import html
+import os
+import pty
+import subprocess
+import sys
+import threading
+
+import pyte
+from qtpy import QtCore, QtGui, QtWidgets
+from qtpy.QtCore import QSize, QSocketNotifier, Qt
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtGui import QClipboard, QTextCursor
+from qtpy.QtWidgets import QApplication, QHBoxLayout, QScrollBar, QSizePolicy
+
+ansi_colors = {
+    "black": "#000000",
+    "red": "#CD0000",
+    "green": "#00CD00",
+    "brown": "#996633",  # Brown, replacing the yellow
+    "blue": "#0000EE",
+    "magenta": "#CD00CD",
+    "cyan": "#00CDCD",
+    "white": "#E5E5E5",
+    "brightblack": "#7F7F7F",
+    "brightred": "#FF0000",
+    "brightgreen": "#00FF00",
+    "brightyellow": "#FFFF00",
+    "brightblue": "#5C5CFF",
+    "brightmagenta": "#FF00FF",
+    "brightcyan": "#00FFFF",
+    "brightwhite": "#FFFFFF",
+}
+
+control_keys_mapping = {
+    QtCore.Qt.Key_A: b"\x01",  # Ctrl-A
+    QtCore.Qt.Key_B: b"\x02",  # Ctrl-B
+    QtCore.Qt.Key_C: b"\x03",  # Ctrl-C
+    QtCore.Qt.Key_D: b"\x04",  # Ctrl-D
+    QtCore.Qt.Key_E: b"\x05",  # Ctrl-E
+    QtCore.Qt.Key_F: b"\x06",  # Ctrl-F
+    QtCore.Qt.Key_G: b"\x07",  # Ctrl-G (Bell)
+    QtCore.Qt.Key_H: b"\x08",  # Ctrl-H (Backspace)
+    QtCore.Qt.Key_I: b"\x09",  # Ctrl-I (Tab)
+    QtCore.Qt.Key_J: b"\x0A",  # Ctrl-J (Line Feed)
+    QtCore.Qt.Key_K: b"\x0B",  # Ctrl-K (Vertical Tab)
+    QtCore.Qt.Key_L: b"\x0C",  # Ctrl-L (Form Feed)
+    QtCore.Qt.Key_M: b"\x0D",  # Ctrl-M (Carriage Return)
+    QtCore.Qt.Key_N: b"\x0E",  # Ctrl-N
+    QtCore.Qt.Key_O: b"\x0F",  # Ctrl-O
+    QtCore.Qt.Key_P: b"\x10",  # Ctrl-P
+    QtCore.Qt.Key_Q: b"\x11",  # Ctrl-Q
+    QtCore.Qt.Key_R: b"\x12",  # Ctrl-R
+    QtCore.Qt.Key_S: b"\x13",  # Ctrl-S
+    QtCore.Qt.Key_T: b"\x14",  # Ctrl-T
+    QtCore.Qt.Key_U: b"\x15",  # Ctrl-U
+    QtCore.Qt.Key_V: b"\x16",  # Ctrl-V
+    QtCore.Qt.Key_W: b"\x17",  # Ctrl-W
+    QtCore.Qt.Key_X: b"\x18",  # Ctrl-X
+    QtCore.Qt.Key_Y: b"\x19",  # Ctrl-Y
+    QtCore.Qt.Key_Z: b"\x1A",  # Ctrl-Z
+    QtCore.Qt.Key_Escape: b"\x1B",  # Ctrl-Escape
+    QtCore.Qt.Key_Backslash: b"\x1C",  # Ctrl-\
+    QtCore.Qt.Key_Underscore: b"\x1F",  # Ctrl-_
+}
+
+normal_keys_mapping = {
+    QtCore.Qt.Key_Return: b"\n",
+    QtCore.Qt.Key_Space: b" ",
+    QtCore.Qt.Key_Enter: b"\n",
+    QtCore.Qt.Key_Tab: b"\t",
+    QtCore.Qt.Key_Backspace: b"\x08",
+    QtCore.Qt.Key_Home: b"\x47",
+    QtCore.Qt.Key_End: b"\x4f",
+    QtCore.Qt.Key_Left: b"\x02",
+    QtCore.Qt.Key_Up: b"\x10",
+    QtCore.Qt.Key_Right: b"\x06",
+    QtCore.Qt.Key_Down: b"\x0E",
+    QtCore.Qt.Key_PageUp: b"\x49",
+    QtCore.Qt.Key_PageDown: b"\x51",
+    QtCore.Qt.Key_F1: b"\x1b\x31",
+    QtCore.Qt.Key_F2: b"\x1b\x32",
+    QtCore.Qt.Key_F3: b"\x1b\x33",
+    QtCore.Qt.Key_F4: b"\x1b\x34",
+    QtCore.Qt.Key_F5: b"\x1b\x35",
+    QtCore.Qt.Key_F6: b"\x1b\x36",
+    QtCore.Qt.Key_F7: b"\x1b\x37",
+    QtCore.Qt.Key_F8: b"\x1b\x38",
+    QtCore.Qt.Key_F9: b"\x1b\x39",
+    QtCore.Qt.Key_F10: b"\x1b\x30",
+    QtCore.Qt.Key_F11: b"\x45",
+    QtCore.Qt.Key_F12: b"\x46",
+}
+
+
+def QtKeyToAscii(event):
+    """
+    Convert the Qt key event to the corresponding ASCII sequence for
+    the terminal. This works fine for standard alphanumerical characters, but
+    most other characters require terminal specific control sequences.
+
+    The conversion below works for TERM="linux" terminals.
+    """
+    if sys.platform == "darwin":
+        # special case for MacOS
+        # /!\ Qt maps ControlModifier to CMD
+        # CMD-C, CMD-V for copy/paste
+        # CTRL-C and other modifiers -> key mapping
+        if event.modifiers() == QtCore.Qt.MetaModifier:
+            if event.key() == Qt.Key_Backspace:
+                return control_keys_mapping.get(Qt.Key_W)
+            return control_keys_mapping.get(event.key())
+        elif event.modifiers() == QtCore.Qt.ControlModifier:
+            if event.key() == Qt.Key_C:
+                # copy
+                return "copy"
+            elif event.key() == Qt.Key_V:
+                # paste
+                return "paste"
+            return None
+        else:
+            return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
+    if event.modifiers() == QtCore.Qt.ControlModifier:
+        return control_keys_mapping.get(event.key())
+    else:
+        return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
+
+
+class Screen(pyte.HistoryScreen):
+    def __init__(self, stdin_fd, numColumns, numLines, historyLength):
+        super().__init__(numColumns, numLines, historyLength, ratio=1 / numLines)
+        self._fd = stdin_fd
+
+    def write_process_input(self, data):
+        """Response to CPR request for example"""
+        os.write(self._fd, data.encode("utf-8"))
+
+
+class Backend(QtCore.QObject):
+    """
+    Poll Bash.
+
+    This class will run as a qsocketnotifier (started in ``_TerminalWidget``) and poll the
+    file descriptor of the Bash terminal.
+    """
+
+    # Signals to communicate with ``_TerminalWidget``.
+    startWork = pyqtSignal()
+    dataReady = pyqtSignal(object)
+
+    def __init__(self, fd, numColumns, numLines):
+        super().__init__()
+
+        # File descriptor that connects to Bash process.
+        self.fd = fd
+
+        # Setup Pyte (hard coded display size for now).
+        self.screen = Screen(self.fd, numColumns, numLines, 10000)
+        self.stream = pyte.ByteStream()
+        self.stream.attach(self.screen)
+
+        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
+        self.notifier.activated.connect(self._fd_readable)
+
+    def _fd_readable(self):
+        """
+        Poll the Bash output, run it through Pyte, and notify the main applet.
+        """
+        # Read the shell output until the file descriptor is closed.
+        try:
+            out = os.read(self.fd, 2**16)
+        except OSError:
+            return
+
+        # Feed output into Pyte's state machine and send the new screen
+        # output to the GUI
+        self.stream.feed(out)
+        self.dataReady.emit(self.screen)
+
+
+class BECConsole(QtWidgets.QScrollArea):
+    """Container widget for the terminal text area"""
+
+    def __init__(self, parent=None, numLines=50, numColumns=125):
+        super().__init__(parent)
+
+        self.innerWidget = QtWidgets.QWidget(self)
+        QHBoxLayout(self.innerWidget)
+        self.innerWidget.layout().setContentsMargins(0, 0, 0, 0)
+
+        self.term = _TerminalWidget(self.innerWidget, numLines, numColumns)
+        self.term.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        self.innerWidget.layout().addWidget(self.term)
+
+        self.scroll_bar = QScrollBar(Qt.Vertical, self.term)
+        self.innerWidget.layout().addWidget(self.scroll_bar)
+
+        self.term.set_scroll(self.scroll_bar)
+
+        self.setWidget(self.innerWidget)
+
+    def start(self, cmd=["bec", "--nogui"], deactivate_ctrl_d=True):
+        self.term._cmd = cmd
+        self.term.start(deactivate_ctrl_d=deactivate_ctrl_d)
+
+    def push(self, text):
+        """Push some text to the terminal"""
+        return self.term.push(text)
+
+
+class _TerminalWidget(QtWidgets.QPlainTextEdit):
+    """
+    Start ``Backend`` process and render Pyte output as text.
+    """
+
+    def __init__(self, parent, numColumns, numLines, **kwargs):
+        super().__init__(parent)
+
+        # file descriptor to communicate with the subprocess
+        self.fd = None
+        self.backend = None
+        self.lock = threading.Lock()
+        # command to execute
+        self._cmd = None
+        # should ctrl-d be deactivated ? (prevent Python exit)
+        self._deactivate_ctrl_d = False
+
+        # Specify the terminal size in terms of lines and columns.
+        self.numLines = numLines
+        self.numColumns = numColumns
+        self.output = [""] * numLines
+
+        # Use Monospace fonts and disable line wrapping.
+        self.setFont(QtGui.QFont("Courier", 9))
+        self.setFont(QtGui.QFont("Monospace"))
+        self.setLineWrapMode(QtWidgets.QPlainTextEdit.NoWrap)
+
+        # Disable vertical scrollbar (we use our own, to be set via .set_scroll())
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+
+        fmt = QtGui.QFontMetrics(self.font())
+        self._char_width = fmt.width("w")
+        self._char_height = fmt.height()
+        self.setCursorWidth(self._char_width)
+        # self.setStyleSheet("QPlainTextEdit { color: #ffff00; background-color: #303030; } ");
+
+    def start(self, deactivate_ctrl_d=False):
+        self._deactivate_ctrl_d = deactivate_ctrl_d
+
+        # Start the Bash process
+        self.fd = self.forkShell()
+
+        # Create the ``Backend`` object
+        self.backend = Backend(self.fd, self.numColumns, self.numLines)
+        self.backend.dataReady.connect(self.dataReady)
+
+    def minimumSizeHint(self):
+        width = self._char_width * self.numColumns
+        height = self._char_height * self.numLines
+        return QSize(width, height + 20)
+
+    def set_scroll(self, scroll):
+        self.scroll = scroll
+        self.scroll.setMinimum(0)
+        self.scroll.valueChanged.connect(self.scroll_value_change)
+
+    def scroll_value_change(self, value, old={"value": 0}):
+        if value <= old["value"]:
+            # scroll up
+            # value is number of lines from the start
+            nlines = old["value"] - value
+            # history ratio gives prev_page == 1 line
+            for i in range(nlines):
+                self.backend.screen.prev_page()
+        else:
+            # scroll down
+            nlines = value - old["value"]
+            for i in range(nlines):
+                self.backend.screen.next_page()
+        old["value"] = value
+        self.dataReady(self.backend.screen, reset_scroll=False)
+
+    @pyqtSlot(object)
+    def keyPressEvent(self, event):
+        """
+        Redirect all keystrokes to the terminal process.
+        """
+        # Convert the Qt key to the correct ASCII code.
+        if (
+            self._deactivate_ctrl_d
+            and event.modifiers() == QtCore.Qt.ControlModifier
+            and event.key() == QtCore.Qt.Key_D
+        ):
+            return None
+
+        code = QtKeyToAscii(event)
+        if code == "copy":
+            # MacOS only: CMD-C handling
+            self.copy()
+        elif code == "paste":
+            # MacOS only: CMD-V handling
+            self._push_clipboard()
+        elif code is not None:
+            os.write(self.fd, code)
+
+    def push(self, text):
+        """
+        Write 'text' to terminal
+        """
+        os.write(self.fd, text.encode("utf-8"))
+
+    def contextMenuEvent(self, event):
+        menu = self.createStandardContextMenu()
+        for action in menu.actions():
+            # remove all actions except copy and paste
+            if "opy" in action.text():
+                # redefine text without shortcut
+                # since it probably clashes with control codes (like CTRL-C etc)
+                action.setText("Copy")
+                continue
+            if "aste" in action.text():
+                # redefine text without shortcut
+                action.setText("Paste")
+                # paste -> have to insert with self.push
+                action.triggered.connect(self._push_clipboard)
+                continue
+            menu.removeAction(action)
+        menu.exec_(event.globalPos())
+
+    def _push_clipboard(self):
+        clipboard = QApplication.instance().clipboard()
+        self.push(clipboard.text())
+
+    def mouseReleaseEvent(self, event):
+        if event.button() == Qt.MiddleButton:
+            # push primary selection buffer ("mouse clipboard") to terminal
+            clipboard = QApplication.instance().clipboard()
+            if clipboard.supportsSelection():
+                self.push(clipboard.text(QClipboard.Selection))
+            return None
+        elif event.button() == Qt.LeftButton:
+            # left button click
+            textCursor = self.textCursor()
+            if textCursor.selectedText():
+                # mouse was used to select text -> nothing to do
+                pass
+            else:
+                # a simple 'click', make cursor going to end
+                textCursor.setPosition(0)
+                textCursor.movePosition(
+                    QTextCursor.Down, QTextCursor.MoveAnchor, self.backend.screen.cursor.y
+                )
+                textCursor.movePosition(
+                    QTextCursor.Right, QTextCursor.MoveAnchor, self.backend.screen.cursor.x
+                )
+                self.setTextCursor(textCursor)
+                self.ensureCursorVisible()
+                return None
+        return super().mouseReleaseEvent(event)
+
+    def dataReady(self, screenData, reset_scroll=True):
+        """
+        Render the new screen as text into the widget.
+
+        This method is triggered via a signal from ``Backend``.
+        """
+        with self.lock:
+            # Clear the widget
+            self.clear()
+
+            # Prepare the HTML output
+            for line_no in screenData.dirty:
+                line = text = ""
+                style = old_style = ""
+                for ch in screenData.buffer[line_no].values():
+                    style = f"{'background-color:%s;' % ansi_colors.get(ch.bg, ansi_colors['black']) if ch.bg!='default' else ''}{'color:%s;' % ansi_colors.get(ch.fg, ansi_colors['white']) if ch.fg!='default' else ''}{'font-weight:bold;' if ch.bold else ''}{'font-style:italic;' if ch.italics else ''}"
+                    if style != old_style:
+                        if old_style:
+                            line += f"<span style={repr(old_style)}>{html.escape(text, quote=True)}</span>"
+                        else:
+                            line += html.escape(text, quote=True)
+                        text = ""
+                        old_style = style
+                    text += ch.data
+                if style:
+                    line += f"<span style={repr(style)}>{html.escape(text, quote=True)}</span>"
+                else:
+                    line += html.escape(text, quote=True)
+                self.output[line_no] = line
+            # fill the text area with HTML contents in one go
+            self.appendHtml(f"<pre>{chr(10).join(self.output)}</pre>")
+            # done updates, all clean
+            screenData.dirty.clear()
+
+            # Activate cursor
+            textCursor = self.textCursor()
+            textCursor.setPosition(0)
+            textCursor.movePosition(QTextCursor.Down, QTextCursor.MoveAnchor, screenData.cursor.y)
+            textCursor.movePosition(QTextCursor.Right, QTextCursor.MoveAnchor, screenData.cursor.x)
+            self.setTextCursor(textCursor)
+            self.ensureCursorVisible()
+
+            # manage scroll
+            if reset_scroll:
+                self.scroll.valueChanged.disconnect(self.scroll_value_change)
+                tmp = len(self.backend.screen.history.top) + len(self.backend.screen.history.bottom)
+                self.scroll.setMaximum(tmp if tmp > 0 else 0)
+                self.scroll.setSliderPosition(len(self.backend.screen.history.top))
+                self.scroll.valueChanged.connect(self.scroll_value_change)
+
+    # def resizeEvent(self, event):
+    #    with self.lock:
+    #        self.numColumns = int(self.width() / self._char_width)
+    #        self.numLines = int(self.height() / self._char_height)
+    #        self.output = [""] * self.numLines
+    #        print("RESIZING TO", self.numColumns, "x", self.numLines)
+    #        self.backend.screen.resize(self.numLines, self.numColumns)
+
+    def wheelEvent(self, event):
+        y = event.angleDelta().y()
+        if y > 0:
+            self.backend.screen.prev_page()
+        else:
+            self.backend.screen.next_page()
+        self.dataReady(self.backend.screen, reset_scroll=False)
+
+    def forkShell(self):
+        """
+        Fork the current process and execute bec in shell.
+        """
+        try:
+            pid, fd = pty.fork()
+        except (IOError, OSError):
+            return False
+        if pid == 0:
+            # Safe way to make it work under BSD and Linux
+            try:
+                ls = os.environ["LANG"].split(".")
+            except KeyError:
+                ls = []
+            if len(ls) < 2:
+                ls = ["en_US", "UTF-8"]
+            try:
+                os.putenv("COLUMNS", str(self.numColumns))
+                os.putenv("LINES", str(self.numLines))
+                os.putenv("TERM", "linux")
+                os.putenv("LANG", ls[0] + ".UTF-8")
+                if isinstance(self._cmd, str):
+                    os.execvp(self._cmd, self._cmd)
+                else:
+                    os.execvp(self._cmd[0], self._cmd)
+                # print "child_pid", child_pid, sts
+            except (IOError, OSError):
+                pass
+            # self.proc_finish(sid)
+            os._exit(0)
+        else:
+            # We are in the parent process.
+            # Set file control
+            fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK)
+            print("Spawned Bash shell (PID {})".format(pid))
+            return fd
+
+
+if __name__ == "__main__":
+    import os
+    import sys
+
+    from qtpy import QtGui, QtWidgets
+
+    # Terminal size in characters.
+    numLines = 25
+    numColumns = 100
+
+    # Create the Qt application and QBash instance.
+    app = QtWidgets.QApplication([])
+    mainwin = QtWidgets.QMainWindow()
+    title = "BECConsole ({}x{})".format(numColumns, numLines)
+    mainwin.setWindowTitle(title)
+
+    console = BECConsole(mainwin, numColumns, numLines)
+    mainwin.setCentralWidget(console)
+    console.start()
+
+    # Show widget and launch Qt's event loop.
+    mainwin.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/dock/dock.py

@@ -26,8 +26,8 @@ class DockConfig(ConnectionConfig):
 
 class BECDock(BECConnector, Dock):
     USER_ACCESS = [
-        "config_dict",
-        "rpc_id",
+        "_config_dict",
+        "_rpc_id",
         "widget_list",
         "show_title_bar",
         "hide_title_bar",

bec_widgets/widgets/dock/dock_area.py

@@ -23,7 +23,7 @@ class DockAreaConfig(ConnectionConfig):
 
 class BECDockArea(BECConnector, DockArea):
     USER_ACCESS = [
-        "config_dict",
+        "_config_dict",
         "panels",
         "save_state",
         "remove_dock",
@@ -32,7 +32,7 @@ class BECDockArea(BECConnector, DockArea):
         "clear_all",
         "detach_dock",
         "attach_all",
-        "get_all_rpc",
+        "_get_all_rpc",
         "temp_areas",
     ]
 

bec_widgets/widgets/figure/figure.py

@@ -8,7 +8,7 @@ from typing import Literal, Optional
 import numpy as np
 import pyqtgraph as pg
 import qdarktheme
-from pydantic import Field
+from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtWidgets import QWidget
 from typeguard import typechecked
@@ -30,16 +30,36 @@ class FigureConfig(ConnectionConfig):
         {}, description="The list of widgets to be added to the figure widget."
     )
 
+    @field_validator("widgets", mode="before")
+    @classmethod
+    def validate_widgets(cls, v):
+        """Validate the widgets configuration."""
+        widget_class_map = {
+            "BECWaveform": Waveform1DConfig,
+            "BECImageShow": ImageConfig,
+            "BECMotorMap": MotorMapConfig,
+        }
+        validated_widgets = {}
+        for key, widget_config in v.items():
+            if "widget_class" not in widget_config:
+                raise ValueError(f"Widget config for {key} does not contain 'widget_class'.")
+            widget_class = widget_config["widget_class"]
+            if widget_class not in widget_class_map:
+                raise ValueError(f"Unknown widget_class '{widget_class}' for widget '{key}'.")
+            config_class = widget_class_map[widget_class]
+            validated_widgets[key] = config_class(**widget_config)
+        return validated_widgets
+
 
 class WidgetHandler:
     """Factory for creating and configuring BEC widgets for BECFigure."""
 
     def __init__(self):
         self.widget_factory = {
-            "PlotBase": (BECPlotBase, SubplotConfig),
-            "Waveform1D": (BECWaveform, Waveform1DConfig),
-            "ImShow": (BECImageShow, ImageConfig),
-            "MotorMap": (BECMotorMap, MotorMapConfig),
+            "BECPlotBase": (BECPlotBase, SubplotConfig),
+            "BECWaveform": (BECWaveform, Waveform1DConfig),
+            "BECImageShow": (BECImageShow, ImageConfig),
+            "BECMotorMap": (BECMotorMap, MotorMapConfig),
         }
 
     def create_widget(
@@ -90,13 +110,11 @@ class WidgetHandler:
 
 class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
+        "_get_all_rpc",
         "axes",
         "widgets",
-        "add_plot",
-        "add_image",
-        "add_motor_map",
         "plot",
         "image",
         "motor_map",
@@ -104,9 +122,15 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         "change_layout",
         "change_theme",
         "clear_all",
-        "get_all_rpc",
         "widget_list",
     ]
+    subplot_map = {
+        "PlotBase": BECPlotBase,
+        "BECWaveform": BECWaveform,
+        "BECImageShow": BECImageShow,
+        "BECMotorMap": BECMotorMap,
+    }
+    widget_method_map = {"BECWaveform": "plot", "BECImageShow": "image", "BECMotorMap": "motor_map"}
 
     clean_signal = pyqtSignal()
 
@@ -122,8 +146,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         else:
             if isinstance(config, dict):
                 config = FigureConfig(**config)
-            self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id)
+        super().__init__(client=client, gui_id=gui_id)
         pg.GraphicsLayoutWidget.__init__(self, parent)
 
         self.widget_handler = WidgetHandler()
@@ -133,6 +156,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
         # Container to keep track of the grid
         self.grid = []
+        # Create config and apply it
+        self.apply_config(config)
 
     def __getitem__(self, key: tuple | str):
         if isinstance(key, tuple) and len(key) == 2:
@@ -147,6 +172,24 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
                 "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
             )
 
+    def apply_config(self, config: dict | FigureConfig):  # ,generate_new_id: bool = False):
+        if isinstance(config, dict):
+            try:
+                config = FigureConfig(**config)
+            except ValidationError as e:
+                print(f"Error in applying config: {e}")
+                return
+        self.config = config
+        self.change_theme(self.config.theme)
+
+        # widget_config has to be reset for not have each widget config twice when added to the figure
+        widget_configs = [config for config in self.config.widgets.values()]
+        self.config.widgets = {}
+        for widget_config in widget_configs:
+            getattr(self, self.widget_method_map[widget_config.widget_class])(
+                config=widget_config.model_dump(), row=widget_config.row, col=widget_config.col
+            )
+
     @property
     def widget_list(self) -> list[BECPlotBase]:
         """
@@ -200,7 +243,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         label: str | None = None,
         validate: bool = True,
         dap: str | None = None,
-    ):
+    ) -> BECWaveform:
         """
         Configure the waveform based on the provided parameters.
 
@@ -279,75 +322,6 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
         return waveform
 
-    def add_plot(
-        self,
-        x: list | np.ndarray = None,
-        y: list | np.ndarray = None,
-        x_name: str = None,
-        y_name: str = None,
-        z_name: str = None,
-        x_entry: str = None,
-        y_entry: str = None,
-        z_entry: str = None,
-        color: Optional[str] = None,
-        color_map_z: Optional[str] = "plasma",
-        label: Optional[str] = None,
-        validate: bool = True,
-        row: int = None,
-        col: int = None,
-        config=None,
-        dap: str | None = None,
-        **axis_kwargs,
-    ) -> BECWaveform:
-        """
-        Add a Waveform1D plot to the figure at the specified position.
-
-        Args:
-            x(list | np.ndarray): Custom x data to plot.
-            y(list | np.ndarray): Custom y data to plot.
-            x_name(str): The name of the device for the x-axis.
-            y_name(str): The name of the device for the y-axis.
-            z_name(str): The name of the device for the z-axis.
-            x_entry(str): The name of the entry for the x-axis.
-            y_entry(str): The name of the entry for the y-axis.
-            z_entry(str): The name of the entry for the z-axis.
-            color(str): The color of the curve.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str): The label of the curve.
-            validate(bool): If True, validate the device names and entries.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
-        """
-        widget_id = str(uuid.uuid4())
-        waveform = self.add_widget(
-            widget_type="Waveform1D",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
-        )
-
-        waveform = self._init_waveform(
-            waveform=waveform,
-            x=x,
-            y=y,
-            x_name=x_name,
-            y_name=y_name,
-            z_name=z_name,
-            x_entry=x_entry,
-            y_entry=y_entry,
-            z_entry=z_entry,
-            color=color,
-            color_map_z=color_map_z,
-            label=label,
-            validate=validate,
-            dap=dap,
-        )
-        return waveform
-
     @typechecked
     def plot(
         self,
@@ -363,7 +337,11 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         color_map_z: str | None = "plasma",
         label: str | None = None,
         validate: bool = True,
+        new: bool = False,
+        row: int | None = None,
+        col: int | None = None,
         dap: str | None = None,
+        config: dict | None = None,  # TODO make logic more transparent
         **axis_kwargs,
     ) -> BECWaveform:
         """
@@ -382,21 +360,23 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             color_map_z(str): The color map to use for the z-axis.
             label(str): The label of the curve.
             validate(bool): If True, validate the device names and entries.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
             dap(str): The DAP model to use for the curve.
+            config(dict): Recreates the whole BECWaveform widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
             BECWaveform: The waveform plot widget.
         """
-        waveform = WidgetContainerUtils.find_first_widget_by_class(
-            self._widgets, BECWaveform, can_fail=True
+        waveform = self.subplot_factory(
+            widget_type="BECWaveform", config=config, row=row, col=col, new=new, **axis_kwargs
         )
-        if waveform is not None:
-            if axis_kwargs:
-                waveform.set(**axis_kwargs)
-        else:
-            waveform = self.add_plot(**axis_kwargs)
+        if config is not None:
+            return waveform
 
+        # Passing args to init_waveform
         waveform = self._init_waveform(
             waveform=waveform,
             x=x,
@@ -413,7 +393,6 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             validate=validate,
             dap=dap,
         )
-        # TODO remove repetition from .plot method
         return waveform
 
     def _init_image(
@@ -460,6 +439,10 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         color_map: str = "magma",
         data: np.ndarray = None,
         vrange: tuple[float, float] = None,
+        new: bool = False,
+        row: int | None = None,
+        col: int | None = None,
+        config: dict | None = None,
         **axis_kwargs,
     ) -> BECImageShow:
         """
@@ -471,78 +454,22 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             color_map(str): The color map to use for the image.
             data(np.ndarray): Custom data to display.
             vrange(tuple[float, float]): The range of values to display.
-            **axis_kwargs: Additional axis properties to set on the widget after creation.
-
-        Returns:
-            BECImageShow: The image widget.
-        """
-        image = WidgetContainerUtils.find_first_widget_by_class(
-            self._widgets, BECImageShow, can_fail=True
-        )
-        if image is not None:
-            if axis_kwargs:
-                image.set(**axis_kwargs)
-        else:
-            image = self.add_image(color_bar=color_bar, **axis_kwargs)
-
-        image = self._init_image(
-            image=image,
-            monitor=monitor,
-            color_bar=color_bar,
-            color_map=color_map,
-            data=data,
-            vrange=vrange,
-        )
-        return image
-
-    def add_image(
-        self,
-        monitor: str = None,
-        color_bar: Literal["simple", "full"] = "full",
-        color_map: str = "magma",
-        data: np.ndarray = None,
-        vrange: tuple[float, float] = None,
-        row: int = None,
-        col: int = None,
-        config=None,
-        **axis_kwargs,
-    ) -> BECImageShow:
-        """
-        Add an image to the figure at the specified position.
-
-        Args:
-            monitor(str): The name of the monitor to display.
-            color_bar(Literal["simple","full"]): The type of color bar to display.
-            color_map(str): The color map to use for the image.
-            data(np.ndarray): Custom data to display.
-            vrange(tuple[float, float]): The range of values to display.
+            new(bool): If True, create a new plot instead of using the first plot.
             row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
             col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
+            config(dict): Recreates the whole BECImageShow widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
             BECImageShow: The image widget.
         """
 
-        widget_id = str(uuid.uuid4())
-        if config is None:
-            config = ImageConfig(
-                widget_class="BECImageShow",
-                gui_id=widget_id,
-                parent_id=self.gui_id,
-                color_map=color_map,
-                color_bar=color_bar,
-                vrange=vrange,
-            )
-        image = self.add_widget(
-            widget_type="ImShow",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
+        image = self.subplot_factory(
+            widget_type="BECImageShow", config=config, row=row, col=col, new=new, **axis_kwargs
         )
+        if config is not None:
+            return image
+
         image = self._init_image(
             image=image,
             monitor=monitor,
@@ -553,76 +480,99 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         )
         return image
 
-    def motor_map(self, motor_x: str = None, motor_y: str = None, **axis_kwargs) -> BECMotorMap:
+    def motor_map(
+        self,
+        motor_x: str = None,
+        motor_y: str = None,
+        new: bool = False,
+        row: int | None = None,
+        col: int | None = None,
+        config: dict | None = None,
+        **axis_kwargs,
+    ) -> BECMotorMap:
         """
         Add a motor map to the figure. Always access the first motor map widget in the figure.
 
         Args:
             motor_x(str): The name of the motor for the X axis.
             motor_y(str): The name of the motor for the Y axis.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Recreates the whole BECImageShow widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
             BECMotorMap: The motor map widget.
         """
-        motor_map = WidgetContainerUtils.find_first_widget_by_class(
-            self._widgets, BECMotorMap, can_fail=True
+        motor_map = self.subplot_factory(
+            widget_type="BECMotorMap", config=config, row=row, col=col, new=new, **axis_kwargs
         )
-        if motor_map is not None:
-            if axis_kwargs:
-                motor_map.set(**axis_kwargs)
-        else:
-            motor_map = self.add_motor_map(**axis_kwargs)
+        if config is not None:
+            return motor_map
 
         if motor_x is not None and motor_y is not None:
             motor_map.change_motors(motor_x, motor_y)
 
         return motor_map
 
-    def add_motor_map(
+    def subplot_factory(
         self,
-        motor_x: str = None,
-        motor_y: str = None,
+        widget_type: Literal[
+            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap"
+        ] = "BECPlotBase",
         row: int = None,
         col: int = None,
         config=None,
+        new: bool = False,
         **axis_kwargs,
-    ) -> BECMotorMap:
-        """
-
-        Args:
-            motor_x(str): The name of the motor for the X axis.
-            motor_y(str): The name of the motor for the Y axis.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs:
-
-        Returns:
-            BECMotorMap: The motor map widget.
-        """
-        widget_id = str(uuid.uuid4())
-        if config is None:
-            config = MotorMapConfig(
-                widget_class="BECMotorMap", gui_id=widget_id, parent_id=self.gui_id
+    ) -> BECPlotBase:
+        # Case 1 - config provided, new plot, possible to define coordinates
+        if config is not None:
+            widget_cls = config["widget_class"]
+            if widget_cls != widget_type:
+                raise ValueError(
+                    f"Widget type '{widget_type}' does not match the provided configuration ({widget_cls})."
+                )
+            widget = self.add_widget(
+                widget_type=widget_type, config=config, row=row, col=col, **axis_kwargs
             )
-        motor_map = self.add_widget(
-            widget_type="MotorMap",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
-        )
+            return widget
 
-        if motor_x is not None and motor_y is not None:
-            motor_map.change_motors(motor_x, motor_y)
+        # Case 2 - find first plot or create first plot if no plot available, no config provided, no coordinates
+        if new is False and (row is None or col is None):
+            widget = WidgetContainerUtils.find_first_widget_by_class(
+                self._widgets, self.subplot_map[widget_type], can_fail=True
+            )
+            if widget is not None:
+                if axis_kwargs:
+                    widget.set(**axis_kwargs)
+            else:
+                widget = self.add_widget(widget_type=widget_type, **axis_kwargs)
+            return widget
 
-        return motor_map
+        # Case 3 - modifying existing plot wit coordinates provided
+        if new is False and (row is not None and col is not None):
+            try:
+                widget = self.axes(row, col)
+            except ValueError:
+                widget = None
+            if widget is not None:
+                if axis_kwargs:
+                    widget.set(**axis_kwargs)
+            else:
+                widget = self.add_widget(widget_type=widget_type, row=row, col=col, **axis_kwargs)
+            return widget
+
+        # Case 4 - no previous plot or new plot, no config provided, possible to define coordinates
+        widget = self.add_widget(widget_type=widget_type, row=row, col=col, **axis_kwargs)
+        return widget
 
     def add_widget(
         self,
-        widget_type: Literal["PlotBase", "Waveform1D", "ImShow"] = "PlotBase",
+        widget_type: Literal[
+            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap"
+        ] = "BECPlotBase",
         widget_id: str = None,
         row: int = None,
         col: int = None,
@@ -653,6 +603,9 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             config=config,
             **axis_kwargs,
         )
+        # has to be changed manually to ensure unique id, if config is copied from existing widget, the id could be
+        # used otherwise multiple times
+        widget.set_gui_id(widget_id)
 
         # Check if position is occupied
         if row is not None and col is not None:
@@ -756,6 +709,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             self._reindex_grid()
             if widget_id in self.config.widgets:
                 self.config.widgets.pop(widget_id)
+            widget.deleteLater()
         else:
             raise ValueError(f"Widget with ID '{widget_id}' does not exist.")
 

bec_widgets/widgets/figure/plots/axis_settings.py

@@ -0,0 +1,61 @@
+import os
+
+import qdarktheme
+from qtpy.QtCore import Slot
+from qtpy.QtWidgets import QVBoxLayout, QWidget
+
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.widget_io import WidgetIO
+
+
+class AxisSettings(QWidget):
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent=parent, *args, **kwargs)
+
+        current_path = os.path.dirname(__file__)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "axis_settings.ui"), self)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.ui)
+
+        # Hardcoded values for best appearance
+        self.setMinimumHeight(280)
+        self.setMaximumHeight(280)
+        self.resize(380, 280)
+
+    @Slot(dict)
+    def display_current_settings(self, axis_config: dict):
+        # Top Box
+        WidgetIO.set_value(self.ui.plot_title, axis_config["title"])
+
+        # X Axis Box
+        WidgetIO.set_value(self.ui.x_label, axis_config["x_label"])
+        WidgetIO.set_value(self.ui.x_scale, axis_config["x_scale"])
+        WidgetIO.set_value(self.ui.x_grid, axis_config["x_grid"])
+        if axis_config["x_lim"] is not None:
+            WidgetIO.check_and_adjust_limits(self.ui.x_min, axis_config["x_lim"][0])
+            WidgetIO.check_and_adjust_limits(self.ui.x_max, axis_config["x_lim"][1])
+            WidgetIO.set_value(self.ui.x_min, axis_config["x_lim"][0])
+            WidgetIO.set_value(self.ui.x_max, axis_config["x_lim"][1])
+
+        # Y Axis Box
+        WidgetIO.set_value(self.ui.y_label, axis_config["y_label"])
+        WidgetIO.set_value(self.ui.y_scale, axis_config["y_scale"])
+        WidgetIO.set_value(self.ui.y_grid, axis_config["y_grid"])
+        if axis_config["y_lim"] is not None:
+            WidgetIO.check_and_adjust_limits(self.ui.y_min, axis_config["y_lim"][0])
+            WidgetIO.check_and_adjust_limits(self.ui.y_max, axis_config["y_lim"][1])
+            WidgetIO.set_value(self.ui.y_min, axis_config["y_lim"][0])
+            WidgetIO.set_value(self.ui.y_max, axis_config["y_lim"][1])
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    qdarktheme.setup_theme("dark")
+    window = AxisSettings()
+    window.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/figure/plots/axis_settings.ui

@@ -0,0 +1,249 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+    <class>Form</class>
+    <widget class="QWidget" name="Form">
+        <property name="geometry">
+            <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>417</width>
+                <height>250</height>
+            </rect>
+        </property>
+        <property name="minimumSize">
+            <size>
+                <width>0</width>
+                <height>250</height>
+            </size>
+        </property>
+        <property name="maximumSize">
+            <size>
+                <width>16777215</width>
+                <height>278</height>
+            </size>
+        </property>
+        <property name="windowTitle">
+            <string>Form</string>
+        </property>
+        <layout class="QGridLayout" name="gridLayout">
+            <item row="0" column="0" colspan="3">
+                <layout class="QHBoxLayout" name="horizontalLayout">
+                    <item>
+                        <widget class="QLabel" name="plot_title_label">
+                            <property name="text">
+                                <string>Plot Title</string>
+                            </property>
+                        </widget>
+                    </item>
+                    <item>
+                        <widget class="QLineEdit" name="plot_title"/>
+                    </item>
+                </layout>
+            </item>
+            <item row="1" column="0" colspan="3">
+                <widget class="Line" name="line_H">
+                    <property name="orientation">
+                        <enum>Qt::Orientation::Horizontal</enum>
+                    </property>
+                </widget>
+            </item>
+            <item row="2" column="0">
+                <widget class="QGroupBox" name="x_axis_box">
+                    <property name="title">
+                        <string>X Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_4">
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="x_scale_label">
+                                <property name="text">
+                                    <string>Scale</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="QDoubleSpinBox" name="x_min">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="x_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="2">
+                            <widget class="QDoubleSpinBox" name="x_max">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="2">
+                            <widget class="QComboBox" name="x_scale">
+                                <item>
+                                    <property name="text">
+                                        <string>linear</string>
+                                    </property>
+                                </item>
+                                <item>
+                                    <property name="text">
+                                        <string>log</string>
+                                    </property>
+                                </item>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="x_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="x_label"/>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="x_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="2">
+                            <widget class="QCheckBox" name="x_grid">
+                                <property name="text">
+                                    <string/>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="x_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+            <item row="2" column="1">
+                <widget class="Line" name="line_V">
+                    <property name="orientation">
+                        <enum>Qt::Orientation::Vertical</enum>
+                    </property>
+                </widget>
+            </item>
+            <item row="2" column="2">
+                <widget class="QGroupBox" name="y_axis_box">
+                    <property name="title">
+                        <string>Y Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_5">
+                        <item row="3" column="2">
+                            <widget class="QComboBox" name="y_scale">
+                                <item>
+                                    <property name="text">
+                                        <string>linear</string>
+                                    </property>
+                                </item>
+                                <item>
+                                    <property name="text">
+                                        <string>log</string>
+                                    </property>
+                                </item>
+                            </widget>
+                        </item>
+                        <item row="2" column="2">
+                            <widget class="QDoubleSpinBox" name="y_max">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="y_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="QDoubleSpinBox" name="y_min">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="y_label"/>
+                        </item>
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="y_scale_label">
+                                <property name="text">
+                                    <string>Scale</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="y_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="y_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="2">
+                            <widget class="QCheckBox" name="y_grid">
+                                <property name="text">
+                                    <string/>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="y_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+        </layout>
+    </widget>
+    <resources/>
+    <connections/>
+</ui>

bec_widgets/widgets/figure/plots/image/image.py

@@ -5,7 +5,7 @@ from typing import Any, Literal, Optional
 
 import numpy as np
 from bec_lib.endpoints import MessageEndpoints
-from pydantic import Field, ValidationError
+from pydantic import BaseModel, Field, ValidationError
 from qtpy.QtCore import QThread
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget
@@ -29,11 +29,9 @@ class ImageConfig(SubplotConfig):
 
 class BECImageShow(BECPlotBase):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "add_image_by_config",
-        "get_image_config",
-        "get_image_dict",
         "add_monitor_image",
         "add_custom_image",
         "set_vrange",
@@ -47,7 +45,6 @@ class BECImageShow(BECPlotBase):
         "set_log",
         "set_rotation",
         "set_transpose",
-        "toggle_threading",
         "set",
         "set_title",
         "set_x_label",
@@ -138,7 +135,8 @@ class BECImageShow(BECPlotBase):
         self.apply_axis_config()
         self._images = defaultdict(dict)
 
-        # TODO extend by adding image by config
+        for image_id, image_config in config.images.items():
+            self.add_image_by_config(image_config)
 
     def change_gui_id(self, new_gui_id: str):
         """
@@ -226,7 +224,7 @@ class BECImageShow(BECPlotBase):
         self,
         monitor: str,
         color_map: Optional[str] = "magma",
-        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        color_bar: Optional[Literal["simple", "full"]] = "full",
         downsample: Optional[bool] = True,
         opacity: Optional[float] = 1.0,
         vrange: Optional[tuple[int, int]] = None,
@@ -241,7 +239,7 @@ class BECImageShow(BECPlotBase):
                 f"Monitor with ID '{monitor}' already exists in widget '{self.gui_id}'."
             )
 
-        monitor = self.entry_validator.validate_monitor(monitor)
+        # monitor = self.entry_validator.validate_monitor(monitor)
 
         image_config = ImageItemConfig(
             widget_class="BECImageItem",
@@ -251,12 +249,13 @@ class BECImageShow(BECPlotBase):
             downsample=downsample,
             opacity=opacity,
             vrange=vrange,
+            source=image_source,
+            monitor=monitor,
             # post_processing=post_processing,
             **kwargs,
         )
 
         image = self._add_image_object(source=image_source, name=monitor, config=image_config)
-        self._connect_device_monitor(monitor)
         return image
 
     def add_custom_image(
@@ -264,16 +263,17 @@ class BECImageShow(BECPlotBase):
         name: str,
         data: Optional[np.ndarray] = None,
         color_map: Optional[str] = "magma",
-        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        color_bar: Optional[Literal["simple", "full"]] = "full",
         downsample: Optional[bool] = True,
         opacity: Optional[float] = 1.0,
         vrange: Optional[tuple[int, int]] = None,
         # post_processing: Optional[PostProcessingConfig] = None,
         **kwargs,
     ):
-        image_source = "device_monitor"
+        image_source = "custom"
+        # image_source = "device_monitor"
 
-        image_exits = self._check_curve_id(name, self._images)
+        image_exits = self._check_image_id(name, self._images)
         if image_exits:
             raise ValueError(f"Monitor with ID '{name}' already exists in widget '{self.gui_id}'.")
 
@@ -290,7 +290,9 @@ class BECImageShow(BECPlotBase):
             **kwargs,
         )
 
-        image = self._add_image_object(source=image_source, config=image_config, data=data)
+        image = self._add_image_object(
+            source=image_source, name=name, config=image_config, data=data
+        )
         return image
 
     def apply_setting_to_images(
@@ -313,6 +315,7 @@ class BECImageShow(BECPlotBase):
             for source, images in self._images.items():
                 for _, image in images.items():
                     getattr(image, setting_method_name)(*args, **kwargs)
+        self.refresh_image()
 
     def set_vrange(self, vmin: float, vmax: float, name: str = None):
         """
@@ -460,6 +463,27 @@ class BECImageShow(BECPlotBase):
         if self.use_threading is False and self.thread.isRunning():
             self.cleanup()
 
+    def process_image(self, device: str, image: BECImageItem, data: np.ndarray):
+        """
+        Process the image data.
+
+        Args:
+            device(str): The name of the device - image_id of image.
+            image(np.ndarray): The image data to be processed.
+            data(np.ndarray): The image data to be processed.
+
+        Returns:
+            np.ndarray: The processed image data.
+        """
+        processing_config = image.config.processing
+        self.processor.set_config(processing_config)
+        if self.use_threading:
+            self._create_thread_worker(device, data)
+        else:
+            data = self.processor.process_image(data)
+            self.update_image(device, data)
+            self.update_vrange(device, self.processor.config.stats)
+
     @pyqtSlot(dict)
     def on_image_update(self, msg: dict):
         """
@@ -470,15 +494,8 @@ class BECImageShow(BECPlotBase):
         """
         data = msg["data"]
         device = msg["device"]
-        image_to_update = self._images["device_monitor"][device]
-        processing_config = image_to_update.config.processing
-        self.processor.set_config(processing_config)
-        if self.use_threading:
-            self._create_thread_worker(device, data)
-        else:
-            data = self.processor.process_image(data)
-            self.update_image(device, data)
-            self.update_vrange(device, self.processor.config.stats)
+        image = self._images["device_monitor"][device]
+        self.process_image(device, image, data)
 
     @pyqtSlot(str, np.ndarray)
     def update_image(self, device: str, data: np.ndarray):
@@ -504,6 +521,15 @@ class BECImageShow(BECPlotBase):
         if image_to_update.config.autorange:
             image_to_update.auto_update_vrange(stats)
 
+    def refresh_image(self):
+        """
+        Refresh the image.
+        """
+        for source, images in self._images.items():
+            for image_id, image in images.items():
+                data = image.get_data()
+                self.process_image(image_id, image, data)
+
     def _connect_device_monitor(self, monitor: str):
         """
         Connect to the device monitor.
@@ -516,16 +542,18 @@ class BECImageShow(BECPlotBase):
             previous_monitor = image_item.config.monitor
         except AttributeError:
             previous_monitor = None
-        if previous_monitor != monitor:
-            if previous_monitor:
-                self.bec_dispatcher.disconnect_slot(
-                    self.on_image_update, MessageEndpoints.device_monitor(previous_monitor)
-                )
-            if monitor:
-                self.bec_dispatcher.connect_slot(
-                    self.on_image_update, MessageEndpoints.device_monitor(monitor)
-                )
-                image_item.set_monitor(monitor)
+        if previous_monitor and image_item.connected is True:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(previous_monitor)
+            )
+            image_item.connected = False
+        if monitor and image_item.connected is False:
+            self.entry_validator.validate_monitor(monitor)
+            self.bec_dispatcher.connect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(monitor)
+            )
+            image_item.set_monitor(monitor)
+            image_item.connected = True
 
     def _add_image_object(
         self, source: str, name: str, config: ImageItemConfig, data=None
@@ -534,6 +562,8 @@ class BECImageShow(BECPlotBase):
         image = BECImageItem(config=config, parent_image=self)
         self.plot_item.addItem(image)
         self._images[source][name] = image
+        if source == "device_monitor":
+            self._connect_device_monitor(config.monitor)
         self.config.images[name] = config
         if data is not None:
             image.setImage(data)
@@ -558,23 +588,6 @@ class BECImageShow(BECPlotBase):
                     return True
         return False
 
-    def _validate_monitor(self, monitor: str, validate_bec: bool = True):
-        """
-        Validate the monitor name.
-
-        Args:
-            monitor(str): The name of the monitor.
-            validate_bec(bool): Whether to validate the monitor name with BEC.
-
-        Returns:
-            bool: True if the monitor name is valid, False otherwise.
-        """
-        if not monitor or monitor == "":
-            return False
-        if validate_bec:
-            return monitor in self.dev
-        return True
-
     def cleanup(self):
         """
         Clean up the widget.

bec_widgets/widgets/figure/plots/image/image_item.py

@@ -20,7 +20,7 @@ class ImageItemConfig(ConnectionConfig):
     color_map: Optional[str] = Field("magma", description="The color map of the image.")
     downsample: Optional[bool] = Field(True, description="Whether to downsample the image.")
     opacity: Optional[float] = Field(1.0, description="The opacity of the image.")
-    vrange: Optional[tuple[float, float]] = Field(
+    vrange: Optional[tuple[float | int, float | int]] = Field(
         None, description="The range of the color bar. If None, the range is automatically set."
     )
     color_bar: Optional[Literal["simple", "full"]] = Field(
@@ -37,8 +37,8 @@ class ImageItemConfig(ConnectionConfig):
 
 class BECImageItem(BECConnector, pg.ImageItem):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "set",
         "set_fft",
         "set_log",
@@ -78,6 +78,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
         self.apply_config()
         if kwargs:
             self.set(**kwargs)
+        self.connected = False
 
     def apply_config(self):
         """

bec_widgets/widgets/figure/plots/motor_map/motor_map.py

@@ -6,38 +6,51 @@ from typing import Optional, Union
 import numpy as np
 import pyqtgraph as pg
 from bec_lib.endpoints import MessageEndpoints
-from pydantic import Field
+from pydantic import Field, ValidationError, field_validator
+from pydantic_core import PydanticCustomError
 from qtpy import QtCore, QtGui
 from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtCore import Slot
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.utils import EntryValidator
+from bec_widgets.utils import Colors, EntryValidator
 from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
 from bec_widgets.widgets.figure.plots.waveform.waveform import Signal, SignalData
 
 
 class MotorMapConfig(SubplotConfig):
     signals: Optional[Signal] = Field(None, description="Signals of the motor map")
-    color_map: Optional[str] = Field(
-        "Greys", description="Color scheme of the motor position gradient."
-    )  # TODO decide if useful for anything, or just keep GREYS always
+    color: Optional[str | tuple] = Field(
+        (255, 255, 255, 255), description="The color of the last point of current position."
+    )
     scatter_size: Optional[int] = Field(5, description="Size of the scatter points.")
-    max_points: Optional[int] = Field(1000, description="Maximum number of points to display.")
+    max_points: Optional[int] = Field(5000, description="Maximum number of points to display.")
     num_dim_points: Optional[int] = Field(
         100,
         description="Number of points to dim before the color remains same for older recorded position.",
     )
     precision: Optional[int] = Field(2, description="Decimal precision of the motor position.")
     background_value: Optional[int] = Field(
-        25, description="Background value of the motor map."
-    )  # TODO can be percentage from 255 calculated
+        25, description="Background value of the motor map. Has to be between 0 and 255."
+    )
+
+    model_config: dict = {"validate_assignment": True}
+
+    _validate_color = field_validator("color")(Colors.validate_color)
+
+    @field_validator("background_value")
+    def validate_background_value(cls, value):
+        if not 0 <= value <= 255:
+            raise PydanticCustomError(
+                "wrong_value", f"'{value}' hs to be between 0 and 255.", {"wrong_value": value}
+            )
+        return value
 
 
 class BECMotorMap(BECPlotBase):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "change_motors",
         "set_max_points",
         "set_precision",
@@ -46,6 +59,7 @@ class BECMotorMap(BECPlotBase):
         "set_scatter_size",
         "get_data",
         "remove",
+        "reset_history",
     ]
 
     # QT Signals
@@ -69,31 +83,45 @@ class BECMotorMap(BECPlotBase):
         self.get_bec_shortcuts()
         self.entry_validator = EntryValidator(self.dev)
 
+        # connect update signal to update plot
+        self.proxy_update_plot = pg.SignalProxy(
+            self.update_signal, rateLimit=25, slot=self._update_plot
+        )
+        self.apply_config(self.config)
+
+    def apply_config(self, config: dict | MotorMapConfig):
+        """
+        Apply the config to the motor map.
+
+        Args:
+            config(dict|MotorMapConfig): Config to be applied.
+        """
+        if isinstance(config, dict):
+            try:
+                config = MotorMapConfig(**config)
+            except ValidationError as e:
+                print(f"Error in applying config: {e}")
+                return
+
+        self.config = config
+        self.plot_item.clear()
+
         self.motor_x = None
         self.motor_y = None
         self.database_buffer = {"x": [], "y": []}
         self.plot_components = defaultdict(dict)  # container for plot components
 
-        # connect update signal to update plot
-        self.proxy_update_plot = pg.SignalProxy(
-            self.update_signal, rateLimit=25, slot=self._update_plot
-        )
+        self.apply_axis_config()
 
-    # TODO decide if needed to implement, maybe there will be no children widgets for motormap for now...
-    # def find_widget_by_id(self, item_id: str) -> BECCurve:
-    #     """
-    #     Find the curve by its ID.
-    #     Args:
-    #         item_id(str): ID of the curve.
-    #
-    #     Returns:
-    #         BECCurve: The curve object.
-    #     """
-    #     for curve in self.plot_item.curves:
-    #         if curve.gui_id == item_id:
-    #             return curve
+        if self.config.signals is not None:
+            self.change_motors(
+                motor_x=self.config.signals.x.name,
+                motor_y=self.config.signals.y.name,
+                motor_x_entry=self.config.signals.x.entry,
+                motor_y_entry=self.config.signals.y.entry,
+            )
 
-    @pyqtSlot(str, str, str, str, bool)
+    @Slot(str, str, str, str, bool)
     def change_motors(
         self,
         motor_x: str,
@@ -112,6 +140,8 @@ class BECMotorMap(BECPlotBase):
             motor_y_entry(str): Motor entry for the Y axis.
             validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
         """
+        self.plot_item.clear()
+
         motor_x_entry, motor_y_entry = self._validate_signal_entries(
             motor_x, motor_y, motor_x_entry, motor_y_entry, validate_bec
         )
@@ -129,19 +159,42 @@ class BECMotorMap(BECPlotBase):
         # reconnect the signals
         self._connect_motor_to_slots()
 
+        self.database_buffer = {"x": [], "y": []}
+
         # Redraw the motor map
         self._make_motor_map()
 
     def get_data(self) -> dict:
         """
         Get the data of the motor map.
+
         Returns:
             dict: Data of the motor map.
         """
         data = {"x": self.database_buffer["x"], "y": self.database_buffer["y"]}
         return data
 
-    # TODO setup all visual properties
+    def reset_history(self):
+        """
+        Reset the history of the motor map.
+        """
+        self.database_buffer["x"] = [self.database_buffer["x"][-1]]
+        self.database_buffer["y"] = [self.database_buffer["y"][-1]]
+        self.update_signal.emit()
+
+    def set_color(self, color: str | tuple):
+        """
+        Set color of the motor trace.
+
+        Args:
+            color(str|tuple): Color of the motor trace. Can be HEX(str) or RGBA(tuple).
+        """
+        if isinstance(color, str):
+            color = Colors.validate_color(color)
+            color = Colors.hex_to_rgba(color, 255)
+        self.config.color = color
+        self.update_signal.emit()
+
     def set_max_points(self, max_points: int) -> None:
         """
         Set the maximum number of points to display.
@@ -150,6 +203,7 @@ class BECMotorMap(BECPlotBase):
             max_points(int): Maximum number of points to display.
         """
         self.config.max_points = max_points
+        self.update_signal.emit()
 
     def set_precision(self, precision: int) -> None:
         """
@@ -159,6 +213,7 @@ class BECMotorMap(BECPlotBase):
             precision(int): Decimal precision of the motor position.
         """
         self.config.precision = precision
+        self.update_signal.emit()
 
     def set_num_dim_points(self, num_dim_points: int) -> None:
         """
@@ -168,6 +223,7 @@ class BECMotorMap(BECPlotBase):
             num_dim_points(int): Number of dim points.
         """
         self.config.num_dim_points = num_dim_points
+        self.update_signal.emit()
 
     def set_background_value(self, background_value: int) -> None:
         """
@@ -177,6 +233,7 @@ class BECMotorMap(BECPlotBase):
             background_value(int): Background value of the motor map.
         """
         self.config.background_value = background_value
+        self._swap_limit_map()
 
     def set_scatter_size(self, scatter_size: int) -> None:
         """
@@ -186,6 +243,7 @@ class BECMotorMap(BECPlotBase):
             scatter_size(int): Size of the scatter points.
         """
         self.config.scatter_size = scatter_size
+        self.update_signal.emit()
 
     def _disconnect_current_motors(self):
         """Disconnect the current motors from the slots."""
@@ -210,6 +268,15 @@ class BECMotorMap(BECPlotBase):
 
         self.bec_dispatcher.connect_slot(self.on_device_readback, endpoints)
 
+    def _swap_limit_map(self):
+        """Swap the limit map."""
+        self.plot_item.removeItem(self.plot_components["limit_map"])
+        self.plot_components["limit_map"] = self._make_limit_map(
+            self.config.signals.x.limits, self.config.signals.y.limits
+        )
+        self.plot_components["limit_map"].setZValue(-1)
+        self.plot_item.addItem(self.plot_components["limit_map"])
+
     def _make_motor_map(self):
         """
         Create the motor map plot.
@@ -249,6 +316,8 @@ class BECMotorMap(BECPlotBase):
         # Set default labels for the plot
         self.set(x_label=f"Motor X ({self.motor_x})", y_label=f"Motor Y ({self.motor_y})")
 
+        self.update_signal.emit()
+
     def _add_coordinantes_crosshair(self, x: float, y: float) -> None:
         """
         Add crosshair to the plot to highlight the current position.
@@ -371,21 +440,34 @@ class BECMotorMap(BECPlotBase):
             print(f"The device '{motor}' does not have defined limits.")
             return None
 
+    @Slot()
     def _update_plot(self):
         """Update the motor map plot."""
+        # If the number of points exceeds max_points, delete the oldest points
+        if len(self.database_buffer["x"]) > self.config.max_points:
+            self.database_buffer["x"] = self.database_buffer["x"][-self.config.max_points :]
+            self.database_buffer["y"] = self.database_buffer["y"][-self.config.max_points :]
+
         x = self.database_buffer["x"]
         y = self.database_buffer["y"]
 
         # Setup gradient brush for history
         brushes = [pg.mkBrush(50, 50, 50, 255)] * len(x)
 
+        # RGB color
+        r, g, b, a = self.config.color
+
         # Calculate the decrement step based on self.num_dim_points
         num_dim_points = self.config.num_dim_points
         decrement_step = (255 - 50) / num_dim_points
+
         for i in range(1, min(num_dim_points + 1, len(x) + 1)):
             brightness = max(60, 255 - decrement_step * (i - 1))
-            brushes[-i] = pg.mkBrush(brightness, brightness, brightness, 255)
-        brushes[-1] = pg.mkBrush(255, 255, 255, 255)  # Newest point is always full brightness
+            dim_r = int(r * (brightness / 255))
+            dim_g = int(g * (brightness / 255))
+            dim_b = int(b * (brightness / 255))
+            brushes[-i] = pg.mkBrush(dim_r, dim_g, dim_b, a)
+        brushes[-1] = pg.mkBrush(r, g, b, a)  # Newest point is always full brightness
         scatter_size = self.config.scatter_size
 
         # Update the scatter plot
@@ -408,7 +490,7 @@ class BECMotorMap(BECPlotBase):
             f"Motor position: ({round(float(current_x),precision)}, {round(float(current_y),precision)})"
         )
 
-    @pyqtSlot(dict)
+    @Slot(dict)
     def on_device_readback(self, msg: dict) -> None:
         """
         Update the motor map plot with the new motor position.

bec_widgets/widgets/figure/plots/plot_base.py

@@ -46,7 +46,7 @@ class SubplotConfig(ConnectionConfig):
 
 class BECPlotBase(BECConnector, pg.GraphicsLayout):
     USER_ACCESS = [
-        "config_dict",
+        "_config_dict",
         "set",
         "set_title",
         "set_x_label",

bec_widgets/widgets/figure/plots/waveform/waveform.py

@@ -35,8 +35,8 @@ class Waveform1DConfig(SubplotConfig):
 
 class BECWaveform(BECPlotBase):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "plot",
         "add_dap",
         "get_dap_params",
@@ -44,8 +44,6 @@ class BECWaveform(BECPlotBase):
         "scan_history",
         "curves",
         "get_curve",
-        "get_curve_config",
-        "apply_config",
         "get_all_data",
         "set",
         "set_title",
@@ -705,14 +703,15 @@ class BECWaveform(BECPlotBase):
                 data_y = data[y_name][y_entry].val
                 if curve.config.signals.z:
                     data_z = data[z_name][z_entry].val
-                    color_z = self._make_z_gradient(
-                        data_z, curve.config.color_map_z
-                    )  # TODO decide how to implement custom gradient
+                    color_z = self._make_z_gradient(data_z, curve.config.color_map_z)
             except TypeError:
                 continue
 
             if data_z is not None and color_z is not None:
-                curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
+                try:
+                    curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
+                except:
+                    return
             else:
                 curve.setData(data_x, data_y)
 

bec_widgets/widgets/figure/plots/waveform/waveform_curve.py

@@ -65,8 +65,8 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     USER_ACCESS = [
         "remove",
         "dap_params",
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "set",
         "set_data",
         "set_color",

bec_widgets/widgets/motor_map/assets/connection.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="48px" viewBox="0 0 24 24" width="48px" fill="#FFFFFF">
+    <path d="M0 0h24v24H0V0z" fill="none"/>
+    <path d="M17 7h-4v2h4c1.65 0 3 1.35 3 3s-1.35 3-3 3h-4v2h4c2.76 0 5-2.24 5-5s-2.24-5-5-5zm-6 8H7c-1.65 0-3-1.35-3-3s1.35-3 3-3h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-2zm-3-4h8v2H8z"/>
+</svg>

bec_widgets/widgets/motor_map/assets/history.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="48px" viewBox="0 0 24 24" width="48px" fill="#FFFFFF">
+    <path d="M0 0h24v24H0V0z" fill="none"/>
+    <path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.25 2.52.77-1.28-3.52-2.09V8z"/>
+</svg>

bec_widgets/widgets/motor_map/assets/settings.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="48px" viewBox="0 0 24 24" width="48px" fill="#FFFFFF">
+    <path d="M0 0h24v24H0V0z" fill="none"/>
+    <path d="M19.43 12.98c.04-.32.07-.64.07-.98 0-.34-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.09-.16-.26-.25-.44-.25-.06 0-.12.01-.17.03l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.06-.02-.12-.03-.18-.03-.17 0-.34.09-.43.25l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98 0 .33.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.09.16.26.25.44.25.06 0 .12-.01.17-.03l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.06.02.12.03.18.03.17 0 .34-.09.43-.25l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zm-1.98-1.71c.04.31.05.52.05.73 0 .21-.02.43-.05.73l-.14 1.13.89.7 1.08.84-.7 1.21-1.27-.51-1.04-.42-.9.68c-.43.32-.84.56-1.25.73l-1.06.43-.16 1.13-.2 1.35h-1.4l-.19-1.35-.16-1.13-1.06-.43c-.43-.18-.83-.41-1.23-.71l-.91-.7-1.06.43-1.27.51-.7-1.21 1.08-.84.89-.7-.14-1.13c-.03-.31-.05-.54-.05-.74s.02-.43.05-.73l.14-1.13-.89-.7-1.08-.84.7-1.21 1.27.51 1.04.42.9-.68c.43-.32.84-.56 1.25-.73l1.06-.43.16-1.13.2-1.35h1.39l.19 1.35.16 1.13 1.06.43c.43.18.83.41 1.23.71l.91.7 1.06-.43 1.27-.51.7 1.21-1.07.85-.89.7.14 1.13zM12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"/>
+</svg>

bec_widgets/widgets/motor_map/bec_motor_map_widget.pyproject

@@ -0,0 +1 @@
+{'files': ['motor_map_widget.py','motor_map_widget_plugin.py']}

bec_widgets/widgets/motor_map/bec_motor_map_widget_plugin.py

@@ -0,0 +1,55 @@
+import os
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.motor_map.motor_map_widget import BECMotorMapWidget
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECMotorMapWidget' name='bec_motor_map_widget'>
+    </widget>
+</ui>
+"""
+
+
+class BECMotorMapWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECMotorMapWidget(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Visualization Widgets"
+
+    def icon(self):
+        current_path = os.path.dirname(__file__)
+        icon_path = os.path.join(current_path, "assets", "motor_map.png")
+        return QIcon(icon_path)
+
+    def includeFile(self):
+        return "bec_motor_map_widget"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "BECMotorMapWidget"
+
+    def toolTip(self):
+        return "BECMotorMapWidget"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/motor_map/motor_map_dialog/motor_map_settings.py

@@ -0,0 +1,73 @@
+import os
+
+from qtpy.QtCore import Slot
+from qtpy.QtWidgets import QDialog, QDialogButtonBox, QLabel, QVBoxLayout, QWidget
+
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.widget_io import WidgetIO
+
+
+class MotorMapSettings(QWidget):
+    def __init__(self, parent=None, target_widget: QWidget = None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+        current_path = os.path.dirname(__file__)
+
+        self.ui = UILoader(self).loader(os.path.join(current_path, "motor_map_settings.ui"))
+        self.target_widget = target_widget
+
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.ui)
+
+    @Slot(dict)
+    def display_current_settings(self, config: dict):
+        WidgetIO.set_value(self.ui.max_points, config["max_points"])
+        WidgetIO.set_value(self.ui.trace_dim, config["num_dim_points"])
+        WidgetIO.set_value(self.ui.precision, config["precision"])
+        WidgetIO.set_value(self.ui.scatter_size, config["scatter_size"])
+        background_intensity = int((config["background_value"] / 255) * 100)
+        WidgetIO.set_value(self.ui.background_value, background_intensity)
+        color = config["color"]
+        self.ui.color.setColor(color)
+
+    @Slot()
+    def accept_changes(self):
+        max_points = WidgetIO.get_value(self.ui.max_points)
+        num_dim_points = WidgetIO.get_value(self.ui.trace_dim)
+        precision = WidgetIO.get_value(self.ui.precision)
+        scatter_size = WidgetIO.get_value(self.ui.scatter_size)
+        background_intensity = int(WidgetIO.get_value(self.ui.background_value) * 0.01 * 255)
+        color = self.ui.color.color().toTuple()
+
+        if self.target_widget is not None:
+            self.target_widget.set_max_points(max_points)
+            self.target_widget.set_num_dim_points(num_dim_points)
+            self.target_widget.set_precision(precision)
+            self.target_widget.set_scatter_size(scatter_size)
+            self.target_widget.set_background_value(background_intensity)
+            self.target_widget.set_color(color)
+
+
+class MotorMapDialog(QDialog):
+    def __init__(self, parent=None, target_widget: QWidget = None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+
+        self.setModal(False)
+
+        self.setWindowTitle("Motor Map Settings")
+
+        self.target_widget = target_widget
+        self.widget = MotorMapSettings(target_widget=self.target_widget)
+        self.widget.display_current_settings(self.target_widget._config_dict)
+        self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+
+        self.button_box.accepted.connect(self.accept)
+        self.button_box.rejected.connect(self.reject)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.widget)
+        self.layout.addWidget(self.button_box)
+
+    @Slot()
+    def accept(self):
+        self.widget.accept_changes()
+        super().accept()

bec_widgets/widgets/motor_map/motor_map_dialog/motor_map_settings.ui

@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>243</width>
+    <height>233</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="3" column="1">
+    <widget class="QSpinBox" name="scatter_size">
+     <property name="maximum">
+      <number>20</number>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0">
+    <widget class="QLabel" name="trace_label">
+     <property name="text">
+      <string>Trace Dim</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="0">
+    <widget class="QLabel" name="precision_label">
+     <property name="text">
+      <string>Precision</string>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="0">
+    <widget class="QLabel" name="background_label">
+     <property name="text">
+      <string>Background Intensity</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="1">
+    <widget class="QSpinBox" name="precision">
+     <property name="maximum">
+      <number>15</number>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="1">
+    <widget class="QSpinBox" name="background_value">
+     <property name="maximum">
+      <number>100</number>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0">
+    <widget class="QLabel" name="max_point_label">
+     <property name="text">
+      <string>Max Points</string>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="0">
+    <widget class="QLabel" name="scatter_size_label">
+     <property name="text">
+      <string>Scatter Size</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1">
+    <widget class="QSpinBox" name="max_points">
+     <property name="maximum">
+      <number>10000</number>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1">
+    <widget class="QSpinBox" name="trace_dim">
+     <property name="maximum">
+      <number>1000</number>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="0">
+    <widget class="QLabel" name="color_label">
+     <property name="text">
+      <string>Color</string>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="1">
+    <widget class="ColorButton" name="color"/>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>ColorButton</class>
+   <extends>QPushButton</extends>
+   <header>color_button</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/widgets/motor_map/motor_map_dialog/motor_map_toolbar.py

@@ -0,0 +1,59 @@
+import os
+
+from qtpy.QtCore import QSize
+from qtpy.QtGui import QAction, QIcon
+from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget
+
+from bec_widgets.widgets.device_inputs import DeviceComboBox
+from bec_widgets.widgets.toolbar.toolbar import ToolBarAction
+
+
+class DeviceSelectionAction(ToolBarAction):
+    def __init__(self, label: str):
+        self.label = label
+        self.device_combobox = DeviceComboBox(device_filter="Positioner")
+
+        self.device_combobox.currentIndexChanged.connect(lambda: self.set_combobox_style("#ffa700"))
+
+    def add_to_toolbar(self, toolbar, target):
+        widget = QWidget()
+        layout = QHBoxLayout(widget)
+
+        label = QLabel(f"{self.label}")
+
+        layout.addWidget(label)
+        layout.addWidget(self.device_combobox)
+        toolbar.addWidget(widget)
+
+    def set_combobox_style(self, color: str):
+        self.device_combobox.setStyleSheet(f"QComboBox {{ background-color: {color}; }}")
+
+
+class ConnectAction(ToolBarAction):
+    def add_to_toolbar(self, toolbar, target):
+        current_path = os.path.dirname(__file__)
+        parent_path = os.path.dirname(current_path)
+        icon = QIcon()
+        icon.addFile(os.path.join(parent_path, "assets", "connection.svg"), size=QSize(20, 20))
+        self.action = QAction(icon, "Connect Motors", target)
+        toolbar.addAction(self.action)
+
+
+class ResetHistoryAction(ToolBarAction):
+    def add_to_toolbar(self, toolbar, target):
+        current_path = os.path.dirname(__file__)
+        parent_path = os.path.dirname(current_path)
+        icon = QIcon()
+        icon.addFile(os.path.join(parent_path, "assets", "history.svg"), size=QSize(20, 20))
+        self.action = QAction(icon, "Reset Trace History", target)
+        toolbar.addAction(self.action)
+
+
+class SettingsAction(ToolBarAction):
+    def add_to_toolbar(self, toolbar, target):
+        current_path = os.path.dirname(__file__)
+        parent_path = os.path.dirname(current_path)
+        icon = QIcon()
+        icon.addFile(os.path.join(parent_path, "assets", "settings.svg"), size=QSize(20, 20))
+        self.action = QAction(icon, "Open Configuration Dialog", target)
+        toolbar.addAction(self.action)

bec_widgets/widgets/motor_map/motor_map_widget.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import sys
+
+from qtpy import PYSIDE6
+from qtpy.QtWidgets import QVBoxLayout, QWidget
+
+from bec_widgets.utils import BECConnector
+from bec_widgets.widgets.figure import BECFigure
+from bec_widgets.widgets.figure.plots.motor_map.motor_map import MotorMapConfig
+from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_settings import MotorMapDialog
+from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_toolbar import (
+    ConnectAction,
+    DeviceSelectionAction,
+    ResetHistoryAction,
+    SettingsAction,
+)
+from bec_widgets.widgets.toolbar import ModularToolBar
+
+
+class BECMotorMapWidget(BECConnector, QWidget):
+    USER_ACCESS = [
+        "change_motors",
+        "set_max_points",
+        "set_precision",
+        "set_num_dim_points",
+        "set_background_value",
+        "set_scatter_size",
+        "get_data",
+        "reset_history",
+    ]
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        config: MotorMapConfig | None = None,
+        client=None,
+        gui_id: str | None = None,
+    ) -> None:
+        if not PYSIDE6:
+            raise RuntimeError(
+                "PYSIDE6 is not available in the environment. This widget is compatible only with PySide6."
+            )
+        if config is None:
+            config = MotorMapConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = MotorMapConfig(**config)
+        super().__init__(client=client, gui_id=gui_id)
+        QWidget.__init__(self, parent)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.setSpacing(0)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+
+        self.fig = BECFigure()
+        self.toolbar = ModularToolBar(
+            actions={
+                "motor_x": DeviceSelectionAction("Motor X:"),
+                "motor_y": DeviceSelectionAction("Motor Y:"),
+                "connect": ConnectAction(),
+                "history": ResetHistoryAction(),
+                "config": SettingsAction(),
+            },
+            target_widget=self,
+        )
+
+        self.layout.addWidget(self.toolbar)
+        self.layout.addWidget(self.fig)
+
+        self.map = self.fig.motor_map()
+        self.map.apply_config(config)
+
+        self._hook_actions()
+
+        self.config = config
+
+    def _hook_actions(self):
+        self.toolbar.widgets["connect"].action.triggered.connect(self._action_motors)
+        self.toolbar.widgets["config"].action.triggered.connect(self.show_settings)
+        self.toolbar.widgets["history"].action.triggered.connect(self.reset_history)
+
+        if self.map.motor_x is None and self.map.motor_y is None:
+            self._enable_actions(False)
+
+    def _enable_actions(self, enable: bool):
+        self.toolbar.widgets["config"].action.setEnabled(enable)
+        self.toolbar.widgets["history"].action.setEnabled(enable)
+
+    def _action_motors(self):
+        toolbar_x = self.toolbar.widgets["motor_x"].device_combobox
+        toolbar_y = self.toolbar.widgets["motor_y"].device_combobox
+        motor_x = toolbar_x.currentText()
+        motor_y = toolbar_y.currentText()
+        self.change_motors(motor_x, motor_y, None, None, True)
+        toolbar_x.setStyleSheet("QComboBox {{ background-color: " "; }}")
+        toolbar_y.setStyleSheet("QComboBox {{ background-color: " "; }}")
+
+    def show_settings(self) -> None:
+        dialog = MotorMapDialog(self, target_widget=self)
+        dialog.exec()
+
+    ###################################
+    # User Access Methods from MotorMap
+    ###################################
+
+    def change_motors(
+        self,
+        motor_x: str,
+        motor_y: str,
+        motor_x_entry: str = None,
+        motor_y_entry: str = None,
+        validate_bec: bool = True,
+    ) -> None:
+        """
+        Change the active motors for the plot.
+
+        Args:
+            motor_x(str): Motor name for the X axis.
+            motor_y(str): Motor name for the Y axis.
+            motor_x_entry(str): Motor entry for the X axis.
+            motor_y_entry(str): Motor entry for the Y axis.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        """
+        self.map.change_motors(motor_x, motor_y, motor_x_entry, motor_y_entry, validate_bec)
+        if self.map.motor_x is not None and self.map.motor_y is not None:
+            self._enable_actions(True)
+        toolbar_x = self.toolbar.widgets["motor_x"].device_combobox
+        toolbar_y = self.toolbar.widgets["motor_y"].device_combobox
+
+        if toolbar_x.currentText() != motor_x:
+            toolbar_x.setCurrentText(motor_x)
+            toolbar_x.setStyleSheet("QComboBox {{ background-color: " "; }}")
+        if toolbar_y.currentText() != motor_y:
+            toolbar_y.setCurrentText(motor_y)
+            toolbar_y.setStyleSheet("QComboBox {{ background-color: " "; }}")
+
+    def get_data(self) -> dict:
+        """
+        Get the data of the motor map.
+
+        Returns:
+            dict: Data of the motor map.
+        """
+        return self.map.get_data()
+
+    def reset_history(self) -> None:
+        """
+        Reset the history of the motor map.
+        """
+        self.map.reset_history()
+
+    def set_color(self, color: str | tuple):
+        """
+        Set the color of the motor map.
+
+        Args:
+            color(str, tuple): Color to set.
+        """
+        self.map.set_color(color)
+
+    def set_max_points(self, max_points: int) -> None:
+        """
+        Set the maximum number of points to display on the motor map.
+
+        Args:
+            max_points(int): Maximum number of points to display.
+        """
+        self.map.set_max_points(max_points)
+
+    def set_precision(self, precision: int) -> None:
+        """
+        Set the precision of the motor map.
+
+        Args:
+            precision(int): Precision to set.
+        """
+        self.map.set_precision(precision)
+
+    def set_num_dim_points(self, num_dim_points: int) -> None:
+        """
+        Set the number of points to display on the motor map.
+
+        Args:
+            num_dim_points(int): Number of points to display.
+        """
+        self.map.set_num_dim_points(num_dim_points)
+
+    def set_background_value(self, background_value: int) -> None:
+        """
+        Set the background value of the motor map.
+
+        Args:
+            background_value(int): Background value of the motor map.
+        """
+        self.map.set_background_value(background_value)
+
+    def set_scatter_size(self, scatter_size: int) -> None:
+        """
+        Set the scatter size of the motor map.
+
+        Args:
+            scatter_size(int): Scatter size of the motor map.
+        """
+        self.map.set_scatter_size(scatter_size)
+
+    def cleanup(self):
+        self.fig.cleanup()
+        self.toolbar.widgets["motor_x"].device_combobox.cleanup()
+        self.toolbar.widgets["motor_y"].device_combobox.cleanup()
+        return super().cleanup()
+
+    def closeEvent(self, event):
+        self.cleanup()
+        QWidget().closeEvent(event)
+
+
+def main():  # pragma: no cover
+
+    if not PYSIDE6:
+        print(
+            "PYSIDE6 is not available in the environment. UI files with BEC custom widgets are runnable only with PySide6."
+        )
+        return
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = BECMotorMapWidget()
+    widget.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/motor_map/register_bec_motor_map_widget.py

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.motor_map.bec_motor_map_widget_plugin import BECMotorMapWidgetPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECMotorMapWidgetPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/ring_progress_bar/ring.py

@@ -79,9 +79,9 @@ class RingConfig(ProgressbarConfig):
 
 class Ring(BECConnector):
     USER_ACCESS = [
-        "get_all_rpc",
-        "rpc_id",
-        "config_dict",
+        "_get_all_rpc",
+        "_rpc_id",
+        "_config_dict",
         "set_value",
         "set_color",
         "set_background",

bec_widgets/widgets/ring_progress_bar/ring_progress_bar.py

@@ -68,9 +68,9 @@ class RingProgressBarConfig(ConnectionConfig):
 
 class RingProgressBar(BECConnector, QWidget):
     USER_ACCESS = [
-        "get_all_rpc",
-        "rpc_id",
-        "config_dict",
+        "_get_all_rpc",
+        "_rpc_id",
+        "_config_dict",
         "rings",
         "update_config",
         "add_ring",
@@ -104,7 +104,7 @@ class RingProgressBar(BECConnector, QWidget):
                 config = RingProgressBarConfig(**config, widget_class=self.__class__.__name__)
             self.config = config
         super().__init__(client=client, config=config, gui_id=gui_id)
-        QWidget.__init__(self, parent=None)
+        QWidget.__init__(self, parent=parent)
 
         self.get_bec_shortcuts()
         self.entry_validator = EntryValidator(self.dev)

bec_widgets/widgets/text_box/text_box.py

@@ -31,7 +31,7 @@ class TextBox(BECConnector, QTextEdit):
 
     USER_ACCESS = ["set_color", "set_text", "set_font_size"]
 
-    def __init__(self, text: str = "", parent=None, client=None, config=None, gui_id=None):
+    def __init__(self, parent=None, text: str = "", client=None, config=None, gui_id=None):
         if config is None:
             config = TextBoxConfig(widget_class=self.__class__.__name__)
         else:

bec_widgets/widgets/toolbar/toolbar.py

@@ -1,123 +1,70 @@
 from abc import ABC, abstractmethod
+from collections import defaultdict
 
 # pylint: disable=no-name-in-module
-from qtpy.QtCore import QSize, QTimer
+from qtpy.QtCore import QSize
 from qtpy.QtGui import QAction
-from qtpy.QtWidgets import QApplication, QStyle, QToolBar, QWidget
+from qtpy.QtWidgets import QHBoxLayout, QLabel, QSpinBox, QToolBar, QWidget
 
 
 class ToolBarAction(ABC):
-    """Abstract base class for action creators for the toolbar."""
-
     @abstractmethod
-    def create(self, target: QWidget):
-        """Creates and returns an action to be added to a toolbar.
-
-        This method must be implemented by subclasses.
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """Adds an action or widget to a toolbar.
 
         Args:
-            target (QWidget): The widget that the action will target.
-
-        Returns:
-            QAction: The action created for the toolbar.
+            toolbar (QToolBar): The toolbar to add the action or widget to.
+            target (QWidget): The target widget for the action.
         """
 
 
-class OpenFileAction:  # (ToolBarAction):
-    """Action creator for the 'Open File' action in the toolbar."""
+class ColumnAdjustAction(ToolBarAction):
+    """Toolbar spinbox to adjust number of columns in the plot layout"""
 
-    def create(self, target: QWidget):
-        """Creates an 'Open File' action for the toolbar.
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """Creates a access history button for the toolbar.
 
         Args:
-            target (QWidget): The widget that the 'Open File' action will be targeted.
+            toolbar (QToolBar): The toolbar to add the action to.
+            target (QWidget): The widget that the 'Access Scan History' action will be targeted.
 
         Returns:
-            QAction: The 'Open File' action created for the toolbar.
+            QAction: The 'Access Scan History' action created for the toolbar.
         """
-        icon = QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogOpenButton)
-        action = QAction(icon, "Open File", target)
-        # action = QAction("Open File", target)
-        action.triggered.connect(target.open_file)
-        return action
+        widget = QWidget()
+        layout = QHBoxLayout(widget)
 
+        label = QLabel("Columns:")
+        spin_box = QSpinBox()
+        spin_box.setMinimum(1)  # Set minimum value
+        spin_box.setMaximum(10)  # Set maximum value
+        spin_box.setValue(target.get_column_count())  # Initial value
+        spin_box.valueChanged.connect(lambda value: target.set_column_count(value))
 
-class SaveFileAction:
-    """Action creator for the 'Save File' action in the toolbar."""
-
-    def create(self, target):
-        """Creates a 'Save File' action for the toolbar.
-
-        Args:
-            target (QWidget): The widget that the 'Save File' action will be targeted.
-
-        Returns:
-            QAction: The 'Save File' action created for the toolbar.
-        """
-        icon = QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogSaveButton)
-        action = QAction(icon, "Save File", target)
-        # action = QAction("Save File", target)
-        action.triggered.connect(target.save_file)
-        return action
-
-
-class RunScriptAction:
-    """Action creator for the 'Run Script' action in the toolbar."""
-
-    def create(self, target):
-        """Creates a 'Run Script' action for the toolbar.
-
-        Args:
-            target (QWidget): The widget that the 'Run Script' action will be targeted.
-
-        Returns:
-            QAction: The 'Run Script' action created for the toolbar.
-        """
-        icon = QApplication.style().standardIcon(QStyle.StandardPixmap.SP_MediaPlay)
-        action = QAction(icon, "Run Script", target)
-        # action = QAction("Run Script", target)
-        action.triggered.connect(target.run_script)
-        return action
+        layout.addWidget(label)
+        layout.addWidget(spin_box)
+        toolbar.addWidget(widget)
 
 
 class ModularToolBar(QToolBar):
     """Modular toolbar with optional automatic initialization.
-
     Args:
         parent (QWidget, optional): The parent widget of the toolbar. Defaults to None.
-        auto_init (bool, optional): If True, automatically populates the toolbar based on the parent widget.
+        actions (list[ToolBarAction], optional): A list of action creators to populate the toolbar. Defaults to None.
+        target_widget (QWidget, optional): The widget that the actions will target. Defaults to None.
+        color (str, optional): The background color of the toolbar. Defaults to "black".
     """
 
-    def __init__(self, parent=None, auto_init=True):
+    def __init__(self, parent=None, actions=None, target_widget=None, color: str = "black"):
         super().__init__(parent)
-        self.auto_init = auto_init
-        self.handler = {
-            "BECEditor": [OpenFileAction(), SaveFileAction(), RunScriptAction()],
-            # BECMonitor: [SomeOtherAction(), AnotherAction()],  # Example for another widget
-        }
-        self.setStyleSheet("QToolBar { background: transparent; }")
-        # Set the icon size for the toolbar
-        self.setIconSize(QSize(20, 20))
 
-        if self.auto_init:
-            QTimer.singleShot(0, self.auto_detect_and_populate)
+        self.widgets = defaultdict(dict)
+        self.set_background_color(color)
 
-    def auto_detect_and_populate(self):
-        """Automatically detects the parent widget and populates the toolbar with relevant actions."""
-        if not self.auto_init:
-            return
+        if actions is not None and target_widget is not None:
+            self.populate_toolbar(actions, target_widget)
 
-        parent_widget = self.parent()
-        if parent_widget is None:
-            return
-
-        parent_widget_class_name = type(parent_widget).__name__
-        for widget_type_name, actions in self.handler.items():
-            if parent_widget_class_name == widget_type_name:
-                self.populate_toolbar(actions, parent_widget)
-                return
-
-    def populate_toolbar(self, actions, target_widget):
+    def populate_toolbar(self, actions: dict, target_widget):
         """Populates the toolbar with a set of actions.
 
         Args:
@@ -125,20 +72,13 @@ class ModularToolBar(QToolBar):
             target_widget (QWidget): The widget that the actions will target.
         """
         self.clear()
-        for action_creator in actions:
-            action = action_creator.create(target_widget)
-            self.addAction(action)
+        for action_id, action in actions.items():
+            action.add_to_toolbar(self, target_widget)
+            self.widgets[action_id] = action
 
-    def set_manual_actions(self, actions, target_widget):
-        """Manually sets the actions for the toolbar.
-
-        Args:
-            actions (list[QAction or ToolBarAction]): A list of actions or action creators to populate the toolbar.
-            target_widget (QWidget): The widget that the actions will target.
-        """
-        self.clear()
-        for action in actions:
-            if isinstance(action, QAction):
-                self.addAction(action)
-            elif isinstance(action, ToolBarAction):
-                self.addAction(action.create(target_widget))
+    def set_background_color(self, color: str):
+        self.setStyleSheet(f"QToolBar {{ background: {color}; }}")
+        self.setIconSize(QSize(20, 20))
+        self.setMovable(False)
+        self.setFloatable(False)
+        self.setContentsMargins(0, 0, 0, 0)

bec_widgets/widgets/website/website.py

@@ -21,7 +21,7 @@ class WebsiteWidget(BECConnector, QWebEngineView):
 
     USER_ACCESS = ["set_url", "get_url", "reload", "back", "forward"]
 
-    def __init__(self, url: str = None, parent=None, config=None, client=None, gui_id=None):
+    def __init__(self, parent=None, url: str = None, config=None, client=None, gui_id=None):
         super().__init__(client=client, config=config, gui_id=gui_id)
         QWebEngineView.__init__(self, parent=parent)
         self.set_url(url)

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "0.74.1"
+version = "0.79.1"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -22,6 +22,7 @@ dependencies = [
     "pyqtdarktheme~=2.1",
     "qtconsole~=5.5, >=5.5.1",  # needed for jupyter console
     "qtpy~=2.4",
+    "pyte",                     # needed for vt100 console
 ]
 
 

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -23,14 +23,14 @@ def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
     d1 = dock.add_dock("dock_1")
     d2 = dock.add_dock("dock_2")
 
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 3
     # Add 3 figures with some widgets
     fig0 = d0.add_widget("BECFigure")
     fig1 = d1.add_widget("BECFigure")
     fig2 = d2.add_widget("BECFigure")
 
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 3
     assert len(dock_config["docks"]["dock_0"]["widgets"]) == 1
     assert len(dock_config["docks"]["dock_1"]["widgets"]) == 1
@@ -52,7 +52,7 @@ def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
     assert im.__class__.__name__ == "BECImageShow"
     assert im.__class__ == BECImageShow
 
-    assert mm.config_dict["signals"] == {
+    assert mm._config_dict["signals"] == {
         "dap": None,
         "source": "device_readback",
         "x": {
@@ -71,14 +71,14 @@ def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
         },
         "z": None,
     }
-    assert plt.config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
+    assert plt._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
         "dap": None,
         "source": "scan_segment",
         "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
         "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
         "z": None,
     }
-    assert im.config_dict["images"]["eiger"]["monitor"] == "eiger"
+    assert im._config_dict["images"]["eiger"]["monitor"] == "eiger"
 
     # check initial position of motor map
     initial_pos_x = dev.samx.read()["samx"]["value"]
@@ -126,29 +126,29 @@ def test_dock_manipulations_e2e(rpc_server_dock):
     d0 = dock.add_dock("dock_0")
     d1 = dock.add_dock("dock_1")
     d2 = dock.add_dock("dock_2")
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 3
 
     d0.detach()
     dock.detach_dock("dock_2")
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 3
     assert len(dock.temp_areas) == 2
 
     d0.attach()
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 3
     assert len(dock.temp_areas) == 1
 
     d2.remove()
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 2
 
     assert ["dock_0", "dock_1"] == list(dock_config["docks"])
 
     dock.clear_all()
 
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 0
     assert len(dock.temp_areas) == 0
 
@@ -165,11 +165,11 @@ def test_ring_bar(rpc_server_dock):
     bar.set_colors_from_map("viridis")
     bar.set_value([10, 20, 30, 40, 50])
 
-    bar_config = bar.config_dict
+    bar_config = bar._config_dict
 
     expected_colors = [list(color) for color in Colors.golden_angle_color("viridis", 5, "RGB")]
-    bar_colors = [ring.config_dict["color"] for ring in bar.rings]
-    bar_values = [ring.config_dict["value"] for ring in bar.rings]
+    bar_colors = [ring._config_dict["color"] for ring in bar.rings]
+    bar_values = [ring._config_dict["value"] for ring in bar.rings]
     assert bar_config["num_bars"] == 5
     assert bar_values == [10, 20, 30, 40, 50]
     assert bar_colors == expected_colors
@@ -191,7 +191,7 @@ def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
     status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
     status.wait()
 
-    bar_config = bar.config_dict
+    bar_config = bar._config_dict
     assert bar_config["num_bars"] == 1
     assert bar_config["rings"][0]["value"] == 10
     assert bar_config["rings"][0]["min_value"] == 0
@@ -200,7 +200,7 @@ def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
     status = scans.grid_scan(dev.samx, -5, 5, 4, dev.samy, -10, 10, 4, relative=True, exp_time=0.1)
     status.wait()
 
-    bar_config = bar.config_dict
+    bar_config = bar._config_dict
     assert bar_config["num_bars"] == 1
     assert bar_config["rings"][0]["value"] == 16
     assert bar_config["rings"][0]["min_value"] == 0
@@ -217,7 +217,7 @@ def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
     status = scans.umv(dev.samx, 5, dev.samy, 10, relative=True)
     status.wait()
 
-    bar_config = bar.config_dict
+    bar_config = bar._config_dict
     assert bar_config["num_bars"] == 2
     assert bar_config["rings"][0]["value"] == final_samx
     assert bar_config["rings"][1]["value"] == final_samy

tests/end-2-end/test_bec_figure_rpc_e2e.py

@@ -10,14 +10,14 @@ from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWave
 def test_rpc_waveform1d_custom_curve(rpc_server_figure):
     fig = BECFigure(rpc_server_figure)
 
-    ax = fig.add_plot()
+    ax = fig.plot()
     curve = ax.plot(x=[1, 2, 3], y=[1, 2, 3])
     curve.set_color("red")
     curve = ax.curves[0]
     curve.set_color("blue")
 
     assert len(fig.widgets) == 1
-    assert len(fig.widgets[ax.rpc_id].curves) == 1
+    assert len(fig.widgets[ax._rpc_id].curves) == 1
 
 
 def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
@@ -26,7 +26,7 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
     plt = fig.plot(x_name="samx", y_name="bpm4i")
     im = fig.image("eiger")
     motor_map = fig.motor_map("samx", "samy")
-    plt_z = fig.add_plot(x_name="samx", y_name="samy", z_name="bpm4i")
+    plt_z = fig.plot(x_name="samx", y_name="samy", z_name="bpm4i", new=True)
 
     # Checking if classes are correctly initialised
     assert len(fig.widgets) == 4
@@ -39,7 +39,7 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
 
     # check if the correct devices are set
     # plot
-    assert plt.config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
+    assert plt._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
         "dap": None,
         "source": "scan_segment",
         "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
@@ -47,9 +47,9 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
         "z": None,
     }
     # image
-    assert im.config_dict["images"]["eiger"]["monitor"] == "eiger"
+    assert im._config_dict["images"]["eiger"]["monitor"] == "eiger"
     # motor map
-    assert motor_map.config_dict["signals"] == {
+    assert motor_map._config_dict["signals"] == {
         "dap": None,
         "source": "device_readback",
         "x": {
@@ -69,7 +69,7 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
         "z": None,
     }
     # plot with z scatter
-    assert plt_z.config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
+    assert plt_z._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
         "dap": None,
         "source": "scan_segment",
         "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},

tests/end-2-end/test_rpc_register_e2e.py

@@ -9,24 +9,24 @@ def test_rpc_register_list_connections(rpc_server_figure):
     plt = fig.plot(x_name="samx", y_name="bpm4i")
     im = fig.image("eiger")
     motor_map = fig.motor_map("samx", "samy")
-    plt_z = fig.add_plot(x_name="samx", y_name="samy", z_name="bpm4i")
+    plt_z = fig.plot(x_name="samx", y_name="samy", z_name="bpm4i", new=True)
 
     # keep only class names from objects, since objects on server and client are different
     # so the best we can do is to compare types (rpc register is unit-tested elsewhere)
-    all_connections = {obj_id: type(obj).__name__ for obj_id, obj in fig.get_all_rpc().items()}
+    all_connections = {obj_id: type(obj).__name__ for obj_id, obj in fig._get_all_rpc().items()}
 
     all_subwidgets_expected = {wid: type(widget).__name__ for wid, widget in fig.widgets.items()}
-    curve_1D = fig.widgets[plt.rpc_id]
-    curve_2D = fig.widgets[plt_z.rpc_id]
+    curve_1D = fig.widgets[plt._rpc_id]
+    curve_2D = fig.widgets[plt_z._rpc_id]
     curves_expected = {
-        curve_1D.rpc_id: type(curve_1D).__name__,
-        curve_2D.rpc_id: type(curve_2D).__name__,
+        curve_1D._rpc_id: type(curve_1D).__name__,
+        curve_2D._rpc_id: type(curve_2D).__name__,
     }
     curves_expected.update({curve._gui_id: type(curve).__name__ for curve in curve_1D.curves})
     curves_expected.update({curve._gui_id: type(curve).__name__ for curve in curve_2D.curves})
-    fig_expected = {fig.rpc_id: type(fig).__name__}
+    fig_expected = {fig._rpc_id: type(fig).__name__}
     image_item_expected = {
-        fig.widgets[im.rpc_id].images[0].rpc_id: type(fig.widgets[im.rpc_id].images[0]).__name__
+        fig.widgets[im._rpc_id].images[0]._rpc_id: type(fig.widgets[im._rpc_id].images[0]).__name__
     }
 
     all_connections_expected = {

tests/unit_tests/client_mocks.py

@@ -84,6 +84,7 @@ class DMMock:
 DEVICES = [
     FakePositioner("samx", limits=[-10, 10], read_value=2.0),
     FakePositioner("samy", limits=[-5, 5], read_value=3.0),
+    FakePositioner("samz", limits=[-8, 8], read_value=4.0),
     FakePositioner("aptrx", limits=None, read_value=4.0),
     FakePositioner("aptry", limits=None, read_value=5.0),
     FakeDevice("gauss_bpm"),

tests/unit_tests/test_bec_figure.py

@@ -38,9 +38,9 @@ def test_bec_figure_add_remove_plot(bec_figure):
     initial_count = len(bec_figure._widgets)
 
     # Adding 3 widgets -  2 WaveformBase and 1 PlotBase
-    w0 = bec_figure.add_plot()
-    w1 = bec_figure.add_plot()
-    w2 = bec_figure.add_widget(widget_type="PlotBase")
+    w0 = bec_figure.plot(new=True)
+    w1 = bec_figure.plot(new=True)
+    w2 = bec_figure.add_widget(widget_type="BECPlotBase")
 
     # Check if the widgets were added
     assert len(bec_figure._widgets) == initial_count + 3
@@ -75,7 +75,7 @@ def test_add_different_types_of_widgets(bec_figure):
 
 
 def test_access_widgets_access_errors(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
+    bec_figure.plot(row=0, col=0)
 
     # access widget by non-existent coordinates
     with pytest.raises(ValueError) as excinfo:
@@ -97,18 +97,18 @@ def test_access_widgets_access_errors(bec_figure):
 
 
 def test_add_plot_to_occupied_position(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
+    bec_figure.plot(row=0, col=0)
 
     with pytest.raises(ValueError) as excinfo:
-        bec_figure.add_plot(row=0, col=0)
+        bec_figure.plot(row=0, col=0, new=True)
         assert "Position at row 0 and column 0 is already occupied." in str(excinfo.value)
 
 
 def test_remove_plots(bec_figure):
-    w1 = bec_figure.add_plot(row=0, col=0)
-    w2 = bec_figure.add_plot(row=0, col=1)
-    w3 = bec_figure.add_plot(row=1, col=0)
-    w4 = bec_figure.add_plot(row=1, col=1)
+    w1 = bec_figure.plot(row=0, col=0)
+    w2 = bec_figure.plot(row=0, col=1)
+    w3 = bec_figure.plot(row=1, col=0)
+    w4 = bec_figure.plot(row=1, col=1)
 
     assert bec_figure[0, 0] == w1
     assert bec_figure[0, 1] == w2
@@ -135,10 +135,10 @@ def test_remove_plots(bec_figure):
 
 
 def test_remove_plots_by_coordinates_ints(bec_figure):
-    w1 = bec_figure.add_plot(row=0, col=0)
-    w2 = bec_figure.add_plot(row=0, col=1)
+    w1 = bec_figure.plot(row=0, col=0)
+    w2 = bec_figure.plot(row=0, col=1)
 
-    bec_figure.remove(0, 0)
+    bec_figure.remove(row=0, col=0)
     assert w1.gui_id not in bec_figure._widgets
     assert w2.gui_id in bec_figure._widgets
     assert bec_figure[0, 0] == w2
@@ -146,8 +146,8 @@ def test_remove_plots_by_coordinates_ints(bec_figure):
 
 
 def test_remove_plots_by_coordinates_tuple(bec_figure):
-    w1 = bec_figure.add_plot(row=0, col=0)
-    w2 = bec_figure.add_plot(row=0, col=1)
+    w1 = bec_figure.plot(row=0, col=0)
+    w2 = bec_figure.plot(row=0, col=1)
 
     bec_figure.remove(coordinates=(0, 0))
     assert w1.gui_id not in bec_figure._widgets
@@ -157,7 +157,7 @@ def test_remove_plots_by_coordinates_tuple(bec_figure):
 
 
 def test_remove_plot_by_id_error(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
+    bec_figure.plot()
 
     with pytest.raises(ValueError) as excinfo:
         bec_figure.remove(widget_id="non_existent_widget")
@@ -165,7 +165,7 @@ def test_remove_plot_by_id_error(bec_figure):
 
 
 def test_remove_plot_by_coordinates_error(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
+    bec_figure.plot(row=0, col=0)
 
     with pytest.raises(ValueError) as excinfo:
         bec_figure.remove(0, 1)
@@ -173,7 +173,7 @@ def test_remove_plot_by_coordinates_error(bec_figure):
 
 
 def test_remove_plot_by_providing_nothing(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
+    bec_figure.plot(row=0, col=0)
 
     with pytest.raises(ValueError) as excinfo:
         bec_figure.remove()
@@ -193,10 +193,10 @@ def test_remove_plot_by_providing_nothing(bec_figure):
 
 
 def test_change_layout(bec_figure):
-    w1 = bec_figure.add_plot(row=0, col=0)
-    w2 = bec_figure.add_plot(row=0, col=1)
-    w3 = bec_figure.add_plot(row=1, col=0)
-    w4 = bec_figure.add_plot(row=1, col=1)
+    w1 = bec_figure.plot(row=0, col=0)
+    w2 = bec_figure.plot(row=0, col=1)
+    w3 = bec_figure.plot(row=1, col=0)
+    w4 = bec_figure.plot(row=1, col=1)
 
     bec_figure.change_layout(max_columns=1)
 
@@ -216,10 +216,10 @@ def test_change_layout(bec_figure):
 
 
 def test_clear_all(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
-    bec_figure.add_plot(row=0, col=1)
-    bec_figure.add_plot(row=1, col=0)
-    bec_figure.add_plot(row=1, col=1)
+    bec_figure.plot(row=0, col=0)
+    bec_figure.plot(row=0, col=1)
+    bec_figure.plot(row=1, col=0)
+    bec_figure.plot(row=1, col=1)
 
     bec_figure.clear_all()
 
@@ -238,3 +238,26 @@ def test_shortcuts(bec_figure):
     assert im.__class__ == BECImageShow
     assert motor_map.config.widget_class == "BECMotorMap"
     assert motor_map.__class__ == BECMotorMap
+
+
+def test_plot_access_factory(bec_figure):
+    plt_00 = bec_figure.plot(x_name="samx", y_name="bpm4i")
+    plt_01 = bec_figure.plot(x_name="samx", y_name="bpm4i", row=0, col=1)
+    plt_10 = bec_figure.plot(new=True)
+
+    assert bec_figure.widget_list[0] == plt_00
+    assert bec_figure.widget_list[1] == plt_01
+    assert bec_figure.widget_list[2] == plt_10
+    assert bec_figure.axes(row=0, col=0) == plt_00
+    assert bec_figure.axes(row=0, col=1) == plt_01
+    assert bec_figure.axes(row=1, col=0) == plt_10
+
+    assert len(plt_00.curves) == 1
+    assert len(plt_01.curves) == 1
+    assert len(plt_10.curves) == 0
+
+    # update plt_00
+    bec_figure.plot(x_name="samx", y_name="bpm3a")
+    bec_figure.plot(x=[1, 2, 3], y=[1, 2, 3], row=0, col=0)
+
+    assert len(plt_00.curves) == 3

tests/unit_tests/test_bec_motor_map.py

@@ -1,100 +1,106 @@
+import numpy as np
 import pytest
 
 from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap, MotorMapConfig
 from bec_widgets.widgets.figure.plots.waveform.waveform_curve import SignalData
 
 from .client_mocks import mocked_client
+from .test_bec_figure import bec_figure
 
 
-@pytest.fixture(scope="function")
-def bec_motor_map(qtbot, mocked_client):
-    widget = BECMotorMap(client=mocked_client, gui_id="BECMotorMap_test")
-    # qtbot.addWidget(widget)
-    # qtbot.waitExposed(widget)
-    yield widget
+def test_motor_map_init(bec_figure):
+    default_config = MotorMapConfig(widget_class="BECMotorMap")
+
+    mm = bec_figure.motor_map(config=default_config.model_dump())
+    default_config.gui_id = mm.gui_id
+
+    assert mm.config == default_config
 
 
-def test_motor_map_init(bec_motor_map):
-    default_config = MotorMapConfig(widget_class="BECMotorMap", gui_id="BECMotorMap_test")
+def test_motor_map_change_motors(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
 
-    assert bec_motor_map.config == default_config
+    assert mm.motor_x == "samx"
+    assert mm.motor_y == "samy"
+    assert mm.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
+    assert mm.config.signals.y == SignalData(name="samy", entry="samy", limits=[-5, 5])
+
+    mm.change_motors("samx", "samz")
+
+    assert mm.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
+    assert mm.config.signals.y == SignalData(name="samz", entry="samz", limits=[-8, 8])
 
 
-def test_motor_map_change_motors(bec_motor_map):
-    bec_motor_map.change_motors("samx", "samy")
-
-    assert bec_motor_map.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
-    assert bec_motor_map.config.signals.y == SignalData(name="samy", entry="samy", limits=[-5, 5])
-
-
-def test_motor_map_get_limits(bec_motor_map):
+def test_motor_map_get_limits(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
     expected_limits = {"samx": [-10, 10], "samy": [-5, 5]}
 
     for motor_name, expected_limit in expected_limits.items():
-        actual_limit = bec_motor_map._get_motor_limit(motor_name)
+        actual_limit = mm._get_motor_limit(motor_name)
         assert actual_limit == expected_limit
 
 
-def test_motor_map_get_init_position(bec_motor_map):
-    bec_motor_map.set_precision(2)
+def test_motor_map_get_init_position(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
+    mm.set_precision(2)
 
-    motor_map_dev = bec_motor_map.client.device_manager.devices
+    motor_map_dev = mm.client.device_manager.devices
 
     expected_positions = {
         ("samx", "samx"): motor_map_dev["samx"].read()["samx"]["value"],
         ("samy", "samy"): motor_map_dev["samy"].read()["samy"]["value"],
-        ("aptrx", "aptrx"): motor_map_dev["aptrx"].read()["aptrx"]["value"],
-        ("aptry", "aptry"): motor_map_dev["aptry"].read()["aptry"]["value"],
     }
 
     for (motor_name, entry), expected_position in expected_positions.items():
-        actual_position = bec_motor_map._get_motor_init_position(motor_name, entry, 2)
+        actual_position = mm._get_motor_init_position(motor_name, entry, 2)
         assert actual_position == expected_position
 
 
-def test_motor_movement_updates_position_and_database(bec_motor_map):
-    motor_map_dev = bec_motor_map.client.device_manager.devices
+def test_motor_movement_updates_position_and_database(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
+    motor_map_dev = mm.client.device_manager.devices
 
     init_positions = {
         "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
         "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
     }
 
-    bec_motor_map.change_motors("samx", "samy")
+    mm.change_motors("samx", "samy")
 
-    assert bec_motor_map.database_buffer["x"] == init_positions["samx"]
-    assert bec_motor_map.database_buffer["y"] == init_positions["samy"]
+    assert mm.database_buffer["x"] == init_positions["samx"]
+    assert mm.database_buffer["y"] == init_positions["samy"]
 
     # Simulate motor movement for 'samx' only
     new_position_samx = 4.0
-    bec_motor_map.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
+    mm.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
 
     init_positions["samx"].append(new_position_samx)
     init_positions["samy"].append(init_positions["samy"][-1])
     # Verify database update for 'samx'
-    assert bec_motor_map.database_buffer["x"] == init_positions["samx"]
+    assert mm.database_buffer["x"] == init_positions["samx"]
 
     # Verify 'samy' retains its last known position
-    assert bec_motor_map.database_buffer["y"] == init_positions["samy"]
+    assert mm.database_buffer["y"] == init_positions["samy"]
 
 
-def test_scatter_plot_rendering(bec_motor_map):
-    motor_map_dev = bec_motor_map.client.device_manager.devices
+def test_scatter_plot_rendering(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
+    motor_map_dev = mm.client.device_manager.devices
 
     init_positions = {
         "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
         "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
     }
 
-    bec_motor_map.change_motors("samx", "samy")
+    mm.change_motors("samx", "samy")
 
     # Simulate motor movement for 'samx' only
     new_position_samx = 4.0
-    bec_motor_map.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
-    bec_motor_map._update_plot()
+    mm.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
+    mm._update_plot()
 
     # Get the scatter plot item
-    scatter_plot_item = bec_motor_map.plot_components["scatter"]
+    scatter_plot_item = mm.plot_components["scatter"]
 
     # Check the scatter plot item properties
     assert len(scatter_plot_item.data) > 0, "Scatter plot data is empty"
@@ -106,16 +112,148 @@ def test_scatter_plot_rendering(bec_motor_map):
     ), "Scatter plot Y data should retain last known position"
 
 
-def test_plot_visualization_consistency(bec_motor_map):
-    bec_motor_map.change_motors("samx", "samy")
+def test_plot_visualization_consistency(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
+    mm.change_motors("samx", "samy")
     # Simulate updating the plot with new data
-    bec_motor_map.on_device_readback({"signals": {"samx": {"value": 5}}})
-    bec_motor_map.on_device_readback({"signals": {"samy": {"value": 9}}})
-    bec_motor_map._update_plot()
+    mm.on_device_readback({"signals": {"samx": {"value": 5}}})
+    mm.on_device_readback({"signals": {"samy": {"value": 9}}})
+    mm._update_plot()
 
-    scatter_plot_item = bec_motor_map.plot_components["scatter"]
+    scatter_plot_item = mm.plot_components["scatter"]
 
     # Check if the scatter plot reflects the new data correctly
     assert (
         scatter_plot_item.data["x"][-1] == 5 and scatter_plot_item.data["y"][-1] == 9
     ), "Plot not updated correctly with new data"
+
+
+def test_change_background_value(bec_figure, qtbot):
+    mm = bec_figure.motor_map("samx", "samy")
+
+    assert mm.config.background_value == 25
+    assert np.all(mm.plot_components["limit_map"].image == 25.0)
+
+    mm.set_background_value(50)
+    qtbot.wait(200)
+
+    assert mm.config.background_value == 50
+    assert np.all(mm.plot_components["limit_map"].image == 50.0)
+
+
+def test_motor_map_init_from_config(bec_figure):
+    config = {
+        "widget_class": "BECMotorMap",
+        "gui_id": "mm_id",
+        "parent_id": bec_figure.gui_id,
+        "row": 0,
+        "col": 0,
+        "axis": {
+            "title": "Motor position: (-0.0, 0.0)",
+            "title_size": None,
+            "x_label": "Motor X (samx)",
+            "x_label_size": None,
+            "y_label": "Motor Y (samy)",
+            "y_label_size": None,
+            "legend_label_size": None,
+            "x_scale": "linear",
+            "y_scale": "linear",
+            "x_lim": None,
+            "y_lim": None,
+            "x_grid": True,
+            "y_grid": True,
+        },
+        "signals": {
+            "source": "device_readback",
+            "x": {
+                "name": "samx",
+                "entry": "samx",
+                "unit": None,
+                "modifier": None,
+                "limits": [-10.0, 10.0],
+            },
+            "y": {
+                "name": "samy",
+                "entry": "samy",
+                "unit": None,
+                "modifier": None,
+                "limits": [-5.0, 5.0],
+            },
+            "z": None,
+            "dap": None,
+        },
+        "color": (255, 255, 255, 255),
+        "scatter_size": 5,
+        "max_points": 50,
+        "num_dim_points": 10,
+        "precision": 5,
+        "background_value": 50,
+    }
+    mm = bec_figure.motor_map(config=config)
+    config["gui_id"] = mm.gui_id
+
+    assert mm._config_dict == config
+
+
+def test_motor_map_set_scatter_size(bec_figure, qtbot):
+    mm = bec_figure.motor_map("samx", "samy")
+
+    assert mm.config.scatter_size == 5
+    assert mm.plot_components["scatter"].opts["size"] == 5
+
+    mm.set_scatter_size(10)
+    qtbot.wait(200)
+
+    assert mm.config.scatter_size == 10
+    assert mm.plot_components["scatter"].opts["size"] == 10
+
+
+def test_motor_map_change_precision(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
+
+    assert mm.config.precision == 2
+    mm.set_precision(10)
+    assert mm.config.precision == 10
+
+
+def test_motor_map_set_color(bec_figure, qtbot):
+    mm = bec_figure.motor_map("samx", "samy")
+
+    assert mm.config.color == (255, 255, 255, 255)
+
+    mm.set_color((0, 0, 0, 255))
+    qtbot.wait(200)
+    assert mm.config.color == (0, 0, 0, 255)
+
+
+def test_motor_map_get_data_max_points(bec_figure, qtbot):
+    mm = bec_figure.motor_map("samx", "samy")
+    motor_map_dev = mm.client.device_manager.devices
+
+    init_positions = {
+        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
+        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
+    }
+    mm.on_device_readback({"signals": {"samx": {"value": 5.0}}})
+    mm.on_device_readback({"signals": {"samy": {"value": 9.0}}})
+    mm.on_device_readback({"signals": {"samx": {"value": 6.0}}})
+    mm.on_device_readback({"signals": {"samy": {"value": 7.0}}})
+
+    expected_x = [init_positions["samx"][-1], 5.0, 5.0, 6.0, 6.0]
+    expected_y = [init_positions["samy"][-1], init_positions["samy"][-1], 9.0, 9.0, 7.0]
+    get_data = mm.get_data()
+
+    assert mm.database_buffer["x"] == expected_x
+    assert mm.database_buffer["y"] == expected_y
+    assert get_data["x"] == expected_x
+    assert get_data["y"] == expected_y
+
+    mm.set_max_points(3)
+    qtbot.wait(200)
+    get_data = mm.get_data()
+    assert len(get_data["x"]) == 3
+    assert len(get_data["y"]) == 3
+    assert get_data["x"] == expected_x[-3:]
+    assert get_data["y"] == expected_y[-3:]
+    assert mm.database_buffer["x"] == expected_x[-3:]
+    assert mm.database_buffer["y"] == expected_y[-3:]

tests/unit_tests/test_bec_queue.py

@@ -0,0 +1,111 @@
+import pytest
+from bec_lib import messages
+
+from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def bec_queue_msg_full():
+    content = {
+        "primary": {
+            "info": [
+                {
+                    "active_request_block": None,
+                    "is_scan": [True],
+                    "queue_id": "600163fc-5e56-4901-af25-14e9ee76817c",
+                    "request_blocks": [
+                        {
+                            "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
+                            "content": {
+                                "parameter": {
+                                    "args": {"samx": [-0.1, 0.1]},
+                                    "kwargs": {
+                                        "exp_time": 0.5,
+                                        "relative": True,
+                                        "steps": 20,
+                                        "system_config": {
+                                            "file_directory": None,
+                                            "file_suffix": None,
+                                        },
+                                    },
+                                },
+                                "queue": "primary",
+                                "scan_type": "line_scan",
+                            },
+                            "is_scan": True,
+                            "metadata": {
+                                "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
+                                "file_directory": None,
+                                "file_suffix": None,
+                                "user_metadata": {"sample_name": "testA"},
+                            },
+                            "msg": messages.ScanQueueMessage(
+                                metadata={
+                                    "file_suffix": None,
+                                    "file_directory": None,
+                                    "user_metadata": {"sample_name": "testA"},
+                                    "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
+                                },
+                                scan_type="line_scan",
+                                parameter={
+                                    "args": {"samx": [-0.1, 0.1]},
+                                    "kwargs": {
+                                        "steps": 20,
+                                        "exp_time": 0.5,
+                                        "relative": True,
+                                        "system_config": {
+                                            "file_suffix": None,
+                                            "file_directory": None,
+                                        },
+                                    },
+                                },
+                                queue="primary",
+                            ),
+                            "readout_priority": {
+                                "async": [],
+                                "baseline": [],
+                                "monitored": ["samx"],
+                                "on_request": [],
+                            },
+                            "report_instructions": [{"scan_progress": 20}],
+                            "scan_id": "2d704cc3-c172-404c-866d-608ce09fce40",
+                            "scan_motors": ["samx"],
+                            "scan_number": 1289,
+                        }
+                    ],
+                    "scan_id": ["2d704cc3-c172-404c-866d-608ce09fce40"],
+                    "scan_number": [1289],
+                    "status": "COMPLETED",
+                }
+            ],
+            "status": "RUNNING",
+        }
+    }
+    msg = messages.ScanQueueStatusMessage(metadata={}, queue=content)
+    return msg
+
+
+@pytest.fixture
+def bec_queue(qtbot, mocked_client):
+    widget = BECQueue(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_bec_queue(bec_queue, bec_queue_msg_full):
+    bec_queue.update_queue(bec_queue_msg_full.content, {})
+    assert bec_queue.rowCount() == 1
+    assert bec_queue.item(0, 0).text() == "1289"
+    assert bec_queue.item(0, 1).text() == "line_scan"
+    assert bec_queue.item(0, 2).text() == "COMPLETED"
+
+
+def test_bec_queue_empty(bec_queue):
+    bec_queue.update_queue({}, {})
+    assert bec_queue.rowCount() == 1
+    assert bec_queue.item(0, 0).text() == ""
+    assert bec_queue.item(0, 1).text() == ""
+    assert bec_queue.item(0, 2).text() == ""

tests/unit_tests/test_bec_status_box.py

@@ -1,3 +1,4 @@
+# pylint: skip-file
 from unittest import mock
 
 import pytest
@@ -15,9 +16,7 @@ def service_status_fixture():
 
 @pytest.fixture
 def status_box(qtbot, mocked_client, service_status_fixture):
-    widget = BECStatusBox(
-        client=mocked_client, service_name="test", bec_service_status_mixin=service_status_fixture
-    )
+    widget = BECStatusBox(client=mocked_client, bec_service_status_mixin=service_status_fixture)
     qtbot.addWidget(widget)
     qtbot.waitExposed(widget)
     yield widget
@@ -25,8 +24,9 @@ def status_box(qtbot, mocked_client, service_status_fixture):
 
 def test_update_top_item(status_box):
     assert status_box.children()[0].children()[0].config.status == "IDLE"
+    name = status_box.box_name
     status_box.update_top_item_status(status="RUNNING")
-    assert status_box.bec_service_info_container["test"].status == "RUNNING"
+    assert status_box.status_container[name]["info"].status == "RUNNING"
     assert status_box.children()[0].children()[0].config.status == "RUNNING"
 
 
@@ -48,13 +48,13 @@ def test_bec_service_container(status_box):
     info = {"test": "test"}
     metrics = {"metric": "test_metric"}
     expected_return = BECServiceInfoContainer(
-        service_name=name, status=status, info=info, metrics=metrics
+        service_name=name, status=status.name, info=info, metrics=metrics
     )
-    assert status_box.service_name in status_box.bec_service_info_container
-    assert len(status_box.bec_service_info_container) == 1
-    status_box._update_bec_service_container(name, status, info, metrics)
-    assert len(status_box.bec_service_info_container) == 2
-    assert status_box.bec_service_info_container[name] == expected_return
+    assert status_box.box_name in status_box.status_container
+    assert len(status_box.status_container) == 1
+    status_box._update_status_container(name, status, info, metrics)
+    assert len(status_box.status_container) == 2
+    assert status_box.status_container[name]["info"] == expected_return
 
 
 def test_add_tree_item(status_box):
@@ -65,7 +65,7 @@ def test_add_tree_item(status_box):
     assert len(status_box.children()[0].children()) == 1
     status_box.add_tree_item(name, status, info, metrics)
     assert len(status_box.children()[0].children()) == 2
-    assert name in status_box.tree_items
+    assert name in status_box.status_container
 
 
 def test_update_service_status(status_box):
@@ -82,10 +82,10 @@ def test_update_service_status(status_box):
     services_metrics = {name: ServiceMetricMessage(name=name, metrics=metrics)}
 
     with mock.patch.object(status_box, "update_core_services", return_value=services_status):
-        assert not_connected_name in status_box.tree_items
+        assert not_connected_name in status_box.status_container
         status_box.update_service_status(services_status, services_metrics)
-        assert status_box.tree_items[name][1].config.metrics == metrics
-        assert not_connected_name not in status_box.tree_items
+        assert status_box.status_container[name]["widget"].config.metrics == metrics
+        assert not_connected_name not in status_box.status_container
 
 
 def test_update_core_services(status_box):
@@ -99,14 +99,14 @@ def test_update_core_services(status_box):
 
     status_box.update_core_services(services_status, services_metrics)
     assert status_box.children()[0].children()[0].config.status == "RUNNING"
-    assert status_box.tree_items[name][1].config.metrics == metrics
+    assert status_box.status_container[name]["widget"].config.metrics == metrics
 
     status = BECStatus.IDLE
     services_status = {name: StatusMessage(name=name, status=status, info=info)}
     services_metrics = {name: ServiceMetricMessage(name=name, metrics=metrics)}
     status_box.update_core_services(services_status, services_metrics)
-    assert status_box.children()[0].children()[0].config.status == "ERROR"
-    assert status_box.tree_items[name][1].config.metrics == metrics
+    assert status_box.children()[0].children()[0].config.status == status.name
+    assert status_box.status_container[name]["widget"].config.metrics == metrics
 
 
 def test_double_click_item(status_box):
@@ -115,7 +115,9 @@ def test_double_click_item(status_box):
     info = {"test": "test"}
     metrics = {"MyData": "This should be shown nicely"}
     status_box.add_tree_item(name, status, info, metrics)
-    item, status_item = status_box.tree_items[name]
+    container = status_box.status_container[name]
+    item = container["item"]
+    status_item = container["widget"]
     with mock.patch.object(status_item, "show_popup") as mock_show_popup:
         status_box.itemDoubleClicked.emit(item, 0)
         assert mock_show_popup.call_count == 1

tests/unit_tests/test_color_validation.py

@@ -58,3 +58,18 @@ def test_color_validation_RGBA():
     assert "The color values must be between 0 and 255 in RGBA format (R,G,B,A)" in str(
         excinfo.value
     )
+
+
+def test_hex_to_rgba():
+    assert Colors.hex_to_rgba("#FF5733") == (255, 87, 51, 255)
+    assert Colors.hex_to_rgba("#FF573380") == (255, 87, 51, 128)
+    assert Colors.hex_to_rgba("#FF5733", 128) == (255, 87, 51, 128)
+
+    with pytest.raises(ValueError):
+        Colors.hex_to_rgba("#FF573")
+
+
+def test_rgba_to_hex():
+    assert Colors.rgba_to_hex(255, 87, 51, 255) == "#FF5733FF"
+    assert Colors.rgba_to_hex(255, 87, 51, 128) == "#FF573380"
+    assert Colors.rgba_to_hex(255, 87, 51) == "#FF5733FF"

tests/unit_tests/test_device_input_base.py

@@ -58,7 +58,7 @@ def test_device_input_base_set_default_device_error(device_input_base):
 
 def test_device_input_base_get_device_list(device_input_base):
     devices = device_input_base.get_device_list("FakePositioner")
-    assert devices == ["samx", "samy", "aptrx", "aptry"]
+    assert devices == ["samx", "samy", "samz", "aptrx", "aptry"]
 
 
 def test_device_input_base_get_filters(device_input_base):

tests/unit_tests/test_device_input_widgets.py

@@ -56,6 +56,7 @@ def test_device_input_combobox_init(device_input_combobox):
     assert device_input_combobox.devices == [
         "samx",
         "samy",
+        "samz",
         "aptrx",
         "aptry",
         "gauss_bpm",
@@ -141,6 +142,7 @@ def test_device_input_line_edit_init(device_input_line_edit):
     assert device_input_line_edit.devices == [
         "samx",
         "samy",
+        "samz",
         "aptrx",
         "aptry",
         "gauss_bpm",

tests/unit_tests/test_generate_plugin.py

@@ -0,0 +1,155 @@
+import importlib
+import inspect
+import os
+import sys
+
+import pytest
+
+from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator
+
+
+def load_plugin(dir_path, content, plugin_name="MyWidget"):
+    plugin_path = dir_path.mkdir("plugin").join("plugin.py")
+    plugin_path.write(content)
+    sys.path.append(str(dir_path))
+    plugin = importlib.import_module("plugin.plugin")
+    importlib.reload(plugin)
+    yield getattr(plugin, plugin_name)
+    sys.path.pop()
+
+
+@pytest.fixture(
+    params=[
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent=parent)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super(QWidget, self).__init__(parent)"""
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super(QWidget, self).__init__(parent=parent)
+""",
+    ]
+)
+def plugin_with_correct_parent(tmpdir, request):
+    yield from load_plugin(tmpdir, request.param)
+
+
+@pytest.fixture(
+    params=[
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        QWidget.__init__(self)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__()
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super(QWidget, self).__init__()
+        """,
+    ]
+)
+def plugin_with_missing_parent(tmpdir, request):
+    yield from load_plugin(tmpdir, request.param)
+
+
+def test_generate_plugin(plugin_with_correct_parent):
+    generator = DesignerPluginGenerator(plugin_with_correct_parent)
+    generator.run()
+    assert os.path.exists(f"{generator.info.base_path}/register_my_widget.py")
+    assert os.path.exists(f"{generator.info.base_path}/my_widget_plugin.py")
+    assert os.path.exists(f"{generator.info.base_path}/my_widget.pyproject")
+
+
+def test_generate_plugin_with_missing_parent(plugin_with_missing_parent):
+    with pytest.raises(ValueError) as excinfo:
+        generator = DesignerPluginGenerator(plugin_with_missing_parent)
+        generator.run()
+    assert "Widget class MyWidget must call the super constructor with parent." in str(
+        excinfo.value
+    )
+
+
+@pytest.fixture()
+def plugin_with_excluded_widget(tmpdir):
+    content = """
+from qtpy.QtWidgets import QWidget
+class BECDock(QWidget):
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent)
+"""
+    yield from load_plugin(tmpdir, content, plugin_name="BECDock")
+
+
+def test_generate_plugin_with_excluded_widget(plugin_with_excluded_widget, capsys):
+    generator = DesignerPluginGenerator(plugin_with_excluded_widget)
+    generator.run()
+    captured = capsys.readouterr()
+
+    assert "Plugin BECDock is excluded from generation." in captured.out
+    assert not os.path.exists(f"{generator.info.base_path}/register_bec_dock.py")
+    assert not os.path.exists(f"{generator.info.base_path}/bec_dock_plugin.py")
+    assert not os.path.exists(f"{generator.info.base_path}/bec_dock.pyproject")
+
+
+@pytest.fixture(
+    params=[
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self):
+        QWidget.__init__(self)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, config, parent=None):
+        super().__init__()
+""",
+    ]
+)
+def plugin_with_no_parent_as_first_arg(tmpdir, request):
+    yield from load_plugin(tmpdir, request.param)
+
+
+def test_generate_plugin_raises_exception_when_first_argument_is_not_parent(
+    plugin_with_no_parent_as_first_arg,
+):
+    with pytest.raises(ValueError) as excinfo:
+        generator = DesignerPluginGenerator(plugin_with_no_parent_as_first_arg)
+        generator.run()
+    assert "Widget class MyWidget must have parent as the first argument." in str(excinfo.value)

tests/unit_tests/test_motor_control.py

@@ -74,7 +74,7 @@ def test_motor_thread_initialization(mocked_client):
 def test_get_all_motors_names(mocked_client):
     motor_thread = MotorThread(client=mocked_client)
     motor_names = motor_thread.get_all_motors_names()
-    expected_names = ["samx", "samy", "aptrx", "aptry"]
+    expected_names = ["samx", "samy", "samz", "aptrx", "aptry"]
     assert sorted(motor_names) == sorted(expected_names)
     assert all(name in motor_names for name in expected_names)
     assert len(motor_names) == len(expected_names)  # Ensure only these motors are returned
@@ -155,11 +155,12 @@ def motor_selection_widget(qtbot, mocked_client, motor_thread):
 
 
 def test_initialization_and_population(motor_selection_widget):
-    assert motor_selection_widget.comboBox_motor_x.count() == 4
+    assert motor_selection_widget.comboBox_motor_x.count() == 5
     assert motor_selection_widget.comboBox_motor_x.itemText(0) == "samx"
     assert motor_selection_widget.comboBox_motor_y.itemText(1) == "samy"
-    assert motor_selection_widget.comboBox_motor_x.itemText(2) == "aptrx"
-    assert motor_selection_widget.comboBox_motor_y.itemText(3) == "aptry"
+    assert motor_selection_widget.comboBox_motor_y.itemText(2) == "samz"
+    assert motor_selection_widget.comboBox_motor_x.itemText(3) == "aptrx"
+    assert motor_selection_widget.comboBox_motor_y.itemText(4) == "aptry"
 
 
 def test_selection_and_signal_emission(motor_selection_widget):

tests/unit_tests/test_plot_base.py

@@ -9,14 +9,14 @@ from .test_bec_figure import bec_figure
 
 
 def test_init_plot_base(bec_figure):
-    plot_base = bec_figure.add_widget(widget_type="PlotBase", widget_id="test_plot")
+    plot_base = bec_figure.add_widget(widget_type="BECPlotBase", widget_id="test_plot")
     assert plot_base is not None
     assert plot_base.config.widget_class == "BECPlotBase"
     assert plot_base.config.gui_id == "test_plot"
 
 
 def test_plot_base_axes_by_separate_methods(bec_figure):
-    plot_base = bec_figure.add_widget(widget_type="PlotBase", widget_id="test_plot")
+    plot_base = bec_figure.add_widget(widget_type="BECPlotBase", widget_id="test_plot")
 
     plot_base.set_title("Test Title")
     plot_base.set_x_label("Test x Label")
@@ -66,7 +66,7 @@ def test_plot_base_axes_by_separate_methods(bec_figure):
 
 
 def test_plot_base_axes_added_by_kwargs(bec_figure):
-    plot_base = bec_figure.add_widget(widget_type="PlotBase", widget_id="test_plot")
+    plot_base = bec_figure.add_widget(widget_type="BECPlotBase", widget_id="test_plot")
 
     plot_base.set(
         title="Test Title",

tests/unit_tests/test_waveform1d.py

@@ -11,7 +11,7 @@ from .test_bec_figure import bec_figure
 
 
 def test_adding_curve_to_waveform(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     # adding curve which is in bec - only names
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
@@ -39,7 +39,7 @@ def test_adding_curve_to_waveform(bec_figure):
 
 
 def test_adding_curve_with_same_id(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i", gui_id="test_curve")
 
     with pytest.raises(ValueError) as excinfo:
@@ -122,9 +122,10 @@ def test_create_waveform1D_by_config(bec_figure):
         },
     }
 
-    w1 = bec_figure.add_plot(config=w1_config_input)
+    w1 = bec_figure.plot(config=w1_config_input)
 
     w1_config_output = w1.get_config()
+    w1_config_input["gui_id"] = w1.gui_id
 
     assert w1_config_input == w1_config_output
     assert w1.plot_item.titleLabel.text == "Widget 1"
@@ -132,7 +133,7 @@ def test_create_waveform1D_by_config(bec_figure):
 
 
 def test_change_gui_id(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
     w1.change_gui_id("new_id")
 
@@ -141,7 +142,7 @@ def test_change_gui_id(bec_figure):
 
 
 def test_getting_curve(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i", gui_id="test_curve")
     c1_expected_config = CurveConfig(
         widget_class="BECCurve",
@@ -171,7 +172,7 @@ def test_getting_curve(bec_figure):
 
 
 def test_getting_curve_errors(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i", gui_id="test_curve")
 
     with pytest.raises(ValueError) as excinfo:
@@ -188,7 +189,7 @@ def test_getting_curve_errors(bec_figure):
 
 
 def test_add_curve(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
 
@@ -199,7 +200,7 @@ def test_add_curve(bec_figure):
 
 
 def test_change_legend_font_size(bec_figure):
-    plot = bec_figure.add_plot()
+    plot = bec_figure.plot()
 
     w1 = plot.add_curve_scan(x_name="samx", y_name="bpm4i")
     my_func = plot.plot_item.legend
@@ -211,7 +212,7 @@ def test_change_legend_font_size(bec_figure):
 
 
 def test_remove_curve(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     w1.add_curve_scan(x_name="samx", y_name="bpm4i")
     w1.add_curve_scan(x_name="samx", y_name="bpm3a")
@@ -229,7 +230,7 @@ def test_remove_curve(bec_figure):
 
 
 def test_change_curve_appearance_methods(bec_figure, qtbot):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
 
@@ -258,7 +259,7 @@ def test_change_curve_appearance_methods(bec_figure, qtbot):
 
 
 def test_change_curve_appearance_args(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
 
@@ -288,7 +289,7 @@ def test_change_curve_appearance_args(bec_figure):
 
 
 def test_set_custom_curve_data(bec_figure, qtbot):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_custom(
         x=[1, 2, 3],
@@ -336,7 +337,7 @@ def test_custom_data_2D_array(bec_figure, qtbot):
 
 
 def test_get_all_data(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_custom(
         x=[1, 2, 3],
@@ -371,7 +372,7 @@ def test_get_all_data(bec_figure):
 
 
 def test_curve_add_by_config(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1_config_input = {
         "widget_class": "BECCurve",
@@ -411,7 +412,7 @@ def test_curve_add_by_config(bec_figure):
 
 
 def test_scan_update(bec_figure, qtbot):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
 
@@ -445,7 +446,7 @@ def test_scan_update(bec_figure, qtbot):
 
 
 def test_scan_history_with_val_access(bec_figure, qtbot):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
 
@@ -470,7 +471,7 @@ def test_scan_history_with_val_access(bec_figure, qtbot):
 
 
 def test_scatter_2d_update(bec_figure, qtbot):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="samx", z_name="bpm4i")
 

tests/unit_tests/test_yaml_dialog.py

@@ -7,7 +7,7 @@ import pytest
 import yaml
 from qtpy.QtWidgets import QPushButton, QVBoxLayout, QWidget
 
-from bec_widgets.utils.yaml_dialog import load_yaml, save_yaml
+from bec_widgets.utils.yaml_dialog import load_yaml_gui, save_yaml_gui
 
 
 @pytest.fixture(scope="function")
@@ -33,7 +33,7 @@ def test_load_yaml(qtbot, example_widget):
         temp_file.write(b"name: test\nvalue: 42")
 
     def load_yaml_wrapper():
-        config = load_yaml(example_widget)
+        config = load_yaml_gui(example_widget)
         if config:
             example_widget.config.update(config)
 
@@ -49,7 +49,7 @@ def test_load_yaml(qtbot, example_widget):
 
 def test_load_yaml_file_not_found(qtbot, example_widget, capsys):
     def load_yaml_wrapper():
-        config = load_yaml(example_widget)
+        config = load_yaml_gui(example_widget)
         if config:
             example_widget.config.update(config)
 
@@ -76,7 +76,7 @@ def test_load_yaml_general_exception(qtbot, example_widget, capsys, monkeypatch)
     monkeypatch.setattr("builtins.open", mock_open)
 
     def load_yaml_wrapper():
-        config = load_yaml(example_widget)
+        config = load_yaml_gui(example_widget)
         if config:
             example_widget.config.update(config)
 
@@ -96,7 +96,7 @@ def test_load_yaml_permission_error(qtbot, example_widget, monkeypatch, capsys):
     os.chmod(temp_file_path, 0o000)  # Remove permissions
 
     def load_yaml_wrapper():
-        config = load_yaml(example_widget)
+        config = load_yaml_gui(example_widget)
         if config:
             example_widget.config.update(config)
 
@@ -120,7 +120,7 @@ def test_load_yaml_invalid_yaml(qtbot, example_widget, capsys):
         temp_file.write(b"\tinvalid_yaml: [unbalanced_brackets: ]")
 
     def load_yaml_wrapper():
-        config = load_yaml(example_widget)
+        config = load_yaml_gui(example_widget)
         if config:
             example_widget.config.update(config)
 
@@ -147,7 +147,7 @@ def test_save_yaml(qtbot, example_widget):
     example_widget.saved_config = {"name": "test", "value": 42}
 
     def save_yaml_wrapper():
-        save_yaml(example_widget, example_widget.saved_config)
+        save_yaml_gui(example_widget, example_widget.saved_config)
 
     example_widget.export_button.clicked.connect(save_yaml_wrapper)