feat(waveform): original Ivans waveform ported from PyQt5 with plugin

0.77.0
Automatically generated by python-semantic-release
2026-06-18 11:01:03 +02:00 · 2024-07-02 15:00:37 +02:00 · 2024-07-02 11:00:18 +00:00 · 2024-07-02 12:43:56 +02:00 · 2024-07-02 12:43:38 +02:00 · 2024-07-02 12:43:38 +02:00
60 changed files with 3058 additions and 844 deletions
@@ -1,5 +1,137 @@
 # CHANGELOG

+## 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 &#34;add VT100 console executing BEC as a widget&#34; ([`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
+
+* build: added missing pytest-bec-e2e dependency; closes #219 ([`56fdae4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/56fdae42757bdb9fa301c1e425a77e98b6eaf92b))
+
+* build: fixed dependency ranges; closes #135 ([`e6a06c9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e6a06c9f43e0ad6bbfcfa550a2f580d2a27aff66))
+
+### Chore
+
+* chore: sorted dependencies alphabetically ([`21c807f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/21c807f35831fdd1ef2e488ab90edae4719f0cb7))
+
+### Documentation
+
+* docs: fixed doc string ([`f979a63`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f979a63d3d1a008f80e500510909750878ff4303))
+
+### Fix
+
+* fix(rings): rings properties updated right after setting ([`c8b7367`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c8b7367815b095f8e4aa8b819481efb701f2e542))
+
+* fix(motor_map): motor map can be removed from BECFigure with .remove() ([`6b25abf`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6b25abff70280271e2eeb70450553c05d4b7c99c))
+
+### Test
+
+* test(bec_figure): tests for removing widgets with rpc e2e ([`a268caa`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a268caaa30711fcc7ece542d24578d74cbf65c77))
+
+## v0.74.0 (2024-06-25)
+
+### Documentation
+
+* docs(becfigure): docs added ([`a51b15d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a51b15da3f5e83e0c897a0342bdb05b9c677a179))
+
+### Feature
+
+* feat(waveform1d): dap LMFit model can be added to plot ([`1866ba6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1866ba66c8e3526661beb13fff3e13af6a0ae562))
+
+### Test
+
+* test(waveform1d): dap e2e test added ([`7271b42`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7271b422f98ef9264970d708811c414b69a644db))
+
+## v0.73.2 (2024-06-25)
+
+### 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 &#34;close&#34; 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
@@ -21,135 +153,3 @@
 ### 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&#39;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)
-
-### Documentation
-
-* docs: fix typo in link ([`fdf11d8`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fdf11d8147750e379af9b17792761a267b49ae53))
-
-### 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))
-
-* feat(device_combobox): plugin added to bec-designer ([`e483b28`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e483b282db20a81182b87938ea172654092419b5))
-
-* feat: added entry point for bec-designer ([`36391db`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/36391db60735d57b371211791ddf8d3d00cebcf1))
-
-* feat(utils/bec-designer): added startup script to launched QtDesigner compatible with conda environments ([`5362334`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5362334ff3b07fc83653323a084a4b6946bade96))
-
-### 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))
-
-## v0.69.0 (2024-06-21)
-
-### Feature
-
-* feat(widgets): added vscode widget ([`48ae950`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/48ae950d57b454307ce409e2511f7b7adf3cfc6b))
-
-### Fix
-
-* fix(generate_cli): fixed rpc generate for classes without user access; closes #226 ([`925c893`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/925c893f3ff4337fc8b4d237c8ffc19a597b0996))
-
-## v0.68.0 (2024-06-21)
-
-### Feature
-
-* feat: properly handle SIGINT (ctrl-c) in BEC GUI server -&gt; calls qapplication.quit() ([`3644f34`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3644f344da2df674bc0d5740c376a86b9d0dfe95))
-
-* feat: bec-gui-server: redirect stdout and stderr (if any) as proper debug and error log entries ([`d1266a1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d1266a1ce148ff89557a039e3a182a87a3948f49))
-
-* feat: add logger for BEC GUI server ([`630616e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/630616ec729f60aa0b4d17a9e0379f9c6198eb96))
-
-### Fix
-
-* fix: ignore GUI server output (any output will go to log file)
-
-If a logger is given to log `_start_log_process`, the server stdout and
-stderr streams will be redirected as log entries with levels DEBUG or ERROR
-in their parent process ([`ce37416`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ce374163cab87a92847409051739777bc505a77b))
-
-* fix: do not create &#39;BECClient&#39; logger when instantiating BECDispatcher ([`f7d0b07`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f7d0b0768ace42a33e2556bb33611d4f02e5a6d9))
-
-## v0.67.0 (2024-06-21)
-
-### Documentation
-
-* docs: add widget to documentation ([`6fa1c06`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6fa1c06053131dabd084bb3cf13c853b5d3ce833))
-
-### Feature
-
-* feat: introduce BECStatusBox Widget ([`443b6c1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/443b6c1d7b02c772fda02e2d1eefd5bd40249e0c))
-
-### Refactor
-
-* refactor: Change inheritance to QTreeWidget from QWidget ([`d2f2b20`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d2f2b206bb0eab60b8a9b0d0ac60a6b7887fa6fb))
-
-### Test
-
-* test: add test suite for bec_status_box and status_item ([`5d4ca81`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5d4ca816cdedec4c88aba9eb326f85392504ea1c))
-
-### Unknown
-
-* Update file requirements.txt ([`505a5ec`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/505a5ec8334ff4422913b3a7b79d39bcb42ad535))
-
-## v0.66.1 (2024-06-20)
-
-### Fix
-
-* fix: fixed shutdown for pyside ([`2718bc6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2718bc624731301756df524d0d5beef6cb1c1430))
@@ -13,6 +13,7 @@ class Widgets(str, enum.Enum):
    Enum for the available widgets.
    """

+    BECQueue = "BECQueue"
    BECStatusBox = "BECStatusBox"
    BECDock = "BECDock"
    BECDockArea = "BECDockArea"
@@ -33,14 +34,21 @@ class BECCurve(RPCBase):

    @property
    @rpc_call
-    def rpc_id(self) -> "str":
+    def dap_params(self):
+        """
+        None
+        """
+
+    @property
+    @rpc_call
+    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.

@@ -143,11 +151,18 @@ class BECCurve(RPCBase):
            tuple[np.ndarray,np.ndarray]: X and Y data of the curve.
        """

+    @property
+    @rpc_call
+    def dap_params(self):
+        """
+        None
+        """
+

 class BECDock(RPCBase):
    @property
    @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
        """
        Get the configuration of the widget.

@@ -157,7 +172,7 @@ class BECDock(RPCBase):

    @property
    @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
        """
        Get the RPC ID of the widget.
        """
@@ -275,7 +290,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.

@@ -383,7 +398,7 @@ class BECDockArea(RPCBase, BECGuiClientMixin):
        """

    @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
        """
        Get all registered RPC objects.
        """
@@ -402,14 +417,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.

@@ -417,6 +432,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":
        """
@@ -439,102 +460,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,
-        **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,
@@ -550,6 +475,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":
        """
@@ -568,6 +498,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:
@@ -582,6 +517,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":
        """
@@ -593,6 +532,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:
@@ -601,7 +544,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.
@@ -609,6 +559,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:
@@ -659,12 +613,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]":
@@ -678,14 +626,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.

@@ -711,6 +659,7 @@ class BECImageItem(RPCBase):
            - log
            - rot
            - transpose
+            - autorange_mode
        """

    @rpc_call
@@ -767,6 +716,15 @@ class BECImageItem(RPCBase):
            autorange(bool): Whether to autorange the color bar.
        """

+    @rpc_call
+    def set_autorange_mode(self, mode: "Literal['max', 'mean']" = "mean"):
+        """
+        Set the autorange mode to scale the vrange of the color bar. Choose between min/max or mean +/- std.
+
+        Args:
+            mode(Literal["max","mean"]): Max for min/max or mean for mean +/- std.
+        """
+
    @rpc_call
    def set_color_map(self, cmap: "str" = "magma"):
        """
@@ -796,7 +754,11 @@ class BECImageItem(RPCBase):

    @rpc_call
    def set_vrange(
-        self, vmin: "float" = None, vmax: "float" = None, vrange: "tuple[int, int]" = None
+        self,
+        vmin: "float" = None,
+        vmax: "float" = None,
+        vrange: "tuple[float, float]" = None,
+        change_autorange: "bool" = True,
    ):
        """
        Set the range of the color bar.
@@ -818,14 +780,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.

@@ -845,34 +807,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,
@@ -888,7 +828,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,
@@ -931,6 +871,17 @@ class BECImageShow(RPCBase):
            name(str): The name of the image. If None, apply to all images.
        """

+    @rpc_call
+    def set_autorange_mode(self, mode: "Literal['max', 'mean']", name: "str" = None):
+        """
+        Set the autoscale mode of the image, that decides how the vrange of the color bar is scaled.
+        Choose betwen 'max' -> min/max of the data, 'mean' -> mean +/- fudge_factor*std of the data (fudge_factor~2).
+
+        Args:
+            mode(str): The autoscale mode of the image.
+            name(str): The name of the image. If None, apply to all images.
+        """
+
    @rpc_call
    def set_monitor(self, monitor: "str", name: "str" = None):
        """
@@ -1022,15 +973,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":
        """
@@ -1166,7 +1108,14 @@ class BECImageShow(RPCBase):
 class BECMotorMap(RPCBase):
    @property
    @rpc_call
-    def config_dict(self) -> "dict":
+    def _rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
+
+    @property
+    @rpc_call
+    def _config_dict(self) -> "dict":
        """
        Get the configuration of the widget.

@@ -1247,11 +1196,17 @@ class BECMotorMap(RPCBase):
            dict: Data of the motor map.
        """

+    @rpc_call
+    def remove(self):
+        """
+        Remove the plot widget from the figure.
+        """
+

 class BECPlotBase(RPCBase):
    @property
    @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
        """
        Get the configuration of the widget.

@@ -1391,10 +1346,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.

@@ -1403,7 +1358,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.
        """
@@ -1412,14 +1385,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.

@@ -1442,6 +1415,7 @@ class BECWaveform(RPCBase):
        color_map_z: "str | None" = "plasma",
        label: "str | None" = None,
        validate: "bool" = True,
+        dap: "str | None" = None,
    ) -> "BECCurve":
        """
        Plot a curve to the plot widget.
@@ -1458,11 +1432,50 @@ class BECWaveform(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.
+            dap(str): The dap model to use for the curve. If not specified, none will be added.

        Returns:
            BECCurve: The curve object.
        """

+    @rpc_call
+    def add_dap(
+        self,
+        x_name: "str",
+        y_name: "str",
+        x_entry: "Optional[str]" = None,
+        y_entry: "Optional[str]" = None,
+        color: "Optional[str]" = None,
+        dap: "str" = "GaussianModel",
+        **kwargs,
+    ) -> "BECCurve":
+        """
+        Add LMFIT dap model curve to the plot widget.
+
+        Args:
+            x_name(str): Name of the x signal.
+            x_entry(str): Entry of the x signal.
+            y_name(str): Name of the y signal.
+            y_entry(str): Entry of the y signal.
+            color(str, optional): Color of the curve. Defaults to None.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str, optional): Label of the curve. Defaults to None.
+            dap(str): The dap model to use for the curve.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+
+    @rpc_call
+    def get_dap_params(self) -> "dict":
+        """
+        Get the DAP parameters of all DAP curves.
+
+        Returns:
+            dict: DAP parameters of all DAP curves.
+        """
+
    @rpc_call
    def remove_curve(self, *identifiers):
        """
@@ -1504,28 +1517,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":
        """
@@ -1673,7 +1664,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.

@@ -1682,7 +1673,7 @@ class DeviceComboBox(RPCBase):
        """

    @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
        """
        Get all registered RPC objects.
        """
@@ -1691,7 +1682,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.

@@ -1700,7 +1691,7 @@ class DeviceInputBase(RPCBase):
        """

    @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
        """
        Get all registered RPC objects.
        """
@@ -1709,7 +1700,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.

@@ -1718,7 +1709,7 @@ class DeviceLineEdit(RPCBase):
        """

    @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
        """
        Get all registered RPC objects.
        """
@@ -1726,21 +1717,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.

@@ -1826,21 +1817,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.

@@ -2006,7 +1997,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.

@@ -2015,7 +2006,7 @@ class ScanControl(RPCBase):
        """

    @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
        """
        Get all registered RPC objects.
        """
@@ -2024,7 +2015,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.

@@ -2033,7 +2024,7 @@ class StopButton(RPCBase):
        """

    @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
        """
        Get all registered RPC objects.
        """
@@ -203,15 +203,12 @@ class BECGuiClientMixin:
        if self._process is None:
            return

-        self._run_rpc("close", (), wait_for_rpc_response=False)
-        while self.gui_is_alive():
-            time.sleep(0.2)
-
        self._client.shutdown()
        if self._process:
            self._process.terminate()
            if self._process_output_processing_thread:
                self._process_output_processing_thread.join()
+            self._process.wait()
            self._process = None


@@ -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"]
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import inspect
 import signal
 import sys
@@ -29,7 +31,7 @@ class BECWidgetsCLIServer:
        dispatcher: BECDispatcher = None,
        client=None,
        config=None,
-        gui_class: Union["BECFigure", "BECDockArea"] = BECFigure,
+        gui_class: Union[BECFigure, BECDockArea] = BECFigure,
    ) -> None:
        self.dispatcher = BECDispatcher(config=config) if dispatcher is None else dispatcher
        self.client = self.dispatcher.client if client is None else client
@@ -118,6 +120,7 @@ class BECWidgetsCLIServer:
    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
        self._shutdown_event = True
        self._heartbeat_timer.stop()
+        self.gui.close()
        self.client.shutdown()


@@ -207,6 +210,7 @@ def main():
                app.quit()

            signal.signal(signal.SIGINT, sigint_handler)
+            signal.signal(signal.SIGTERM, sigint_handler)

            sys.exit(app.exec())

@@ -14,21 +14,6 @@ from bec_widgets.widgets.dock.dock_area import BECDockArea
 from bec_widgets.widgets.figure import BECFigure
 from bec_widgets.widgets.jupyter_console.jupyter_console import BECJupyterConsole

-# class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
-#     def __init__(self):
-#         super().__init__()
-#
-#         self.kernel_manager = QtInProcessKernelManager()
-#         self.kernel_manager.start_kernel(show_banner=False)
-#         self.kernel_client = self.kernel_manager.client()
-#         self.kernel_client.start_channels()
-#
-#         self.kernel_manager.kernel.shell.push({"np": np, "pg": pg})
-#
-#     def shutdown_kernel(self):
-#         self.kernel_client.stop_channels()
-#         self.kernel_manager.shutdown_kernel()
-

 class JupyterConsoleWindow(QWidget):  # pragma: no cover:
    """A widget that contains a Jupyter console linked to BEC Widgets with full API access (contains Qt and pyqtgraph API)."""
@@ -55,12 +40,14 @@ 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,
                }
            )
@@ -89,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")
@@ -115,7 +122,8 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:

        self.d2 = self.dock.add_dock(name="dock_2", position="bottom")
        self.fig2 = self.d2.add_widget("BECFigure", row=0, col=0)
-        self.fig2.plot(x_name="samx", y_name="bpm4i")
+        self.plt = self.fig2.plot(x_name="samx", y_name="bpm3a")
+        self.plt.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
        self.bar = self.d2.add_widget("RingProgressBar", row=0, col=1)
        self.bar.set_diameter(200)

@@ -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:
        """
@@ -228,6 +286,7 @@ class BECConnector:
        all_connections = self.rpc_register.list_all_connections()
        if len(all_connections) == 0:
            print("No more connections. Shutting down GUI BEC client.")
+            self.bec_dispatcher.disconnect_all()
            self.client.shutdown()

    # def closeEvent(self, event):
@@ -21,12 +21,12 @@ if PYSIDE6:
 import bec_widgets


-def list_editable_packages() -> list[tuple[str, str]]:
+def list_editable_packages() -> set[str]:
    """
    List all editable packages in the environment.

    Returns:
-        list[tuple[str, str]]: A list of tuples containing the package name and the path to the package.
+        set: A set of paths to editable packages.
    """

    editable_packages = set()
@@ -1,6 +1,5 @@
 from __future__ import annotations

-import argparse
 import collections
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Union
@@ -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:
        """
@@ -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()
@@ -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()
@@ -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()
@@ -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:
@@ -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_())
@@ -0,0 +1 @@
+{'files': ['bec_queue.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()
@@ -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()
@@ -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_())
@@ -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",
@@ -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",
    ]

@@ -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]:
        """
@@ -195,11 +238,12 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        z_entry: str = None,
        x: list | np.ndarray = None,
        y: list | np.ndarray = None,
-        color: Optional[str] = None,
-        color_map_z: Optional[str] = "plasma",
-        label: Optional[str] = None,
+        color: str | None = None,
+        color_map_z: str | None = "plasma",
+        label: str | None = None,
        validate: bool = True,
-    ):
+        dap: str | None = None,
+    ) -> BECWaveform:
        """
        Configure the waveform based on the provided parameters.

@@ -217,6 +261,7 @@ 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.
+            dap (str): The DAP model to use for the curve.
        """
        if x is not None and y is None:
            if isinstance(x, np.ndarray):
@@ -240,7 +285,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
            return waveform
        # User wants to add scan curve -> 1D Waveform
        if x_name is not None and y_name is not None and z_name is None and x is None and y is None:
-            waveform.add_curve_scan(
+            waveform.plot(
                x_name=x_name,
                y_name=y_name,
                x_entry=x_entry,
@@ -248,6 +293,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
                validate=validate,
                color=color,
                label=label,
+                dap=dap,
            )
        # User wants to add scan curve -> 2D Waveform Scatter
        if (
@@ -257,7 +303,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
            and x is None
            and y is None
        ):
-            waveform.add_curve_scan(
+            waveform.plot(
                x_name=x_name,
                y_name=y_name,
                z_name=z_name,
@@ -268,6 +314,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
                color_map_z=color_map_z,
                label=label,
                validate=validate,
+                dap=dap,
            )
        # User wants to add custom curve
        elif x is not None and y is not None and x_name is None and y_name is None:
@@ -275,73 +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,
-        **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,
-        )
-        return waveform
-
    @typechecked
    def plot(
        self,
@@ -357,6 +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:
        """
@@ -375,20 +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,
@@ -403,8 +391,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
            color_map_z=color_map_z,
            label=label,
            validate=validate,
+            dap=dap,
        )
-        # TODO remove repetition from .plot method
        return waveform

    def _init_image(
@@ -451,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:
        """
@@ -462,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,
@@ -544,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,
@@ -644,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:
@@ -747,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.")

@@ -5,14 +5,18 @@ 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

 from bec_widgets.utils import EntryValidator
 from bec_widgets.widgets.figure.plots.image.image_item import BECImageItem, ImageItemConfig
-from bec_widgets.widgets.figure.plots.image.image_processor import ImageProcessor, ProcessorWorker
+from bec_widgets.widgets.figure.plots.image.image_processor import (
+    ImageProcessor,
+    ImageStats,
+    ProcessorWorker,
+)
 from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig


@@ -25,16 +29,15 @@ 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",
        "set_color_map",
        "set_autorange",
+        "set_autorange_mode",
        "set_monitor",
        "set_processing",
        "set_image_properties",
@@ -42,7 +45,6 @@ class BECImageShow(BECPlotBase):
        "set_log",
        "set_rotation",
        "set_transpose",
-        "toggle_threading",
        "set",
        "set_title",
        "set_x_label",
@@ -86,6 +88,7 @@ class BECImageShow(BECPlotBase):
        # Connect signals and slots
        thread.started.connect(lambda: worker.process_image(device, image))
        worker.processed.connect(self.update_image)
+        worker.stats.connect(self.update_vrange)
        worker.finished.connect(thread.quit)
        worker.finished.connect(thread.wait)
        worker.finished.connect(worker.deleteLater)
@@ -132,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):
        """
@@ -220,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,
@@ -235,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",
@@ -245,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(
@@ -258,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}'.")

@@ -284,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(
@@ -307,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):
        """
@@ -341,6 +350,17 @@ class BECImageShow(BECPlotBase):
        """
        self.apply_setting_to_images("set_autorange", args=[enable], kwargs={}, image_id=name)

+    def set_autorange_mode(self, mode: Literal["max", "mean"], name: str = None):
+        """
+        Set the autoscale mode of the image, that decides how the vrange of the color bar is scaled.
+        Choose betwen 'max' -> min/max of the data, 'mean' -> mean +/- fudge_factor*std of the data (fudge_factor~2).
+
+        Args:
+            mode(str): The autoscale mode of the image.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_autorange_mode", args=[mode], kwargs={}, image_id=name)
+
    def set_monitor(self, monitor: str, name: str = None):
        """
        Set the monitor of the image.
@@ -443,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):
        """
@@ -453,14 +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)
+        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):
@@ -474,6 +509,27 @@ class BECImageShow(BECPlotBase):
        image_to_update = self._images["device_monitor"][device]
        image_to_update.updateImage(data, autoLevels=image_to_update.config.autorange)

+    @pyqtSlot(str, ImageStats)
+    def update_vrange(self, device: str, stats: ImageStats):
+        """
+        Update the scaling of the image.
+
+        Args:
+            stats(ImageStats): The statistics of the image.
+        """
+        image_to_update = self._images["device_monitor"][device]
+        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.
@@ -486,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
@@ -504,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)
@@ -528,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.
@@ -7,7 +7,7 @@ import pyqtgraph as pg
 from pydantic import Field

 from bec_widgets.utils import BECConnector, ConnectionConfig
-from bec_widgets.widgets.figure.plots.image.image_processor import ProcessingConfig
+from bec_widgets.widgets.figure.plots.image.image_processor import ImageStats, ProcessingConfig

 if TYPE_CHECKING:
    from bec_widgets.widgets.figure.plots.image.image import BECImageShow
@@ -20,13 +20,16 @@ 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[int, int]] = 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(
        "simple", description="The type of the color bar."
    )
    autorange: Optional[bool] = Field(True, description="Whether to autorange the color bar.")
+    autorange_mode: Optional[Literal["max", "mean"]] = Field(
+        "mean", description="Whether to use the mean of the image for autoscaling."
+    )
    processing: ProcessingConfig = Field(
        default_factory=ProcessingConfig, description="The post processing of the image."
    )
@@ -34,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",
@@ -43,6 +46,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
        "set_transpose",
        "set_opacity",
        "set_autorange",
+        "set_autorange_mode",
        "set_color_map",
        "set_auto_downsample",
        "set_monitor",
@@ -74,6 +78,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
        self.apply_config()
        if kwargs:
            self.set(**kwargs)
+        self.connected = False

    def apply_config(self):
        """
@@ -101,6 +106,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
            - log
            - rot
            - transpose
+            - autorange_mode
        """
        method_map = {
            "downsample": self.set_auto_downsample,
@@ -112,6 +118,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
            "log": self.set_log,
            "rot": self.set_rotation,
            "transpose": self.set_transpose,
+            "autorange_mode": self.set_autorange_mode,
        }
        for key, value in kwargs.items():
            if key in method_map:
@@ -175,9 +182,18 @@ class BECImageItem(BECConnector, pg.ImageItem):
            autorange(bool): Whether to autorange the color bar.
        """
        self.config.autorange = autorange
-        if self.color_bar is not None:
+        if self.color_bar and autorange:
            self.color_bar.autoHistogramRange()

+    def set_autorange_mode(self, mode: Literal["max", "mean"] = "mean"):
+        """
+        Set the autorange mode to scale the vrange of the color bar. Choose between min/max or mean +/- std.
+
+        Args:
+            mode(Literal["max","mean"]): Max for min/max or mean for mean +/- std.
+        """
+        self.config.autorange_mode = mode
+
    def set_color_map(self, cmap: str = "magma"):
        """
        Set the color map of the image.
@@ -212,7 +228,29 @@ class BECImageItem(BECConnector, pg.ImageItem):
        """
        self.config.monitor = monitor

-    def set_vrange(self, vmin: float = None, vmax: float = None, vrange: tuple[int, int] = None):
+    def auto_update_vrange(self, stats: ImageStats) -> None:
+        """Auto update of the vrange base on the stats of the image.
+
+        Args:
+            stats(ImageStats): The stats of the image.
+        """
+        fumble_factor = 2
+        if self.config.autorange_mode == "mean":
+            vmin = max(stats.mean - fumble_factor * stats.std, 0)
+            vmax = stats.mean + fumble_factor * stats.std
+            self.set_vrange(vmin, vmax, change_autorange=False)
+            return
+        if self.config.autorange_mode == "max":
+            self.set_vrange(max(stats.minimum, 0), stats.maximum, change_autorange=False)
+            return
+
+    def set_vrange(
+        self,
+        vmin: float = None,
+        vmax: float = None,
+        vrange: tuple[float, float] = None,
+        change_autorange: bool = True,
+    ):
        """
        Set the range of the color bar.

@@ -224,11 +262,13 @@ class BECImageItem(BECConnector, pg.ImageItem):
            vmin, vmax = vrange
        self.setLevels([vmin, vmax])
        self.config.vrange = (vmin, vmax)
-        self.config.autorange = False
+        if change_autorange:
+            self.config.autorange = False
        if self.color_bar is not None:
            if self.config.color_bar == "simple":
                self.color_bar.setLevels(low=vmin, high=vmax)
            elif self.config.color_bar == "full":
+                # pylint: disable=unexpected-keyword-arg
                self.color_bar.setLevels(min=vmin, max=vmax)
                self.color_bar.setHistogramRange(vmin - 0.1 * vmin, vmax + 0.1 * vmax)

@@ -1,5 +1,6 @@
 from __future__ import annotations

+from dataclasses import dataclass
 from typing import Optional

 import numpy as np
@@ -7,6 +8,16 @@ from pydantic import BaseModel, Field
 from qtpy.QtCore import QObject, Signal, Slot


+@dataclass
+class ImageStats:
+    """Container to store stats of an image."""
+
+    maximum: float
+    minimum: float
+    mean: float
+    std: float
+
+
 class ProcessingConfig(BaseModel):
    fft: Optional[bool] = Field(False, description="Whether to perform FFT on the monitor data.")
    log: Optional[bool] = Field(False, description="Whether to perform log on the monitor data.")
@@ -20,6 +31,10 @@ class ProcessingConfig(BaseModel):
        None, description="The rotation angle of the monitor data before displaying."
    )
    model_config: dict = {"validate_assignment": True}
+    stats: ImageStats = Field(
+        ImageStats(maximum=0, minimum=0, mean=0, std=0),
+        description="The statistics of the image data.",
+    )


 class ImageProcessor:
@@ -97,6 +112,18 @@ class ImageProcessor:
    # def center_of_mass(self, data: np.ndarray) -> tuple:  # TODO check functionality
    #     return np.unravel_index(np.argmax(data), data.shape)

+    def update_image_stats(self, data: np.ndarray) -> None:
+        """Get the statistics of the image data.
+
+        Args:
+            data(np.ndarray): The image data.
+
+        """
+        self.config.stats.maximum = np.max(data)
+        self.config.stats.minimum = np.min(data)
+        self.config.stats.mean = np.mean(data)
+        self.config.stats.std = np.std(data)
+
    def process_image(self, data: np.ndarray) -> np.ndarray:
        """
        Process the data according to the configuration.
@@ -115,6 +142,7 @@ class ImageProcessor:
            data = self.transpose(data)
        if self.config.log:
            data = self.log(data)
+        self.update_image_stats(data)
        return data


@@ -124,6 +152,7 @@ class ProcessorWorker(QObject):
    """

    processed = Signal(str, np.ndarray)
+    stats = Signal(str, ImageStats)
    stopRequested = Signal()
    finished = Signal()

@@ -147,6 +176,7 @@ class ProcessorWorker(QObject):
        self._isRunning = False
        if not self._isRunning:
            self.processed.emit(device, processed_image)
+            self.stats.emit(self.processor.config.stats)
            self.finished.emit()

    def stop(self):
@@ -6,22 +6,23 @@ 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.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.")
    num_dim_points: Optional[int] = Field(
@@ -30,13 +31,26 @@ class MotorMapConfig(SubplotConfig):
    )
    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 = [
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
        "change_motors",
        "set_max_points",
        "set_precision",
@@ -44,6 +58,7 @@ class BECMotorMap(BECPlotBase):
        "set_background_value",
        "set_scatter_size",
        "get_data",
+        "remove",
    ]

    # QT Signals
@@ -67,29 +82,43 @@ 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)
    def change_motors(
@@ -127,6 +156,8 @@ class BECMotorMap(BECPlotBase):
        # reconnect the signals
        self._connect_motor_to_slots()

+        self.database_buffer = {"x": [], "y": []}
+
        # Redraw the motor map
        self._make_motor_map()

@@ -139,7 +170,19 @@ class BECMotorMap(BECPlotBase):
        data = {"x": self.database_buffer["x"], "y": self.database_buffer["y"]}
        return data

-    # TODO setup all visual properties
+    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.
@@ -148,6 +191,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:
        """
@@ -157,6 +201,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:
        """
@@ -166,6 +211,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:
        """
@@ -175,6 +221,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:
        """
@@ -184,6 +231,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."""
@@ -208,6 +256,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.
@@ -247,6 +304,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,19 +430,31 @@ class BECMotorMap(BECPlotBase):

    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
@@ -46,7 +46,7 @@ class SubplotConfig(ConnectionConfig):

 class BECPlotBase(BECConnector, pg.GraphicsLayout):
    USER_ACCESS = [
-        "config_dict",
+        "_config_dict",
        "set",
        "set_title",
        "set_x_label",
@@ -1,10 +1,12 @@
 from __future__ import annotations

+import time
 from collections import defaultdict
 from typing import Any, Literal, Optional

 import numpy as np
 import pyqtgraph as pg
+from bec_lib import messages
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.scan_data import ScanData
 from pydantic import Field, ValidationError
@@ -33,15 +35,15 @@ class Waveform1DConfig(SubplotConfig):

 class BECWaveform(BECPlotBase):
    USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
        "plot",
+        "add_dap",
+        "get_dap_params",
        "remove_curve",
        "scan_history",
        "curves",
        "get_curve",
-        "get_curve_config",
-        "apply_config",
        "get_all_data",
        "set",
        "set_title",
@@ -57,6 +59,7 @@ class BECWaveform(BECPlotBase):
        "set_legend_label_size",
    ]
    scan_signal_update = pyqtSignal()
+    dap_params_update = pyqtSignal(dict)

    def __init__(
        self,
@@ -73,6 +76,7 @@ class BECWaveform(BECPlotBase):
        )

        self._curves_data = defaultdict(dict)
+        self.old_scan_id = None
        self.scan_id = None

        # Scan segment update proxy
@@ -80,6 +84,9 @@ class BECWaveform(BECPlotBase):
            self.scan_signal_update, rateLimit=25, slot=self._update_scan_segment_plot
        )

+        self.proxy_update_dap = pg.SignalProxy(
+            self.scan_signal_update, rateLimit=25, slot=self.refresh_dap
+        )
        # Get bec shortcuts dev, scans, queue, scan_storage, dap
        self.get_bec_shortcuts()

@@ -213,6 +220,7 @@ class BECWaveform(BECPlotBase):
        color_map_z: str | None = "plasma",
        label: str | None = None,
        validate: bool = True,
+        dap: str | None = None,  # TODO add dap custom curve wrapper
    ) -> BECCurve:
        """
        Plot a curve to the plot widget.
@@ -229,6 +237,7 @@ class BECWaveform(BECPlotBase):
            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.
+            dap(str): The dap model to use for the curve. If not specified, none will be added.

        Returns:
            BECCurve: The curve object.
@@ -237,6 +246,8 @@ class BECWaveform(BECPlotBase):
        if x is not None and y is not None:
            return self.add_curve_custom(x=x, y=y, label=label, color=color)
        else:
+            if dap:
+                self.add_dap(x_name=x_name, y_name=y_name, dap=dap)
            return self.add_curve_scan(
                x_name=x_name,
                y_name=y_name,
@@ -256,6 +267,7 @@ class BECWaveform(BECPlotBase):
        y: list | np.ndarray,
        label: str = None,
        color: str = None,
+        curve_source: str = "custom",
        **kwargs,
    ) -> BECCurve:
        """
@@ -266,12 +278,13 @@ class BECWaveform(BECPlotBase):
            y(list|np.ndarray): Y data of the curve.
            label(str, optional): Label of the curve. Defaults to None.
            color(str, optional): Color of the curve. Defaults to None.
+            curve_source(str, optional): Tag for source of the curve. Defaults to "custom".
            **kwargs: Additional keyword arguments for the curve configuration.

        Returns:
            BECCurve: The curve object.
        """
-        curve_source = "custom"
+        curve_source = curve_source
        curve_id = label or f"Curve {len(self.plot_item.curves) + 1}"

        curve_exits = self._check_curve_id(curve_id, self._curves_data)
@@ -314,10 +327,12 @@ class BECWaveform(BECPlotBase):
        color_map_z: Optional[str] = "plasma",
        label: Optional[str] = None,
        validate_bec: bool = True,
+        source: str = "scan_segment",
+        dap: Optional[str] = None,
        **kwargs,
    ) -> BECCurve:
        """
-        Add a curve to the plot widget from the scan segment.
+        Add a curve to the plot widget from the scan segment. #TODO adapt docs to DAP

        Args:
            x_name(str): Name of the x signal.
@@ -335,7 +350,7 @@ class BECWaveform(BECPlotBase):
            BECCurve: The curve object.
        """
        # Check if curve already exists
-        curve_source = "scan_segment"
+        curve_source = source

        # Get entry if not provided and validate
        x_entry, y_entry, z_entry = self._validate_signal_entries(
@@ -371,12 +386,74 @@ class BECWaveform(BECPlotBase):
                x=SignalData(name=x_name, entry=x_entry),
                y=SignalData(name=y_name, entry=y_entry),
                z=SignalData(name=z_name, entry=z_entry) if z_name else None,
+                dap=dap,
            ),
            **kwargs,
        )
        curve = self._add_curve_object(name=label, source=curve_source, config=curve_config)
        return curve

+    def add_dap(
+        self,
+        x_name: str,
+        y_name: str,
+        x_entry: Optional[str] = None,
+        y_entry: Optional[str] = None,
+        color: Optional[str] = None,
+        dap: str = "GaussianModel",
+        **kwargs,
+    ) -> BECCurve:
+        """
+        Add LMFIT dap model curve to the plot widget.
+
+        Args:
+            x_name(str): Name of the x signal.
+            x_entry(str): Entry of the x signal.
+            y_name(str): Name of the y signal.
+            y_entry(str): Entry of the y signal.
+            color(str, optional): Color of the curve. Defaults to None.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str, optional): Label of the curve. Defaults to None.
+            dap(str): The dap model to use for the curve.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        x_entry, y_entry, _ = self._validate_signal_entries(
+            x_name, y_name, None, x_entry, y_entry, None
+        )
+        label = f"{y_name}-{y_entry}-{dap}"
+        curve = self.add_curve_scan(
+            x_name=x_name,
+            y_name=y_name,
+            x_entry=x_entry,
+            y_entry=y_entry,
+            color=color,
+            label=label,
+            source="DAP",
+            dap=dap,
+            pen_style="dash",
+            symbol="star",
+            **kwargs,
+        )
+
+        self.setup_dap(self.old_scan_id, self.scan_id)
+        self.refresh_dap()
+        return curve
+
+    def get_dap_params(self) -> dict:
+        """
+        Get the DAP parameters of all DAP curves.
+
+        Returns:
+            dict: DAP parameters of all DAP curves.
+        """
+        params = {}
+        for curve_id, curve in self._curves_data["DAP"].items():
+            params[curve_id] = curve.dap_params
+        return params
+
    def _add_curve_object(
        self,
        name: str,
@@ -528,13 +605,75 @@ class BECWaveform(BECPlotBase):
            return

        if current_scan_id != self.scan_id:
+            self.old_scan_id = self.scan_id
            self.scan_id = current_scan_id
            self.scan_segment_data = self.queue.scan_storage.find_scan_by_ID(
                self.scan_id
            )  # TODO do scan access through BECFigure
+            self.setup_dap(self.old_scan_id, self.scan_id)

        self.scan_signal_update.emit()

+    def setup_dap(self, old_scan_id, new_scan_id):
+        """
+        Setup DAP for the new scan.
+
+        Args:
+            old_scan_id(str): old_scan_id, used to disconnect the previous dispatcher connection.
+            new_scan_id(str): new_scan_id, used to connect the new dispatcher connection.
+
+        """
+        self.bec_dispatcher.disconnect_slot(
+            self.update_dap, MessageEndpoints.dap_response(old_scan_id)
+        )
+        if len(self._curves_data["DAP"]) > 0:
+            self.bec_dispatcher.connect_slot(
+                self.update_dap, MessageEndpoints.dap_response(new_scan_id)
+            )
+
+    def refresh_dap(self):
+        """
+        Refresh the DAP curves with the latest data from the DAP model MessageEndpoints.dap_response().
+        """
+        for curve_id, curve in self._curves_data["DAP"].items():
+            x_name = curve.config.signals.x.name
+            y_name = curve.config.signals.y.name
+            x_entry = curve.config.signals.x.entry
+            y_entry = curve.config.signals.y.entry
+            model_name = curve.config.signals.dap
+            model = getattr(self.dap, model_name)
+
+            msg = messages.DAPRequestMessage(
+                dap_cls="LmfitService1D",
+                dap_type="on_demand",
+                config={
+                    "args": [self.scan_id, x_name, x_entry, y_name, y_entry],
+                    "kwargs": {},
+                    "class_args": model._plugin_info["class_args"],
+                    "class_kwargs": model._plugin_info["class_kwargs"],
+                },
+                metadata={"RID": self.scan_id},
+            )
+            self.client.connector.set_and_publish(MessageEndpoints.dap_request(), msg)
+
+    @pyqtSlot(dict, dict)
+    def update_dap(self, msg, metadata):
+        self.msg = msg
+        scan_id, x_name, x_entry, y_name, y_entry = msg["dap_request"].content["config"]["args"]
+        model = msg["dap_request"].content["config"]["class_kwargs"]["model"]
+
+        curve_id_request = f"{y_name}-{y_entry}-{model}"
+
+        for curve_id, curve in self._curves_data["DAP"].items():
+            if curve_id == curve_id_request:
+                if msg["data"] is not None:
+                    x = msg["data"][0]["x"]
+                    y = msg["data"][0]["y"]
+                    curve.setData(x, y)
+                    curve.dap_params = msg["data"][1]["fit_parameters"]
+                    self.dap_params_update.emit(curve.dap_params)
+                break
+
    def _update_scan_segment_plot(self):
        """Update the plot with the data from the scan segment."""
        data = self.scan_segment_data.data
@@ -564,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)

@@ -609,13 +749,17 @@ class BECWaveform(BECPlotBase):
        if scan_index is not None and scan_id is not None:
            raise ValueError("Only one of scan_id or scan_index can be provided.")

+        # Reset DAP connector
+        self.bec_dispatcher.disconnect_slot(
+            self.update_dap, MessageEndpoints.dap_response(self.scan_id)
+        )
        if scan_index is not None:
            self.scan_id = self.queue.scan_storage.storage[scan_index].scan_id
-            data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data
        elif scan_id is not None:
            self.scan_id = scan_id
-            data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data

+        self.setup_dap(self.old_scan_id, self.scan_id)
+        data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data
        self._update_scan_curves(data)

    def get_all_data(self, output: Literal["dict", "pandas"] = "dict") -> dict | pd.DataFrame:
@@ -661,6 +805,9 @@ class BECWaveform(BECPlotBase):
    def cleanup(self):
        """Cleanup the widget connection from BECDispatcher."""
        self.bec_dispatcher.disconnect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+        self.bec_dispatcher.disconnect_slot(
+            self.update_dap, MessageEndpoints.dap_response(self.scan_id)
+        )
        for curve in self.curves:
            curve.cleanup()
        super().cleanup()
@@ -31,6 +31,7 @@ class Signal(BaseModel):
    x: SignalData  # TODO maybe add metadata for config gui later
    y: SignalData
    z: Optional[SignalData] = None
+    dap: Optional[str] = None
    model_config: dict = {"validate_assignment": True}


@@ -63,8 +64,9 @@ class CurveConfig(ConnectionConfig):
 class BECCurve(BECConnector, pg.PlotDataItem):
    USER_ACCESS = [
        "remove",
-        "rpc_id",
-        "config_dict",
+        "dap_params",
+        "_rpc_id",
+        "_config_dict",
        "set",
        "set_data",
        "set_color",
@@ -75,6 +77,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
        "set_pen_width",
        "set_pen_style",
        "get_data",
+        "dap_params",
    ]

    def __init__(
@@ -96,6 +99,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):

        self.parent_item = parent_item
        self.apply_config()
+        self.dap_params = None
        if kwargs:
            self.set(**kwargs)

@@ -119,6 +123,14 @@ class BECCurve(BECConnector, pg.PlotDataItem):
            self.setSymbolSize(self.config.symbol_size)
            self.setSymbol(self.config.symbol)

+    @property
+    def dap_params(self):
+        return self._dap_params
+
+    @dap_params.setter
+    def dap_params(self, value):
+        self._dap_params = value
+
    def set_data(self, x, y):
        if self.config.source == "custom":
            self.setData(x, y)
@@ -241,5 +253,6 @@ class BECCurve(BECConnector, pg.PlotDataItem):

    def remove(self):
        """Remove the curve from the plot."""
-        self.parent_item.removeItem(self)
+        # self.parent_item.removeItem(self)
+        self.parent_item.remove_curve(self.name())
        self.cleanup()
@@ -0,0 +1,154 @@
+import itertools
+from threading import RLock
+
+import pyqtgraph as pg
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import Property as pyqtProperty, Slot as pyqtSlot
+
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+logger = bec_logger.logger
+
+pg.setConfigOptions(background="w", foreground="k", antialias=True)
+COLORS = ["#fd7f6f", "#7eb0d5", "#b2e061", "#bd7ebe", "#ffb55a"]
+
+
+class BECScanPlot(pg.GraphicsView):
+    def __init__(self, parent=None, background="default"):
+        super().__init__(parent, background)
+        BECDispatcher().connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+
+        self.view = pg.PlotItem()
+        self.setCentralItem(self.view)
+
+        self._scanID = None
+        self._scanID_lock = RLock()
+
+        self._x_channel = ""
+        self._y_channel_list = []
+
+        self.scan_curves = {}
+        self.dap_curves = {}
+
+        self.x_channel = "samx"
+        self.y_channel_list = ["bpm3y", "bpm6y"]
+
+    def reset_plots(self, _scan_segment, _metadata):
+        for plot_curve in {**self.scan_curves, **self.dap_curves}.values():
+            plot_curve.setData(x=[], y=[])
+
+    @pyqtSlot(dict, dict)
+    def on_scan_segment(self, scan_segment, metadata):
+        # reset plots on scanID change
+        with self._scanID_lock:
+            scan_id = scan_segment["scan_id"]
+            if self._scanID != scan_id:
+                self._scanID = scan_id
+                self.reset_plots(scan_segment, metadata)
+
+        if not self.x_channel:
+            return
+
+        data = scan_segment["data"]
+
+        if self.x_channel not in data:
+            logger.warning(f"Unknown channel `{self.x_channel}` for X data in {self.objectName()}")
+            return
+
+        x_new = data[self.x_channel][self.x_channel]["value"]
+        for chan, plot_curve in self.scan_curves.items():
+            if not chan:
+                continue
+
+            if chan not in data:
+                logger.warning(f"Unknown channel `{chan}` for Y data in {self.objectName()}")
+                continue
+
+            y_new = data[chan][chan]["value"]
+            x, y = plot_curve.getData()  # TODO: is it a good approach?
+            if x is None:
+                x = []
+            if y is None:
+                y = []
+
+            plot_curve.setData(x=[*x, x_new], y=[*y, y_new])
+
+    @pyqtSlot(dict, dict)
+    def redraw_dap(self, content, _metadata):
+        data = content["data"]
+        for chan, plot_curve in self.dap_curves.items():
+            if not chan:
+                continue
+
+            if chan not in data:
+                logger.warning(f"Unknown channel `{chan}` for DAP data in {self.objectName()}")
+                continue
+
+            x_new = data[chan]["x"]
+            y_new = data[chan]["y"]
+
+            plot_curve.setData(x=x_new, y=y_new)
+
+    @pyqtProperty("QStringList")
+    def y_channel_list(self):
+        return self._y_channel_list
+
+    @y_channel_list.setter
+    def y_channel_list(self, new_list):
+        bec_dispatcher = BECDispatcher()
+        # TODO: do we want to care about dap/not dap here?
+        chan_removed = [chan for chan in self._y_channel_list if chan not in new_list]
+        if chan_removed and chan_removed[0].startswith("dap."):
+            chan_removed = chan_removed[0].partition("dap.")[-1]
+            chan_removed_ep = MessageEndpoints.processed_data(chan_removed)
+            bec_dispatcher.disconnect_slot(self.redraw_dap, chan_removed_ep)
+
+        self._y_channel_list = new_list
+
+        # Prepare plot for a potentially different list of y channels
+        self.view.clear()
+
+        self.view.addLegend()
+        colors = itertools.cycle(COLORS)
+
+        for y_chan in new_list:
+            if y_chan.startswith("dap."):
+                y_chan = y_chan.partition("dap.")[-1]
+                curves = self.dap_curves
+                y_chan_ep = MessageEndpoints.processed_data(y_chan)
+                bec_dispatcher.connect_slot(self.redraw_dap, y_chan_ep)
+            else:
+                curves = self.scan_curves
+
+            curves[y_chan] = self.view.plot(
+                x=[], y=[], pen=pg.mkPen(color=next(colors), width=2), name=y_chan
+            )
+
+        if len(new_list) == 1:
+            self.view.setLabel("left", new_list[0])
+
+    @pyqtProperty(str)
+    def x_channel(self):
+        return self._x_channel
+
+    @x_channel.setter
+    def x_channel(self, new_val):
+        self._x_channel = new_val
+        self.view.setLabel("bottom", new_val)
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+
+    plot = BECScanPlot()
+    plot.x_channel = "samx"
+    plot.y_channel_list = ["bpm3y", "bpm6y"]
+
+    plot.show()
+
+    sys.exit(app.exec())
@@ -0,0 +1 @@
+{'files': ['ivan_waveform.py']}
@@ -0,0 +1,56 @@
+from qtpy.QtGui import QIcon
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.widgets.ivan_waveform.ivan_waveform import BECScanPlot
+
+
+class BECScanPlotPlugin(QDesignerCustomWidgetInterface):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self._initialized = False
+
+    def initialize(self, formEditor):
+        if self._initialized:
+            return
+
+        self._initialized = True
+
+    def isInitialized(self):
+        return self._initialized
+
+    def createWidget(self, parent):
+        return BECScanPlot(parent)
+
+    def name(self):
+        return "BECScanPlot"
+
+    def group(self):
+        return "BEC widgets"
+
+    def icon(self):
+        return QIcon()
+
+    def toolTip(self):
+        return "BEC plot for scans"
+
+    def whatsThis(self):
+        return "BEC plot for scans"
+
+    def isContainer(self):
+        return False
+
+    def domXml(self):
+        return (
+            '<widget class="BECScanPlot" name="BECScanPlot">\n'
+            ' <property name="toolTip" >\n'
+            "  <string>BEC plot for scans</string>\n"
+            " </property>\n"
+            ' <property name="whatsThis" >\n'
+            "  <string>BEC plot for scans in Python using PyQt.</string>\n"
+            " </property>\n"
+            "</widget>\n"
+        )
+
+    def includeFile(self):
+        return "scan_plot"
@@ -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.ivan_waveform.ivan_waveform_plugin import BECScanPlotPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECScanPlotPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
@@ -2,7 +2,7 @@ from __future__ import annotations

 from typing import Literal, Optional

-from bec_lib.endpoints import EndpointInfo
+from bec_lib.endpoints import EndpointInfo, MessageEndpoints
 from pydantic import BaseModel, Field, field_validator
 from pydantic_core import PydanticCustomError
 from qtpy import QtGui
@@ -21,14 +21,14 @@ class ProgressbarConnections(BaseModel):
        slot = values.data["slot"]
        v = v.endpoint if isinstance(v, EndpointInfo) else v
        if slot == "on_scan_progress":
-            if v != "scans/scan_progress":
+            if v != MessageEndpoints.scan_progress().endpoint:
                raise PydanticCustomError(
                    "unsupported endpoint",
                    "For slot 'on_scan_progress', endpoint must be MessageEndpoint.scan_progress or 'scans/scan_progress'.",
                    {"wrong_value": v},
                )
        elif slot == "on_device_readback":
-            if not v.startswith("internal/devices/readback/"):
+            if not v.startswith(MessageEndpoints.device_readback("").endpoint):
                raise PydanticCustomError(
                    "unsupported endpoint",
                    "For slot 'on_device_readback', endpoint must be MessageEndpoint.device_readback(device) or 'internal/devices/readback/{device}'.",
@@ -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",
@@ -135,6 +135,7 @@ class Ring(BECConnector):
            float(max(self.config.min_value, min(self.config.max_value, value))),
            self.config.precision,
        )
+        self.parent_progress_widget.update()

    def set_color(self, color: str | tuple):
        """
@@ -145,6 +146,7 @@ class Ring(BECConnector):
        """
        self.config.color = color
        self.color = self.convert_color(color)
+        self.parent_progress_widget.update()

    def set_background(self, color: str | tuple):
        """
@@ -155,6 +157,7 @@ class Ring(BECConnector):
        """
        self.config.background_color = color
        self.color = self.convert_color(color)
+        self.parent_progress_widget.update()

    def set_line_width(self, width: int):
        """
@@ -164,6 +167,7 @@ class Ring(BECConnector):
            width(int): Line width for the ring widget
        """
        self.config.line_width = width
+        self.parent_progress_widget.update()

    def set_min_max_values(self, min_value: int | float, max_value: int | float):
        """
@@ -175,6 +179,7 @@ class Ring(BECConnector):
        """
        self.config.min_value = min_value
        self.config.max_value = max_value
+        self.parent_progress_widget.update()

    def set_start_angle(self, start_angle: int):
        """
@@ -185,6 +190,7 @@ class Ring(BECConnector):
        """
        self.config.start_position = start_angle
        self.start_position = start_angle * 16
+        self.parent_progress_widget.update()

    @staticmethod
    def convert_color(color):
@@ -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)
@@ -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:
@@ -60,7 +60,7 @@ class VSCodeEditor(WebsiteWidget):
        """
        Cleanup the VSCode editor.
        """
-        if not self.process:
+        if not self.process or self.process.poll() is not None:
            return
        os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
        self.process.wait()
@@ -72,6 +72,13 @@ class VSCodeEditor(WebsiteWidget):
        self.cleanup_vscode()
        return super().cleanup()

+    def close(self):
+        """
+        Close the widget.
+        """
+        self.cleanup_vscode()
+        return super().close()
+

 if __name__ == "__main__":  # pragma: no cover
    import sys
@@ -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)
@@ -7,7 +7,6 @@ In the following, we describe 4 different type of widgets thaat are available in

 ![BECFigure.png](BECFigure.png)

-(user.widgets.waveform_1d)=
 ## [1D Waveform Widget](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform)

 **Purpose:** This widget provides a straightforward visualization of 1D data. It is particularly useful for plotting positioner movements against detector readings, enabling users to observe correlations and patterns in a simple, linear format.
@@ -20,11 +19,12 @@ In the following, we describe 4 different type of widgets thaat are available in
 **Example of Use:**
 ![Waveform 1D](./w1D.gif)

-**Code example**
+**Code example 1 - adding curves**
+
 The following code snipped demonstrates how to create a 1D waveform plot using BEC Widgets within BEC. More details about BEC Widgets in BEC can be found in the getting started section within the [introduction to the command line.](user.command_line_introduction)
 ```python
 # adds a new dock, a new BECFigure and a BECWaveForm to the dock
-plt = gui.add_dock().add_widget('BECFigure').plot('samx', 'bpm4i')
+plt = gui.add_dock().add_widget('BECFigure').plot(x_name='samx', y_name='bpm4i')
 # add a second curve to the same plot 
 plt.plot(x_name='samx', y_name='bpm3i')
 plt.set_title("Gauss plots vs. samx")
@@ -39,6 +39,48 @@ dev.bpm4i.sim.select_sim_model("GaussianModel")
 dev.bpm3i.sim.select_sim_model("StepModel")
 ```

+**Code example 2 - Adding Data Processing Pipeline Curve with LMFit Models**
+
+Together with the scan curve, one can also add a second curve that fits the signal using a specified model
+from [LMFit](https://lmfit.github.io/lmfit-py/builtin_models.html). The following code snippet demonstrates how to
+create a 1D waveform curve with an attached DAP process, or how to add a DAP process to an existing curve using the BEC
+CLI. Please note that for this example, both devices were set as Gaussian signals.
+
+```python
+# Add a new dock, a new BECFigure, and a BECWaveForm to the dock with a GaussianModel DAP
+plt = gui.add_dock().add_widget('BECFigure').plot(x_name='samx', y_name='bpm4i', dap="GaussianModel")
+
+# Add a second curve to the same plot without DAP
+plt.plot(x_name='samx', y_name='bpm3a')
+
+# Add DAP to the second curve
+plt.add_dap(x_name='samx', y_name='bpm3a', dap="GaussianModel")
+
+```
+
+To get the parameters of the fit, one has to retrieve the curve objects and call the dap_params property.
+
+```python
+# Get the curve object by name from the legend
+dap_bpm4i = plt.get_curve("bpm4i-bpm4i-GaussianModel")
+dap_bpm3a = plt.get_curve("bpm3a-bpm3a-GaussianModel")
+
+# Get the parameters of the fit
+print(dap_bpm4i.dap_params)
+# Output
+{'amplitude': 197.399639720862,
+ 'center': 5.013486095404885,
+ 'sigma': 0.9820868875739888}
+
+print(dap_bpm3a.dap_params)
+# Output
+{'amplitude': 698.3072786185278,
+ 'center': 0.9702840866173836,
+ 'sigma': 1.97139754785518}
+```
+
+![Waveform 1D_DAP](./bec_figure_dap.gif)
+
 (user.widgets.scatter_2d)=
 ## [2D Scatter Plot](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform)

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"

 [project]
 name = "bec_widgets"
-version = "0.72.2"
+version = "0.77.0"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -13,30 +13,29 @@ classifiers = [
    "Topic :: Scientific/Engineering",
 ]
 dependencies = [
-    "pydantic",
-    "qtconsole",
-    "jedi",
-    "qtpy",
-    "pyqtgraph",
-    "bec_lib",
-    "bec_ipython_client", # needed for jupyter widget
-    "zmq",
-    "h5py",
-    "pyqtdarktheme",
-    "black",              # needed for bw-generate-cli
-    "isort",              # needed for bw-generate-cli
+    "bec_ipython_client~=2.16", # needed for jupyter console
+    "bec_lib~=2.16",
+    "black~=24.0",              # needed for bw-generate-cli
+    "isort~=5.13, >=5.13.2",    # needed for bw-generate-cli
+    "pydantic~=2.0",
+    "pyqtgraph~=0.13",
+    "pyqtdarktheme~=2.1",
+    "qtconsole~=5.5, >=5.5.1",  # needed for jupyter console
+    "qtpy~=2.4",
+    "pyte",                     # needed for vt100 console
 ]


 [project.optional-dependencies]
 dev = [
-    "pytest",
-    "pytest-random-order",
-    "pytest-timeout",
-    "pytest-xvfb",
-    "coverage",
-    "pytest-qt",
-    "fakeredis",
+    "coverage~=7.0",
+    "fakeredis~=2.23, >=2.23.2",
+    "pytest-bec-e2e~=2.16",
+    "pytest-qt~=4.4",
+    "pytest-random-order~=1.1",
+    "pytest-timeout~=2.2",
+    "pytest-xvfb~=3.0",
+    "pytest~=8.0",
 ]
 pyqt5 = ["PyQt5>=5.9", "PyQtWebEngine>=5.9"]
 pyqt6 = ["PyQt6>=6.7", "PyQt6-WebEngine>=6.7"]
@@ -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,8 @@ 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": {
            "name": "samx",
@@ -70,13 +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"]
@@ -124,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

@@ -163,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
@@ -189,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
@@ -198,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
@@ -215,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
@@ -1,3 +1,5 @@
+import time
+
 import numpy as np
 import pytest
 from bec_lib.endpoints import MessageEndpoints
@@ -8,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):
@@ -24,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
@@ -37,16 +39,18 @@ 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},
        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
        "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": {
            "name": "samx",
@@ -65,7 +69,8 @@ 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},
        "y": {"name": "samy", "entry": "samy", "unit": None, "modifier": None, "limits": None},
@@ -151,3 +156,55 @@ def test_rpc_motor_map(rpc_server_figure, bec_client_lib):
    np.testing.assert_equal(
        [motor_map_data["x"][-1], motor_map_data["y"][-1]], [final_pos_x, final_pos_y]
    )
+
+
+def test_dap_rpc(rpc_server_figure, bec_client_lib):
+
+    fig = BECFigure(rpc_server_figure)
+    plt = fig.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
+
+    client = bec_client_lib
+    dev = client.device_manager.devices
+    scans = client.scans
+
+    dev.bpm4i.sim.sim_select_model("GaussianModel")
+    params = dev.bpm4i.sim.sim_params
+    params.update(
+        {"noise": "uniform", "noise_multiplier": 10, "center": 5, "sigma": 1, "amplitude": 200}
+    )
+    dev.bpm4i.sim.sim_params = params
+    time.sleep(1)
+
+    res = scans.line_scan(dev.samx, 0, 8, steps=50, relative=False)
+    res.wait()
+
+    time.sleep(2)
+
+    dap_curve = plt.get_curve("bpm4i-bpm4i-GaussianModel")
+    fit_params = dap_curve.dap_params
+    print(fit_params)
+
+    assert np.isclose(fit_params["center"], 5, atol=0.5)
+
+
+def test_removing_subplots(rpc_server_figure, bec_client_lib):
+    fig = BECFigure(rpc_server_figure)
+    plt = fig.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
+    im = fig.image(monitor="eiger")
+    mm = fig.motor_map(motor_x="samx", motor_y="samy")
+
+    assert len(fig.widget_list) == 3
+
+    # removing curves
+    assert len(plt.curves) == 2
+    plt.curves[0].remove()
+    assert len(plt.curves) == 1
+    plt.remove_curve("bpm4i-bpm4i")
+    assert len(plt.curves) == 0
+
+    # removing all subplots from figure
+    plt.remove()
+    im.remove()
+    mm.remove()
+
+    assert len(fig.widget_list) == 0
@@ -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 = {
@@ -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"),
@@ -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
@@ -0,0 +1,65 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
+from unittest import mock
+
+import numpy as np
+import pytest
+from bec_lib import messages
+from qtpy.QtGui import QFontInfo
+
+from .client_mocks import mocked_client
+from .test_bec_figure import bec_figure
+
+
+@pytest.fixture
+def bec_image_show(bec_figure):
+    yield bec_figure.image("eiger")
+
+
+def test_on_image_update(bec_image_show):
+    data = np.random.rand(100, 100)
+    msg = messages.DeviceMonitorMessage(
+        device="eiger", data=data, metadata={"scan_id": "12345"}
+    ).model_dump()
+    bec_image_show.on_image_update(msg)
+    img = bec_image_show.images[0]
+    assert np.array_equal(img.get_data(), data)
+
+
+def test_autorange_on_image_update(bec_image_show):
+    # Check if autorange mode "mean" works, should be default
+    data = np.random.rand(100, 100)
+    msg = messages.DeviceMonitorMessage(
+        device="eiger", data=data, metadata={"scan_id": "12345"}
+    ).model_dump()
+    bec_image_show.on_image_update(msg)
+    img = bec_image_show.images[0]
+    assert np.array_equal(img.get_data(), data)
+    vmin = max(np.mean(data) - 2 * np.std(data), 0)
+    vmax = np.mean(data) + 2 * np.std(data)
+    assert np.isclose(img.color_bar.getLevels(), (vmin, vmax), rtol=(1e-5, 1e-5)).all()
+    # Test general update with autorange True, mode "max"
+    bec_image_show.set_autorange_mode("max")
+    bec_image_show.on_image_update(msg)
+    img = bec_image_show.images[0]
+    vmin = np.min(data)
+    vmax = np.max(data)
+    assert np.array_equal(img.get_data(), data)
+    assert np.isclose(img.color_bar.getLevels(), (vmin, vmax), rtol=(1e-5, 1e-5)).all()
+    # Change the input data, and switch to autorange False, colormap levels should stay untouched
+    data *= 100
+    msg = messages.DeviceMonitorMessage(
+        device="eiger", data=data, metadata={"scan_id": "12345"}
+    ).model_dump()
+    bec_image_show.set_autorange(False)
+    bec_image_show.on_image_update(msg)
+    img = bec_image_show.images[0]
+    assert np.array_equal(img.get_data(), data)
+    assert np.isclose(img.color_bar.getLevels(), (vmin, vmax), rtol=(1e-3, 1e-3)).all()
+    # Reactivate autorange, should now scale the new data
+    bec_image_show.set_autorange(True)
+    bec_image_show.set_autorange_mode("mean")
+    bec_image_show.on_image_update(msg)
+    img = bec_image_show.images[0]
+    vmin = max(np.mean(data) - 2 * np.std(data), 0)
+    vmax = np.mean(data) + 2 * np.std(data)
+    assert np.isclose(img.color_bar.getLevels(), (vmin, vmax), rtol=(1e-5, 1e-5)).all()
@@ -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:]
@@ -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() == ""
@@ -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"
@@ -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):
@@ -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",
@@ -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)
@@ -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):
@@ -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",
@@ -46,7 +46,8 @@ def test_start_server(qtbot, mocked_client):
        )


-def test_close_event(qtbot, vscode_widget):
+@pytest.fixture
+def patched_vscode_process(qtbot, vscode_widget):
    with mock.patch("bec_widgets.widgets.vscode.vscode.os.killpg") as mock_killpg:
        with mock.patch("bec_widgets.widgets.vscode.vscode.os.getpgid") as mock_getpgid:
            with mock.patch(
@@ -54,8 +55,24 @@ def test_close_event(qtbot, vscode_widget):
            ) as mock_close_event:
                mock_getpgid.return_value = 123
                vscode_widget.process = mock.Mock()
-                vscode_widget.process.pid = 123
-                vscode_widget.closeEvent(None)
-                mock_killpg.assert_called_once_with(123, 15)
-                vscode_widget.process.wait.assert_called_once()
-                mock_close_event.assert_called_once()
+                yield vscode_widget, mock_killpg, mock_close_event
+
+
+def test_close_event(qtbot, patched_vscode_process):
+    vscode_patched, mock_killpg, mock_close_event = patched_vscode_process
+    vscode_patched.process.pid = 123
+    vscode_patched.process.poll.return_value = None
+    vscode_patched.closeEvent(None)
+    mock_killpg.assert_called_once_with(123, 15)
+    vscode_patched.process.wait.assert_called_once()
+    mock_close_event.assert_called_once()
+
+
+def test_close_event_on_terminated_code(qtbot, patched_vscode_process):
+    vscode_patched, mock_killpg, mock_close_event = patched_vscode_process
+    vscode_patched.process.pid = 123
+    vscode_patched.process.poll.return_value = 0
+    vscode_patched.closeEvent(None)
+    mock_killpg.assert_not_called()
+    vscode_patched.process.wait.assert_not_called()
+    mock_close_event.assert_called_once()
@@ -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:
@@ -85,6 +85,7 @@ def test_create_waveform1D_by_config(bec_figure):
                "pen_style": "dash",
                "source": "scan_segment",
                "signals": {
+                    "dap": None,
                    "source": "scan_segment",
                    "x": {
                        "name": "samx",
@@ -121,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"
@@ -131,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")

@@ -140,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",
@@ -170,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:
@@ -187,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")

@@ -198,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
@@ -210,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")
@@ -228,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")

@@ -248,6 +250,7 @@ def test_change_curve_appearance_methods(bec_figure, qtbot):
    assert c1.config.pen_style == "dashdot"
    assert c1.config.source == "scan_segment"
    assert c1.config.signals.model_dump() == {
+        "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},
@@ -256,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")

@@ -277,6 +280,7 @@ def test_change_curve_appearance_args(bec_figure):
    assert c1.config.pen_style == "dashdot"
    assert c1.config.source == "scan_segment"
    assert c1.config.signals.model_dump() == {
+        "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},
@@ -285,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],
@@ -333,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],
@@ -368,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",
@@ -384,6 +388,7 @@ def test_curve_add_by_config(bec_figure):
        "pen_style": "dash",
        "source": "scan_segment",
        "signals": {
+            "dap": None,
            "source": "scan_segment",
            "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
            "y": {
@@ -407,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")

@@ -441,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")

@@ -466,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")

@@ -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)
Author	SHA1	Message	Date
wyzula_j	6c6cbba328	feat(waveform): original Ivans waveform ported from PyQt5 with plugin	2024-07-02 15:00:37 +02:00
semantic-release	c069f3e1b3	0.77.0 Automatically generated by python-semantic-release	2024-07-02 11:00:18 +00:00
wyzula_j	215d59c8bf	fix(waveform): scatter 2D brush error	2024-07-02 12:43:56 +02:00
wyzula_j	008a33a9b1	fix(figure): API cleanup	2024-07-02 12:43:38 +02:00
wyzula_j	3e787234c7	fix(figure): if/else logic corrected in subplot_factory	2024-07-02 12:43:38 +02:00
wyzula_j	1173510105	fix(image): processing of already displayed data; closes #106	2024-07-02 12:43:38 +02:00
wyzula_j	a391f3018c	feat(bec_connector): export config to yaml	2024-07-02 12:43:38 +02:00
wyzula_j	b6e1e20b7c	fix(bec_figure): full reconstruction with config from other bec figure	2024-07-02 12:43:38 +02:00
wyzula_j	572f2fb811	feat(utils): colors added convertor for rgba to hex	2024-07-02 12:43:38 +02:00
wyzula_j	2e2d422910	fix(motor_map): API changes updates current visualisation; motor_map can be initialised from config	2024-07-02 12:43:38 +02:00
wyzula_j	f0556e4411	fix(image): image add_custom_image fixed, closes #225	2024-07-02 12:43:38 +02:00
wyzula_j	4a97105e4b	fix(figure): subplot methods consolidated; added subplot factory	2024-07-02 12:43:38 +02:00
wyzula_j	797f73c39a	fix(image): image can be fully reconstructed from config	2024-07-02 12:43:38 +02:00
wyzula_j	b8f796fd3f	fix(image_item): vrange added int for pydantic model check	2024-07-02 12:43:38 +02:00
wyzula_j	78673ea11a	fix(bec_figure): waveforms can be initialised from the config; widgets are deleteLater after removal	2024-07-02 12:43:38 +02:00
guijar_m	c6a14c0768	Resolve "add VT100 console executing BEC as a widget"	2024-07-01 15:11:09 +02:00
semantic-release	70a966d8dc	0.76.1 Automatically generated by python-semantic-release	2024-06-29 12:17:07 +00:00
wakonig_k	c42511dd44	fix(plugins): fixes and tests for auto-gen plugins	2024-06-28 13:49:12 +02:00
semantic-release	db62f9e998	0.76.0 Automatically generated by python-semantic-release	2024-06-28 10:20:18 +00:00
wakonig_k	0610d2f9f0	fix: fixed qwidget inheritance for ring progress bar	2024-06-28 12:12:18 +02:00
wakonig_k	c1dd0ee190	feat(designer): added support for creating designer plugins automatically	2024-06-28 12:12:18 +02:00
wyzula_j	a45c407568	fix:parent set as first kwarg TextBox and WebsiteWidget	2024-06-27 17:47:08 +02:00
semantic-release	813f57861c	0.75.0 Automatically generated by python-semantic-release	2024-06-26 19:38:24 +00:00
wakonig_k	3faee98ec8	feat(widgets): added simple bec queue widget	2024-06-26 20:42:37 +02:00
wakonig_k	ca02132c8d	refactor(dispatcher): cleanup	2024-06-26 20:42:37 +02:00
semantic-release	cb4ef25b73	0.74.1 Automatically generated by python-semantic-release	2024-06-26 13:10:06 +00:00
wyzula_j	c8b7367815	fix(rings): rings properties updated right after setting	2024-06-26 11:46:21 +02:00
wyzula_j	a268caaa30	test(bec_figure): tests for removing widgets with rpc e2e	2024-06-26 11:41:29 +02:00
wyzula_j	6b25abff70	fix(motor_map): motor map can be removed from BECFigure with .remove()	2024-06-26 11:24:46 +02:00
wakonig_k	21c807f358	chore: sorted dependencies alphabetically	2024-06-26 10:27:46 +02:00
wakonig_k	56fdae4275	build: added missing pytest-bec-e2e dependency; closes #219	2024-06-26 10:24:25 +02:00
wakonig_k	e6a06c9f43	build: fixed dependency ranges; closes #135	2024-06-26 10:09:48 +02:00
wakonig_k	f979a63d3d	docs: fixed doc string	2024-06-26 09:46:14 +02:00
semantic-release	327bc54e22	0.74.0 Automatically generated by python-semantic-release	2024-06-25 16:44:56 +00:00
wyzula_j	a51b15da3f	docs(becfigure): docs added	2024-06-25 18:37:23 +02:00
wyzula_j	7271b422f9	test(waveform1d): dap e2e test added	2024-06-25 18:37:23 +02:00
wyzula_j	1866ba66c8	feat(waveform1d): dap LMFit model can be added to plot	2024-06-25 18:37:20 +02:00
semantic-release	6175a04a90	0.73.2 Automatically generated by python-semantic-release	2024-06-25 16:24:11 +00:00
wakonig_k	7120f3e93b	fix(vscode): only run terminate if the process is still alive	2024-06-25 18:17:02 +02:00
wakonig_k	acc13183e2	fix(rpc): trigger shutdown of server when gui is terminated	2024-06-25 16:45:39 +02:00
wyzula_j	f75fc19c5b	fix(rpc): remove of calling "close" and waiting for gui_is_alive	2024-06-25 15:22:29 +02:00
semantic-release	2650c8b8cf	0.73.1 Automatically generated by python-semantic-release	2024-06-25 10:25:13 +00:00
wakonig_k	1de3cbf65a	fix(ringprogressbar): removed hard-coded endpoint strings	2024-06-25 12:18:14 +02:00
semantic-release	4a9d0c9e44	0.73.0 Automatically generated by python-semantic-release	2024-06-25 10:05:53 +00:00
appel_c	88ecd05b95	test: add test for imageitem	2024-06-25 11:58:55 +02:00
appel_c	df812eaad5	feat: add new default scaling of image_item	2024-06-25 11:58:55 +02:00