WIP adjustments to be compatible with latest bec widgets and bec

fix(dock): REBASE docks can be created as temporary, when closed the dock will not return to original dock area
1.4.0
2026-04-16 05:30:54 +02:00 · 2024-11-11 16:41:28 +01:00 · 2024-11-11 16:31:05 +01:00 · 2024-11-11 14:19:33 +00:00 · 2024-11-11 15:09:55 +01:00 · 2024-11-11 15:09:55 +01:00
65 changed files with 3258 additions and 681 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,176 +1,209 @@
 # CHANGELOG


+## v1.4.0 (2024-11-11)
+
+### Bug Fixes
+
+- **crosshair**: Label of coordinates of TextItem displays numbers in general format
+  ([`11e5937`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/11e5937ae0f3c1413acd4e66878a692ebe4ef7d0))
+
+- **crosshair**: Label of coordinates of TextItem is updated according to the current theme of qapp
+  ([`4f31ea6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4f31ea655cf6190e141e6a2720a2d6da517a2b5b))
+
+- **crosshair**: Log is separately scaled for backend logic and for signal emit
+  ([`b2eb71a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b2eb71aae0b6a7c82158f2d150ae1e31411cfdeb))
+
+### Features
+
+- **crosshair**: Textitem to display crosshair coordinates
+  ([`035136d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/035136d5171ec5f4311d15a9aa5bad2bdbc1f6cb))
+
+### Testing
+
+- **crosshair**: Tests extended
+  ([`64df805`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/64df805a9ed92bb97e580ac3bc0a1bbd2b1cb81e))
+
+
+## v1.3.3 (2024-11-07)
+
+### Bug Fixes
+
+- **scan_control**: Devicelineedit kwargs readings changed to get name of the positioner
+  ([`5fabd4b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5fabd4bea95bafd2352102686357cc1db80813fd))
+
+### Documentation
+
+- Update outdated text in docs
+  ([`4f0693c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4f0693cae34b391d75884837e1ae6353a0501868))
+
+
+## v1.3.2 (2024-11-05)
+
+### Bug Fixes
+
+- **plot_base**: Legend text color is changed when changing dark-light theme
+  ([`2304c9f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2304c9f8497c1ab1492f3e6690bb79b0464c0df8))
+
+### Build System
+
+- Pyside6 version fixed 6.7.2
+  ([`c6e48ec`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c6e48ec1fe5aaee6a7c7a6f930f1520cd439cdb2))
+
+
+## v1.3.1 (2024-10-31)
+
+### Bug Fixes
+
+- **ophyd_kind_util**: Kind enums are imported from the bec widget util class
+  ([`940ee65`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/940ee6552c1ee8d9b4e4a74c62351f2e133ab678))
+
+
+## v1.3.0 (2024-10-30)
+
+### Bug Fixes
+
+- **colors**: Extend color map validation for matplotlib and colorcet maps (if available)
+  ([`14dd8c5`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/14dd8c5b2947c92f6643b888d71975e4e8d4ee88))
+
+### Features
+
+- **colormap_button**: Colormap button with menu to select colormap filtered by the colormap type
+  ([`b039933`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b039933405e2fbe92bd81bd0748e79e8d443a741))
+
+
+## v1.2.0 (2024-10-25)
+
+### Features
+
+- **colors**: Evenly spaced color generation + new golden ratio calculation
+  ([`40c9fea`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/40c9fea35f869ef52e05948dd1989bcd99f602e0))
+
+### Refactoring
+
+- Add bec_lib version to statusbox
+  ([`5d4b86e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5d4b86e1c6e1800051afce4f991153e370767fa6))
+
+
+## v1.1.0 (2024-10-25)
+
+### Features
+
+- Add filter i/o utility class
+  ([`0350833`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0350833f36e0a7cadce4173f9b1d1fbfdf985375))
+
+### Refactoring
+
+- Do not flush selection upon receiving config update; allow widgetIO to receive kwargs to be able
+  to use get_value to receive string instead of int for QComboBox
+  ([`91959e8`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/91959e82de8586934af3ebb5aaa0923930effc51))
+
+- Allow to set selection in DeviceInput; automatic update of selection on device config update;
+  cleanup
+  ([`5eb15b7`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5eb15b785f12e30eb8ccbc56d4ad9e759a4cf5eb))
+
+- Cleanup, added device_signal for signal inputs
+  ([`6fb2055`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6fb20552ff57978f4aeb79fd7f062f8d6b5581e7))
+
+### Testing
+
+- **scan_control**: Tests added for grid_scan to ensure scan_args signal validity
+  ([`acb7902`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/acb79020d4be546efc001ff47b6f5cdba2ee9375))
+
+
 ## v1.0.2 (2024-10-22)

 ### Bug Fixes

-* fix(scan_control): scan args signal fixed to emit list instead of hardcoded structure ([`4f5448c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4f5448cf51a204e077af162c7f0aed1f1a60e57a))
+- **scan_control**: Scan args signal fixed to emit list instead of hardcoded structure
+  ([`4f5448c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4f5448cf51a204e077af162c7f0aed1f1a60e57a))


 ## v1.0.1 (2024-10-22)

 ### Bug Fixes

-* fix(waveform): added support for live_data and data access ([`7469c89`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7469c892c8076fc09e61f173df6920c551241cec))
+- **waveform**: Added support for live_data and data access
+  ([`7469c89`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7469c892c8076fc09e61f173df6920c551241cec))


 ## v1.0.0 (2024-10-18)

-### Breaking
-
-* feat!: ability to disable scatter from waveform & compatible crosshair with down sampling ([`2ab12ed`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2ab12ed60abb995abc381d9330fdcf399796d9e5))
-
 ### Bug Fixes

-* fix(crosshair): downsample clear markers ([`f9a889f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f9a889fc6d380b9e587edcb465203122ea0bffc1))
+- **crosshair**: Downsample clear markers
+  ([`f9a889f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f9a889fc6d380b9e587edcb465203122ea0bffc1))
+
+### Features
+
+- Ability to disable scatter from waveform & compatible crosshair with down sampling
+  ([`2ab12ed`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2ab12ed60abb995abc381d9330fdcf399796d9e5))


 ## v0.119.0 (2024-10-17)

 ### Bug Fixes

-* fix: fix syntax due to change of api for simulated devices ([`19f4e40`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/19f4e407e00ee242973ca4c3f90e4e41a4d3e315))
+- Fix syntax due to change of api for simulated devices
+  ([`19f4e40`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/19f4e407e00ee242973ca4c3f90e4e41a4d3e315))

-* fix: remove wrongly scoped test ([`a23841b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a23841b2553dc7162da943715d58275c7dc39ed9))
+- Remove wrongly scoped test
+  ([`a23841b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a23841b2553dc7162da943715d58275c7dc39ed9))

-* fix: rename 'compact' property -> 'compact_view' ([`6982711`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6982711fea5fb8a73845ed7c0692e3ec53ef7871))
+- Rename 'compact' property -> 'compact_view'
+  ([`6982711`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6982711fea5fb8a73845ed7c0692e3ec53ef7871))

-* fix: Alignment 1D update, make app window a main window (in .ui file) ([`0015f0e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0015f0e2d62adc02d3ef334e1f6dbb2d0288fec6))
+- Alignment 1D update, make app window a main window (in .ui file)
+  ([`0015f0e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0015f0e2d62adc02d3ef334e1f6dbb2d0288fec6))

-* fix: set (Minimum, Fixed) size policy on Stop button ([`523cc43`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/523cc435725b10b7d59a4477a1aaa24a1f3e37a2))
+- Set (Minimum, Fixed) size policy on Stop button
+  ([`523cc43`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/523cc435725b10b7d59a4477a1aaa24a1f3e37a2))

 ### Features

-* feat: new PositionerGroup widget ([`af9655d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/af9655de0c541092437accfbaa779628a2f48ccb))
+- New PositionerGroup widget
+  ([`af9655d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/af9655de0c541092437accfbaa779628a2f48ccb))

-* feat: add 'expand_popup' property to CompactPopupWidget
+- Add 'expand_popup' property to CompactPopupWidget
+  ([`e4121a0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e4121a01cb6b8d496e630cd43bc642b994b8f310))

-This property tells if expand should show a popup (by default), or
-if the widget should expand in-place ([`e4121a0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e4121a01cb6b8d496e630cd43bc642b994b8f310))
+This property tells if expand should show a popup (by default), or if the widget should expand
+  in-place

-* feat: PositionerBox with a popup view ([`2615787`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/261578796f1de8ca9cab9b91659bc1484f7aa89d))
+- Positionerbox with a popup view
+  ([`2615787`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/261578796f1de8ca9cab9b91659bc1484f7aa89d))

-* feat: emit 'device_selected' and 'scan_axis' from scan control widget ([`0b9b1a3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0b9b1a3c89a98505079f7d4078915b7bbfaa1e23))
+- Emit 'device_selected' and 'scan_axis' from scan control widget
+  ([`0b9b1a3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0b9b1a3c89a98505079f7d4078915b7bbfaa1e23))

-* feat: new 'device_selected' signals to ScanControl, ScanGroupBox, DeviceLineEdit ([`9801d27`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9801d2769eb0ee95c94ec0c011e1dac1407142ae))
+- New 'device_selected' signals to ScanControl, ScanGroupBox, DeviceLineEdit
+  ([`9801d27`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9801d2769eb0ee95c94ec0c011e1dac1407142ae))

 ### Refactoring

-* refactor: redesign of scan selection and scan control boxes ([`a69d287`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a69d2870e2b3539739781d741b27b8599c0f4abd))
+- Redesign of scan selection and scan control boxes
+  ([`a69d287`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a69d2870e2b3539739781d741b27b8599c0f4abd))

-* refactor: move add/remove bundle to scan group box ([`e3d0a7b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e3d0a7bbf9918dc16eb7227a178c310256ce570d))
+- Move add/remove bundle to scan group box
+  ([`e3d0a7b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e3d0a7bbf9918dc16eb7227a178c310256ce570d))


 ## v0.118.0 (2024-10-13)

 ### Documentation

-* docs(sphinx-build): adjusted pyside verion ([`b236951`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b23695167ab969f754a058ffdccca2b40f00a008))
+- **sphinx-build**: Adjusted pyside verion
+  ([`b236951`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b23695167ab969f754a058ffdccca2b40f00a008))

 ### Features

-* feat(image): image widget can take data from monitor_1d endpoint ([`9ef1d1c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9ef1d1c9ac2178d9fa2e655942208f8abbdf5c1b))
+- **image**: Image widget can take data from monitor_1d endpoint
+  ([`9ef1d1c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9ef1d1c9ac2178d9fa2e655942208f8abbdf5c1b))


 ## v0.117.1 (2024-10-11)

 ### Bug Fixes

-* fix(FPS): qtimer cleanup leaking ([`3a22392`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3a2239278075de7489ad10a58c31d7d89715e221))
-
-### Unknown
-
-* feature(vscode): added support for vscode instructions ([`f5f1f6c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f5f1f6c304b890dc162e8653005233bce4ea82e4))
-
-* feature(vscode): support for controlling vscode from widgets ([`9238679`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/923867947f62db026ac0378c30ef62c883596058))
-
-
-## v0.117.0 (2024-10-11)
-
-### Features
-
-* feat(utils): FPS counter utility based on the viewBox updates, integrated to waveform and image widget ([`8c5ef26`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8c5ef268430d5243ac05fcbbdb6b76ad24ac5735))
-
-### Unknown
-
-* tests(plot_base): tests extended ([`8dc892d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8dc892df0a47ccbdd812555b7c5775a455a23ede))
-
-
-## v0.116.0 (2024-10-11)
-
-### Build System
-
-* build: fix PySide6 to 6.7.2 ([`908dbc1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/908dbc1760da5b323722207163f00850b84fb90b))
-
-### Features
-
-* feat: UI changes to have top toolbar with compact popup widgets (fix issue #360) ([`499b6b9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/499b6b9a12efd931b5728b519404c41a7e29e4d6))
-
-* feat: adapt BECQueue and BECStatusBox widgets to use CompactPopupWidget ([`94ce92f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/94ce92f5b054d25ea3bb7976c1f75e14b78b9edc))
-
-* feat: add 'CompactPopupWidget' container widget
-
-Makes it easy to write widgets which can have a compact
-representation with LED-like global state indicator,
-with the possibility to display a popup dialog with more
-complete UI ([`49268e3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/49268e3829406d70b09e4d88989812f5578e46f4))
-
-
-## v0.115.0 (2024-10-08)
-
-### Bug Fixes
-
-* fix: make Alignment1D a MainWindow as it is an application ([`c5e9ed6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c5e9ed6e422acb908e1ada32822f5d7cc256ade7))
-
-* fix: adjust bec_qthemes dependency ([`b207e45`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b207e45a67818ee061272ce00a09fe7ea31cd1ba))
-
-### Features
-
-* feat: add bec-app script to launch applications ([`8bf4842`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8bf48427884338672a8e3de3deb20439b0bfdf99))
-
-
-## v0.114.0 (2024-10-02)
-
-### Bug Fixes
-
-* fix: prevent exception when empty string updates are coming from widget ([`04cfb1e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/04cfb1edf19437d54f07b868bcf3cfc2a35fd3bc))
-
-* fix: use new 'scan_axis' signal, to set_x and select x axis on waveform
-
-Fixes #361, do not try to change x axis when not permitted ([`efa2763`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/efa276358b0f5a45cce9fa84fa5f9aafaf4284f7))
-
-### Features
-
-* feat: new 'scan_axis' signal
-
-Signal is emitted before "scan_started", to inform about scan positioner
-and (start, stop) positions. In case of multiple bundles, the signal
-is emitted multiple times. ([`f084e25`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f084e2514bc9459cccaa951b79044bc25884e738))
-
-
-## v0.113.0 (2024-10-02)
-
-### Bug Fixes
-
-* fix: add is_log checks and functionality to plot_indicator_items ([`0f9953e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0f9953e8fdcf3f9b5a09f994c69edb6b34756df9))
-
-### Features
-
-* feat: add first draft for alignment_1d GUI ([`63c24f9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/63c24f97a355edaa928b6e222909252b276bcada))
-
-* feat: add move to position button to lmfit dialog ([`281cb27`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/281cb27d8b5433e27a7ba0ca0a19e4b45b9c544f))
-
-### Refactoring
-
-* refactor: various minor improvements for the alignment gui ([`f554f3c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f554f3c1672c4fe32968a5991dc98802556a6f3b))
-
-* refactor: allow hiding of arg/kwarg boxes ([`efe90eb`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/efe90eb163e2123a5b4d0bb59f66025a569336ad))
-
-### Testing
-
-* test: add tests for scan_status_callback ([`dc0c825`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/dc0c825fd594c093a24543ff803d6c6564010e92))
-
-### Unknown
-
-* feat : Add bec_signal_proxy to handle signals with option to unblock them manually. ([`1dcfeb6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1dcfeb6cfce3c69f0c5401731d4d3f9a1981b22e))
+- **FPS**: Qtimer cleanup leaking
+  ([`3a22392`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3a2239278075de7489ad10a58c31d7d89715e221))
--- a/bec_widgets/cli/client.py
+++ b/bec_widgets/cli/client.py
@@ -16,6 +16,7 @@ class Widgets(str, enum.Enum):
    """

    AbortButton = "AbortButton"
+    BECColorMapWidget = "BECColorMapWidget"
    BECDock = "BECDock"
    BECDockArea = "BECDockArea"
    BECFigure = "BECFigure"
@@ -34,10 +35,13 @@ class Widgets(str, enum.Enum):
    PositionIndicator = "PositionIndicator"
    PositionerBox = "PositionerBox"
    PositionerControlLine = "PositionerControlLine"
+    PositionerGroup = "PositionerGroup"
    ResetButton = "ResetButton"
    ResumeButton = "ResumeButton"
    RingProgressBar = "RingProgressBar"
    ScanControl = "ScanControl"
+    SignalComboBox = "SignalComboBox"
+    SignalLineEdit = "SignalLineEdit"
    StopButton = "StopButton"
    TextBox = "TextBox"
    VSCodeEditor = "VSCodeEditor"
@@ -62,6 +66,15 @@ class AbortButton(RPCBase):
        """


+class BECColorMapWidget(RPCBase):
+    @property
+    @rpc_call
+    def colormap(self):
+        """
+        Get the current colormap name.
+        """
+
+
 class BECCurve(RPCBase):
    @rpc_call
    def remove(self):
@@ -323,6 +336,13 @@ class BECDock(RPCBase):
        Detach the dock from the parent dock area.
        """

+    @rpc_call
+    def close(self):
+        """
+        Close the dock area and cleanup.
+        Has to be implemented to overwrite pyqtgraph event accept in Container close.
+        """
+

 class BECDockArea(RPCBase, BECGuiClientMixin):
    @property
@@ -381,6 +401,7 @@ class BECDockArea(RPCBase, BECGuiClientMixin):
        name: "str" = None,
        position: "Literal['bottom', 'top', 'left', 'right', 'above', 'below']" = None,
        relative_to: "BECDock | None" = None,
+        temporary: "bool" = False,
        closable: "bool" = True,
        floating: "bool" = False,
        prefix: "str" = "dock",
@@ -397,6 +418,7 @@ class BECDockArea(RPCBase, BECGuiClientMixin):
            name(str): The name of the dock to be displayed and for further references. Has to be unique.
            position(Literal["bottom", "top", "left", "right", "above", "below"]): The position of the dock.
            relative_to(BECDock): The dock to which the new dock should be added relative to.
+            temp(bool): Whether the dock is temporary. Upon closing the dock is not returned to the parent dock area.
            closable(bool): Whether the dock is closable.
            floating(bool): Whether the dock is detached after creating.
            prefix(str): The prefix for the dock name if no name is provided.
@@ -2591,6 +2613,24 @@ class DeviceLineEdit(RPCBase):
        """


+class DeviceSignalInputBase(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.
+        """
+
+
 class LMFitDialog(RPCBase):
    @property
    @rpc_call
@@ -2670,6 +2710,16 @@ class PositionerControlLine(RPCBase):
        """


+class PositionerGroup(RPCBase):
+    @rpc_call
+    def set_positioners(self, device_names: "str"):
+        """
+        Redraw grid with positioners from device_names string
+
+        Device names must be separated by space
+        """
+
+
 class ResetButton(RPCBase):
    @property
    @rpc_call
@@ -3003,6 +3053,42 @@ class ScanControl(RPCBase):
        """


+class SignalComboBox(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.
+        """
+
+
+class SignalLineEdit(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.
+        """
+
+
 class StopButton(RPCBase):
    @property
    @rpc_call
--- a/bec_widgets/tests/init.py
+++ b/bec_widgets/tests/init.py
--- a/bec_widgets/tests/utils.py
+++ b/bec_widgets/tests/utils.py
@@ -0,0 +1,226 @@
+from unittest.mock import MagicMock
+
+from bec_lib.device import Device as BECDevice
+from bec_lib.device import Positioner as BECPositioner
+from bec_lib.device import ReadoutPriority
+from bec_lib.devicemanager import DeviceContainer
+
+
+class FakeDevice(BECDevice):
+    """Fake minimal positioner class for testing."""
+
+    def __init__(self, name, enabled=True, readout_priority=ReadoutPriority.MONITORED):
+        super().__init__(name=name)
+        self._enabled = enabled
+        self.signals = {self.name: {"value": 1.0}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self._readout_priority = readout_priority
+        self._config = {
+            "readoutPriority": "baseline",
+            "deviceClass": "ophyd.Device",
+            "deviceConfig": {},
+            "deviceTags": ["user device"],
+            "enabled": enabled,
+            "readOnly": False,
+            "name": self.name,
+        }
+
+    @property
+    def readout_priority(self):
+        return self._readout_priority
+
+    @readout_priority.setter
+    def readout_priority(self, value):
+        self._readout_priority = value
+
+    @property
+    def limits(self) -> tuple[float, float]:
+        return self._limits
+
+    @limits.setter
+    def limits(self, value: tuple[float, float]):
+        self._limits = value
+
+    def __contains__(self, item):
+        return item == self.name
+
+    @property
+    def _hints(self):
+        return [self.name]
+
+    def set_value(self, fake_value: float = 1.0) -> None:
+        """
+        Setup fake value for device readout
+        Args:
+            fake_value(float): Desired fake value
+        """
+        self.signals[self.name]["value"] = fake_value
+
+    def describe(self) -> dict:
+        """
+        Get the description of the device
+        Returns:
+            dict: Description of the device
+        """
+        return self.description
+
+
+class FakePositioner(BECPositioner):
+
+    def __init__(
+        self,
+        name,
+        enabled=True,
+        limits=None,
+        read_value=1.0,
+        readout_priority=ReadoutPriority.MONITORED,
+    ):
+        super().__init__(name=name)
+        # self.limits = limits if limits is not None else [0.0, 0.0]
+        self.read_value = read_value
+        self.setpoint_value = read_value
+        self.motor_is_moving_value = 0
+        self._enabled = enabled
+        self._limits = limits
+        self._readout_priority = readout_priority
+        self.signals = {self.name: {"value": 1.0}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self._config = {
+            "readoutPriority": "baseline",
+            "deviceClass": "ophyd_devices.SimPositioner",
+            "deviceConfig": {"delay": 1, "tolerance": 0.01, "update_frequency": 400},
+            "deviceTags": ["user motors"],
+            "enabled": enabled,
+            "readOnly": False,
+            "name": self.name,
+        }
+        self._info = {
+            "signals": {
+                "readback": {"kind_str": "5"},  # hinted
+                "setpoint": {"kind_str": "1"},  # normal
+                "velocity": {"kind_str": "2"},  # config
+            }
+        }
+        self.signals = {
+            self.name: {"value": self.read_value},
+            f"{self.name}_setpoint": {"value": self.setpoint_value},
+            f"{self.name}_motor_is_moving": {"value": self.motor_is_moving_value},
+        }
+
+    @property
+    def readout_priority(self):
+        return self._readout_priority
+
+    @readout_priority.setter
+    def readout_priority(self, value):
+        self._readout_priority = value
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value: bool):
+        self._enabled = value
+
+    @property
+    def limits(self) -> tuple[float, float]:
+        return self._limits
+
+    @limits.setter
+    def limits(self, value: tuple[float, float]):
+        self._limits = value
+
+    def __contains__(self, item):
+        return item == self.name
+
+    @property
+    def _hints(self):
+        return [self.name]
+
+    def set_value(self, fake_value: float = 1.0) -> None:
+        """
+        Setup fake value for device readout
+        Args:
+            fake_value(float): Desired fake value
+        """
+        self.read_value = fake_value
+
+    def describe(self) -> dict:
+        """
+        Get the description of the device
+        Returns:
+            dict: Description of the device
+        """
+        return self.description
+
+    @property
+    def precision(self):
+        return 3
+
+    def set_read_value(self, value):
+        self.read_value = value
+
+    def read(self):
+        return self.signals
+
+    def set_limits(self, limits):
+        self.limits = limits
+
+    def move(self, value, relative=False):
+        """Simulates moving the device to a new position."""
+        if relative:
+            self.read_value += value
+        else:
+            self.read_value = value
+        # Respect the limits
+        self.read_value = max(min(self.read_value, self.limits[1]), self.limits[0])
+
+    @property
+    def readback(self):
+        return MagicMock(get=MagicMock(return_value=self.read_value))
+
+
+class Positioner(FakePositioner):
+    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
+
+    def __init__(self, name="test", limits=None, read_value=1.0):
+        super().__init__(name, limits, read_value)
+
+
+class Device(FakeDevice):
+    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
+
+    def __init__(self, name, enabled=True):
+        super().__init__(name, enabled)
+
+
+class DMMock:
+    def __init__(self):
+        self.devices = DeviceContainer()
+        self.enabled_devices = [device for device in self.devices if device.enabled]
+
+    def add_devives(self, devices: list):
+        for device in devices:
+            self.devices[device.name] = device
+
+
+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"),
+    FakeDevice("gauss_adc1"),
+    FakeDevice("gauss_adc2"),
+    FakeDevice("gauss_adc3"),
+    FakeDevice("bpm4i"),
+    FakeDevice("bpm3a"),
+    FakeDevice("bpm3i"),
+    FakeDevice("eiger", readout_priority=ReadoutPriority.ASYNC),
+    FakeDevice("waveform1d"),
+    FakeDevice("async_device", readout_priority=ReadoutPriority.ASYNC),
+    Positioner("test", limits=[-10, 10], read_value=2.0),
+    Device("test_device"),
+]
--- a/bec_widgets/utils/colors.py
+++ b/bec_widgets/utils/colors.py
@@ -107,9 +107,98 @@ class Colors:
            angles.append(angle)
        return angles

+    @staticmethod
+    def set_theme_offset(theme: Literal["light", "dark"] | None = None, offset=0.2) -> tuple:
+        """
+        Set the theme offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
+
+        Args:
+            theme(str): The theme to be applied.
+            offset(float): Offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
+
+        Returns:
+            tuple: Tuple of min_pos and max_pos.
+
+        Raises:
+            ValueError: If theme_offset is not between 0 and 1.
+        """
+
+        if offset < 0 or offset > 1:
+            raise ValueError("theme_offset must be between 0 and 1")
+
+        if theme is None:
+            app = QApplication.instance()
+            if hasattr(app, "theme"):
+                theme = app.theme.theme
+
+        if theme == "light":
+            min_pos = 0.0
+            max_pos = 1 - offset
+        else:
+            min_pos = 0.0 + offset
+            max_pos = 1.0
+
+        return min_pos, max_pos
+
+    @staticmethod
+    def evenly_spaced_colors(
+        colormap: str,
+        num: int,
+        format: Literal["QColor", "HEX", "RGB"] = "QColor",
+        theme_offset=0.2,
+        theme: Literal["light", "dark"] | None = None,
+    ) -> list:
+        """
+        Extract `num` colors from the specified colormap, evenly spaced along its range,
+        and return them in the specified format.
+
+        Args:
+            colormap (str): Name of the colormap.
+            num (int): Number of requested colors.
+            format (Literal["QColor","HEX","RGB"]): The format of the returned colors ('RGB', 'HEX', 'QColor').
+            theme_offset (float): Has to be between 0-1. Offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
+            theme (Literal['light', 'dark'] | None): The theme to be applied. Overrides the QApplication theme if specified.
+
+        Returns:
+            list: List of colors in the specified format.
+
+        Raises:
+            ValueError: If theme_offset is not between 0 and 1.
+        """
+        if theme_offset < 0 or theme_offset > 1:
+            raise ValueError("theme_offset must be between 0 and 1")
+
+        cmap = pg.colormap.get(colormap)
+        min_pos, max_pos = Colors.set_theme_offset(theme, theme_offset)
+
+        # Generate positions that are evenly spaced within the acceptable range
+        if num == 1:
+            positions = np.array([(min_pos + max_pos) / 2])
+        else:
+            positions = np.linspace(min_pos, max_pos, num)
+
+        # Sample colors from the colormap at the calculated positions
+        colors = cmap.map(positions, mode="float")
+        color_list = []
+
+        for color in colors:
+            if format.upper() == "HEX":
+                color_list.append(QColor.fromRgbF(*color).name())
+            elif format.upper() == "RGB":
+                color_list.append(tuple((np.array(color) * 255).astype(int)))
+            elif format.upper() == "QCOLOR":
+                color_list.append(QColor.fromRgbF(*color))
+            else:
+                raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
+        return color_list
+
    @staticmethod
    def golden_angle_color(
-        colormap: str, num: int, format: Literal["QColor", "HEX", "RGB"] = "QColor"
+        colormap: str,
+        num: int,
+        format: Literal["QColor", "HEX", "RGB"] = "QColor",
+        theme_offset=0.2,
+        theme: Literal["dark", "light"] | None = None,
    ) -> list:
        """
        Extract num colors from the specified colormap following golden angle distribution and return them in the specified format.
@@ -118,45 +207,39 @@ class Colors:
            colormap (str): Name of the colormap.
            num (int): Number of requested colors.
            format (Literal["QColor","HEX","RGB"]): The format of the returned colors ('RGB', 'HEX', 'QColor').
+            theme_offset (float): Has to be between 0-1. Offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.

        Returns:
            list: List of colors in the specified format.

        Raises:
-            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
+            ValueError: If theme_offset is not between 0 and 1.
        """
-        cmap = pg.colormap.get(colormap)
-        cmap_colors = cmap.getColors(mode="float")
-        if num > len(cmap_colors):
-            raise ValueError(
-                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
-            )
-        angles = Colors.golden_ratio(len(cmap_colors))
-        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
-        colors = []
-        ii = 0
-        while len(colors) < num:
-            color_index = int(color_selection[ii])
-            color = cmap_colors[color_index]
-            app = QApplication.instance()
-            if hasattr(app, "theme") and app.theme.theme == "light":
-                background = 255
-            else:
-                background = 0
-            if np.abs(np.mean(color[:3] * 255) - background) < 50:
-                ii += 1
-                continue

+        cmap = pg.colormap.get(colormap)
+        phi = (1 + np.sqrt(5)) / 2  # Golden ratio
+        golden_angle_conjugate = 1 - (1 / phi)  # Approximately 0.38196601125
+
+        min_pos, max_pos = Colors.set_theme_offset(theme, theme_offset)
+
+        # Generate positions within the acceptable range
+        positions = np.mod(np.arange(num) * golden_angle_conjugate, 1)
+        positions = min_pos + positions * (max_pos - min_pos)
+
+        # Sample colors from the colormap at the calculated positions
+        colors = cmap.map(positions, mode="float")
+        color_list = []
+
+        for color in colors:
            if format.upper() == "HEX":
-                colors.append(QColor.fromRgbF(*color).name())
+                color_list.append(QColor.fromRgbF(*color).name())
            elif format.upper() == "RGB":
-                colors.append(tuple((np.array(color) * 255).astype(int)))
+                color_list.append(tuple((np.array(color) * 255).astype(int)))
            elif format.upper() == "QCOLOR":
-                colors.append(QColor.fromRgbF(*color))
+                color_list.append(QColor.fromRgbF(*color))
            else:
                raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
-            ii += 1
-        return colors
+        return color_list

    @staticmethod
    def hex_to_rgba(hex_color: str, alpha=255) -> tuple:
@@ -385,7 +468,7 @@ class Colors:
            return color

    @staticmethod
-    def validate_color_map(color_map: str) -> str:
+    def validate_color_map(color_map: str, return_error: bool = True) -> str | bool:
        """
        Validate the colormap input if it is supported by pyqtgraph. Can be used in any pydantic model as a field validator. If validation fails it prints all available colormaps from pyqtgraph instance.

@@ -393,13 +476,24 @@ class Colors:
            color_map(str): The colormap to be validated.

        Returns:
-            str: The validated colormap.
+            str: The validated colormap, if colormap is valid.
+            bool: False, if colormap is invalid.
+
+        Raises:
+            PydanticCustomError: If colormap is invalid.
        """
-        available_colormaps = pg.colormap.listMaps()
+        available_pg_maps = pg.colormap.listMaps()
+        available_mpl_maps = pg.colormap.listMaps("matplotlib")
+        available_mpl_colorcet = pg.colormap.listMaps("colorcet")
+
+        available_colormaps = available_pg_maps + available_mpl_maps + available_mpl_colorcet
        if color_map not in available_colormaps:
-            raise PydanticCustomError(
-                "unsupported colormap",
-                f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose on the following: {available_colormaps}.",
-                {"wrong_value": color_map},
-            )
+            if return_error:
+                raise PydanticCustomError(
+                    "unsupported colormap",
+                    f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose on the following: {available_colormaps}.",
+                    {"wrong_value": color_map},
+                )
+            else:
+                return False
        return color_map
--- a/bec_widgets/utils/crosshair.py
+++ b/bec_widgets/utils/crosshair.py
@@ -2,10 +2,8 @@ from collections import defaultdict

 import numpy as np
 import pyqtgraph as pg
-
-# from qtpy.QtCore import QObject, pyqtSignal
-from qtpy.QtCore import QObject, Qt
-from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import QObject, Qt, Signal, Slot
+from qtpy.QtWidgets import QApplication


 class NonDownsamplingScatterPlotItem(pg.ScatterPlotItem):
@@ -17,14 +15,18 @@ class NonDownsamplingScatterPlotItem(pg.ScatterPlotItem):


 class Crosshair(QObject):
-    positionChanged = pyqtSignal(tuple)
-    positionClicked = pyqtSignal(tuple)
+    # QT Position of mouse cursor
+    positionChanged = Signal(tuple)
+    positionClicked = Signal(tuple)
+    # Plain crosshair position signals mapped to real coordinates
+    crosshairChanged = Signal(tuple)
+    crosshairClicked = Signal(tuple)
    # Signal for 1D plot
-    coordinatesChanged1D = pyqtSignal(tuple)
-    coordinatesClicked1D = pyqtSignal(tuple)
+    coordinatesChanged1D = Signal(tuple)
+    coordinatesClicked1D = Signal(tuple)
    # Signal for 2D plot
-    coordinatesChanged2D = pyqtSignal(tuple)
-    coordinatesClicked2D = pyqtSignal(tuple)
+    coordinatesChanged2D = Signal(tuple)
+    coordinatesClicked2D = Signal(tuple)

    def __init__(self, plot_item: pg.PlotItem, precision: int = 3, parent=None):
        """
@@ -47,11 +49,21 @@ class Crosshair(QObject):
        self.h_line.skip_auto_range = True
        self.plot_item.addItem(self.v_line, ignoreBounds=True)
        self.plot_item.addItem(self.h_line, ignoreBounds=True)
+
+        # Add TextItem to display coordinates
+        self.coord_label = pg.TextItem("", anchor=(1, 1), fill=(0, 0, 0, 100))
+        self.coord_label.setVisible(False)  # Hide initially
+        self.coord_label.skip_auto_range = True
+        self.plot_item.addItem(self.coord_label)
+
+        # Signals to connect
        self.proxy = pg.SignalProxy(
            self.plot_item.scene().sigMouseMoved, rateLimit=60, slot=self.mouse_moved
        )
+        self.positionChanged.connect(self.update_coord_label)
        self.plot_item.scene().sigMouseClicked.connect(self.mouse_clicked)

+        # Connect signals from pyqtgraph right click menu
        self.plot_item.ctrl.derivativeCheck.checkStateChanged.connect(self.check_derivatives)
        self.plot_item.ctrl.logXCheck.checkStateChanged.connect(self.check_log)
        self.plot_item.ctrl.logYCheck.checkStateChanged.connect(self.check_log)
@@ -62,6 +74,44 @@ class Crosshair(QObject):
        self.marker_clicked_1d = {}
        self.marker_2d = None
        self.update_markers()
+        self.check_log()
+        self.check_derivatives()
+
+        self._connect_to_theme_change()
+
+    def _connect_to_theme_change(self):
+        """Connect to the theme change signal."""
+        qapp = QApplication.instance()
+        if hasattr(qapp, "theme_signal"):
+            qapp.theme_signal.theme_updated.connect(self._update_theme)
+            self._update_theme()
+
+    @Slot(str)
+    def _update_theme(self, theme: str | None = None):
+        """Update the theme."""
+        if theme is None:
+            qapp = QApplication.instance()
+            if hasattr(qapp, "theme"):
+                theme = qapp.theme.theme
+            else:
+                theme = "dark"
+        self.apply_theme(theme)
+
+    def apply_theme(self, theme: str):
+        """Apply the theme to the plot."""
+        if theme == "dark":
+            text_color = "w"
+            label_bg_color = (50, 50, 50, 150)
+        elif theme == "light":
+            text_color = "k"
+            label_bg_color = (240, 240, 240, 150)
+        else:
+            text_color = "w"
+            label_bg_color = (50, 50, 50, 150)
+
+        self.coord_label.setColor(text_color)
+        self.coord_label.fill = pg.mkBrush(label_bg_color)
+        self.coord_label.border = pg.mkPen(None)

    def update_markers(self):
        """Update the markers for the crosshair, creating new ones if necessary."""
@@ -151,21 +201,34 @@ class Crosshair(QObject):

        return None, None

-    def closest_x_y_value(self, input_value: float, list_x: list, list_y: list) -> tuple:
+    def closest_x_y_value(self, input_x: float, list_x: list, list_y: list) -> tuple:
        """
        Find the closest x and y value to the input value.

        Args:
-            input_value (float): Input value
+            input_x (float): Input value
            list_x (list): List of x values
            list_y (list): List of y values

        Returns:
            tuple: Closest x and y value
        """
-        arr = np.asarray(list_x)
-        i = (np.abs(arr - input_value)).argmin()
-        return list_x[i], list_y[i]
+        # Convert lists to NumPy arrays
+        arr_x = np.asarray(list_x)
+
+        # Get the indices where x is not NaN
+        valid_indices = ~np.isnan(arr_x)
+
+        # Filter x array to exclude NaN values
+        filtered_x = arr_x[valid_indices]
+
+        # Find the index of the closest value in the filtered x array
+        closest_index = np.abs(filtered_x - input_x).argmin()
+
+        # Map back to the original index in the list_x and list_y arrays
+        original_index = np.where(valid_indices)[0][closest_index]
+
+        return list_x[original_index], list_y[original_index]

    def mouse_moved(self, event):
        """Handles the mouse moved event, updating the crosshair position and emitting signals.
@@ -175,17 +238,15 @@ class Crosshair(QObject):
        """
        pos = event[0]
        self.update_markers()
-        self.positionChanged.emit((pos.x(), pos.y()))
        if self.plot_item.vb.sceneBoundingRect().contains(pos):
            mouse_point = self.plot_item.vb.mapSceneToView(pos)
-            self.v_line.setPos(mouse_point.x())
-            self.h_line.setPos(mouse_point.y())
-
            x, y = mouse_point.x(), mouse_point.y()
-            if self.is_log_x:
-                x = 10**x
-            if self.is_log_y:
-                y = 10**y
+            self.v_line.setPos(x)
+            self.h_line.setPos(y)
+            scaled_x, scaled_y = self.scale_emitted_coordinates(mouse_point.x(), mouse_point.y())
+            self.crosshairChanged.emit((scaled_x, scaled_y))
+            self.positionChanged.emit((x, y))
+
            x_snap_values, y_snap_values = self.snap_to_data(x, y)
            if x_snap_values is None or y_snap_values is None:
                return
@@ -202,7 +263,12 @@ class Crosshair(QObject):
                    if x is None or y is None:
                        continue
                    self.marker_moved_1d[name].setData([x], [y])
-                    coordinate_to_emit = (name, round(x, self.precision), round(y, self.precision))
+                    x_snapped_scaled, y_snapped_scaled = self.scale_emitted_coordinates(x, y)
+                    coordinate_to_emit = (
+                        name,
+                        round(x_snapped_scaled, self.precision),
+                        round(y_snapped_scaled, self.precision),
+                    )
                    self.coordinatesChanged1D.emit(coordinate_to_emit)
                elif isinstance(item, pg.ImageItem):
                    name = item.config.monitor
@@ -229,12 +295,10 @@ class Crosshair(QObject):
        if self.plot_item.vb.sceneBoundingRect().contains(event._scenePos):
            mouse_point = self.plot_item.vb.mapSceneToView(event._scenePos)
            x, y = mouse_point.x(), mouse_point.y()
+            scaled_x, scaled_y = self.scale_emitted_coordinates(mouse_point.x(), mouse_point.y())
+            self.crosshairClicked.emit((scaled_x, scaled_y))
            self.positionClicked.emit((x, y))

-            if self.is_log_x:
-                x = 10**x
-            if self.is_log_y:
-                y = 10**y
            x_snap_values, y_snap_values = self.snap_to_data(x, y)

            if x_snap_values is None or y_snap_values is None:
@@ -252,7 +316,12 @@ class Crosshair(QObject):
                    if x is None or y is None:
                        continue
                    self.marker_clicked_1d[name].setData([x], [y])
-                    coordinate_to_emit = (name, round(x, self.precision), round(y, self.precision))
+                    x_snapped_scaled, y_snapped_scaled = self.scale_emitted_coordinates(x, y)
+                    coordinate_to_emit = (
+                        name,
+                        round(x_snapped_scaled, self.precision),
+                        round(y_snapped_scaled, self.precision),
+                    )
                    self.coordinatesClicked1D.emit(coordinate_to_emit)
                elif isinstance(item, pg.ImageItem):
                    name = item.config.monitor
@@ -272,10 +341,40 @@ class Crosshair(QObject):
        for marker in self.marker_clicked_1d.values():
            marker.clear()

+    def scale_emitted_coordinates(self, x, y):
+        """Scales the emitted coordinates if the axes are in log scale.
+
+        Args:
+            x (float): The x-coordinate
+            y (float): The y-coordinate
+
+        Returns:
+            tuple: The scaled x and y coordinates
+        """
+        if self.is_log_x:
+            x = 10**x
+        if self.is_log_y:
+            y = 10**y
+        return x, y
+
+    def update_coord_label(self, pos: tuple):
+        """Updates the coordinate label based on the crosshair position and axis scales.
+
+        Args:
+            pos (tuple): The (x, y) position of the crosshair.
+        """
+        x, y = pos
+        x_scaled, y_scaled = self.scale_emitted_coordinates(x, y)
+
+        # # Update coordinate label
+        self.coord_label.setText(f"({x_scaled:.{self.precision}g}, {y_scaled:.{self.precision}g})")
+        self.coord_label.setPos(x, y)
+        self.coord_label.setVisible(True)
+
    def check_log(self):
        """Checks if the x or y axis is in log scale and updates the internal state accordingly."""
-        self.is_log_x = self.plot_item.ctrl.logXCheck.isChecked()
-        self.is_log_y = self.plot_item.ctrl.logYCheck.isChecked()
+        self.is_log_x = self.plot_item.axes["bottom"]["item"].logMode
+        self.is_log_y = self.plot_item.axes["left"]["item"].logMode
        self.clear_markers()

    def check_derivatives(self):
@@ -284,6 +383,8 @@ class Crosshair(QObject):
        self.clear_markers()

    def cleanup(self):
-        self.v_line.deleteLater()
-        self.h_line.deleteLater()
+        self.plot_item.removeItem(self.v_line)
+        self.plot_item.removeItem(self.h_line)
+        self.plot_item.removeItem(self.coord_label)
+
        self.clear_markers()
--- a/bec_widgets/utils/filter_io.py
+++ b/bec_widgets/utils/filter_io.py
@@ -0,0 +1,156 @@
+"""Module for handling filter I/O operations in BEC Widgets for input fields.
+These operations include filtering device/signal names and/or device types.
+"""
+
+from abc import ABC, abstractmethod
+
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QStringListModel
+from qtpy.QtWidgets import QComboBox, QCompleter, QLineEdit
+
+logger = bec_logger.logger
+
+
+class WidgetFilterHandler(ABC):
+    """Abstract base class for widget filter handlers"""
+
+    @abstractmethod
+    def set_selection(self, widget, selection: list) -> None:
+        """Set the filtered_selection for the widget
+
+        Args:
+            selection (list): Filtered selection of items
+        """
+
+    @abstractmethod
+    def check_input(self, widget, text: str) -> bool:
+        """Check if the input text is in the filtered selection
+
+        Args:
+            widget: Widget instance
+            text (str): Input text
+
+        Returns:
+            bool: True if the input text is in the filtered selection
+        """
+
+
+class LineEditFilterHandler(WidgetFilterHandler):
+    """Handler for QLineEdit widget"""
+
+    def set_selection(self, widget: QLineEdit, selection: list) -> None:
+        """Set the selection for the widget to the completer model
+
+        Args:
+            widget (QLineEdit): The QLineEdit widget
+            selection (list): Filtered selection of items
+        """
+        if not isinstance(widget.completer, QCompleter):
+            completer = QCompleter(widget)
+            widget.setCompleter(completer)
+        widget.completer.setModel(QStringListModel(selection, widget))
+
+    def check_input(self, widget: QLineEdit, text: str) -> bool:
+        """Check if the input text is in the filtered selection
+
+        Args:
+            widget (QLineEdit): The QLineEdit widget
+            text (str): Input text
+
+        Returns:
+            bool: True if the input text is in the filtered selection
+        """
+        model = widget.completer.model()
+        model_data = [model.data(model.index(i)) for i in range(model.rowCount())]
+        return text in model_data
+
+
+class ComboBoxFilterHandler(WidgetFilterHandler):
+    """Handler for QComboBox widget"""
+
+    def set_selection(self, widget: QComboBox, selection: list) -> None:
+        """Set the selection for the widget to the completer model
+
+        Args:
+            widget (QComboBox): The QComboBox widget
+            selection (list): Filtered selection of items
+        """
+        widget.clear()
+        widget.addItems(selection)
+
+    def check_input(self, widget: QComboBox, text: str) -> bool:
+        """Check if the input text is in the filtered selection
+
+        Args:
+            widget (QComboBox): The QComboBox widget
+            text (str): Input text
+
+        Returns:
+            bool: True if the input text is in the filtered selection
+        """
+        return text in [widget.itemText(i) for i in range(widget.count())]
+
+
+class FilterIO:
+    """Public interface to set filters for input widgets.
+    It supports the list of widgets stored in class attribute _handlers.
+    """
+
+    _handlers = {QLineEdit: LineEditFilterHandler, QComboBox: ComboBoxFilterHandler}
+
+    @staticmethod
+    def set_selection(widget, selection: list, ignore_errors=True):
+        """
+        Retrieve value from the widget instance.
+
+        Args:
+            widget: Widget instance.
+            selection(list): List of filtered selection items.
+            ignore_errors(bool, optional): Whether to ignore if no handler is found.
+        """
+        handler_class = FilterIO._find_handler(widget)
+        if handler_class:
+            return handler_class().set_selection(widget=widget, selection=selection)
+        if not ignore_errors:
+            raise ValueError(
+                f"No matching handler for widget type: {type(widget)} in handler list {FilterIO._handlers}"
+            )
+        return None
+
+    @staticmethod
+    def check_input(widget, text: str, ignore_errors=True):
+        """
+        Check if the input text is in the filtered selection.
+
+        Args:
+            widget: Widget instance.
+            text(str): Input text.
+            ignore_errors(bool, optional): Whether to ignore if no handler is found.
+
+        Returns:
+            bool: True if the input text is in the filtered selection.
+        """
+        handler_class = FilterIO._find_handler(widget)
+        if handler_class:
+            return handler_class().check_input(widget=widget, text=text)
+        if not ignore_errors:
+            raise ValueError(
+                f"No matching handler for widget type: {type(widget)} in handler list {FilterIO._handlers}"
+            )
+        return None
+
+    @staticmethod
+    def _find_handler(widget):
+        """
+        Find the appropriate handler for the widget by checking its base classes.
+
+        Args:
+            widget: Widget instance.
+
+        Returns:
+            handler_class: The handler class if found, otherwise None.
+        """
+        for base in type(widget).__mro__:
+            if base in FilterIO._handlers:
+                return FilterIO._handlers[base]
+        return None
--- a/bec_widgets/utils/ophyd_kind_util.py
+++ b/bec_widgets/utils/ophyd_kind_util.py
@@ -0,0 +1,26 @@
+from enum import IntFlag
+
+try:
+
+    from enum import KEEP
+
+    class IFBase(IntFlag, boundary=KEEP): ...
+
+except ImportError:
+
+    IFBase = IntFlag
+
+
+class Kind(IFBase):
+    """
+    This is used in the .kind attribute of all OphydObj (Signals, Devices).
+
+    A Device examines its components' .kind atttribute to decide whether to
+    traverse it in read(), read_configuration(), or neither. Additionally, if
+    decides whether to include its name in `hints['fields']`.
+    """
+
+    omitted = 0b000
+    normal = 0b001
+    config = 0b010
+    hinted = 0b101  # Notice that bool(hinted & normal) is True.
--- a/bec_widgets/utils/widget_io.py
+++ b/bec_widgets/utils/widget_io.py
@@ -1,5 +1,6 @@
 # pylint: disable=no-name-in-module
 from abc import ABC, abstractmethod
+from typing import Literal

 from qtpy.QtWidgets import (
    QApplication,
@@ -20,7 +21,7 @@ class WidgetHandler(ABC):
    """Abstract base class for all widget handlers."""

    @abstractmethod
-    def get_value(self, widget: QWidget):
+    def get_value(self, widget: QWidget, **kwargs):
        """Retrieve value from the widget instance."""

    @abstractmethod
@@ -31,7 +32,7 @@ class WidgetHandler(ABC):
 class LineEditHandler(WidgetHandler):
    """Handler for QLineEdit widgets."""

-    def get_value(self, widget: QLineEdit) -> str:
+    def get_value(self, widget: QLineEdit, **kwargs) -> str:
        return widget.text()

    def set_value(self, widget: QLineEdit, value: str) -> None:
@@ -41,7 +42,9 @@ class LineEditHandler(WidgetHandler):
 class ComboBoxHandler(WidgetHandler):
    """Handler for QComboBox widgets."""

-    def get_value(self, widget: QComboBox) -> int:
+    def get_value(self, widget: QComboBox, as_string: bool = False, **kwargs) -> int | str:
+        if as_string is True:
+            return widget.currentText()
        return widget.currentIndex()

    def set_value(self, widget: QComboBox, value: int | str) -> None:
@@ -54,7 +57,7 @@ class ComboBoxHandler(WidgetHandler):
 class TableWidgetHandler(WidgetHandler):
    """Handler for QTableWidget widgets."""

-    def get_value(self, widget: QTableWidget) -> list:
+    def get_value(self, widget: QTableWidget, **kwargs) -> list:
        return [
            [
                widget.item(row, col).text() if widget.item(row, col) else ""
@@ -73,7 +76,7 @@ class TableWidgetHandler(WidgetHandler):
 class SpinBoxHandler(WidgetHandler):
    """Handler for QSpinBox and QDoubleSpinBox widgets."""

-    def get_value(self, widget):
+    def get_value(self, widget, **kwargs):
        return widget.value()

    def set_value(self, widget, value):
@@ -83,7 +86,7 @@ class SpinBoxHandler(WidgetHandler):
 class CheckBoxHandler(WidgetHandler):
    """Handler for QCheckBox widgets."""

-    def get_value(self, widget):
+    def get_value(self, widget, **kwargs):
        return widget.isChecked()

    def set_value(self, widget, value):
@@ -93,7 +96,7 @@ class CheckBoxHandler(WidgetHandler):
 class LabelHandler(WidgetHandler):
    """Handler for QLabel widgets."""

-    def get_value(self, widget):
+    def get_value(self, widget, **kwargs):
        return widget.text()

    def set_value(self, widget, value):
@@ -114,7 +117,7 @@ class WidgetIO:
    }

    @staticmethod
-    def get_value(widget, ignore_errors=False):
+    def get_value(widget, ignore_errors=False, **kwargs):
        """
        Retrieve value from the widget instance.

@@ -124,7 +127,7 @@ class WidgetIO:
        """
        handler_class = WidgetIO._find_handler(widget)
        if handler_class:
-            return handler_class().get_value(widget)  # Instantiate the handler
+            return handler_class().get_value(widget, **kwargs)  # Instantiate the handler
        if not ignore_errors:
            raise ValueError(f"No handler for widget type: {type(widget)}")
        return None
--- a/bec_widgets/widgets/base_classes/device_input_base.py
+++ b/bec_widgets/widgets/base_classes/device_input_base.py
@@ -1,38 +1,133 @@
 from __future__ import annotations

+import enum
+
+from bec_lib.device import ComputedSignal, Device, Positioner, ReadoutPriority
+from bec_lib.device import Signal as BECSignal
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import Property, Signal, Slot
+
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.filter_io import FilterIO
+from bec_widgets.utils.widget_io import WidgetIO
+
+logger = bec_logger.logger
+
+
+class BECDeviceFilter(enum.Enum):
+    """Filter for the device classes."""
+
+    DEVICE = "Device"
+    POSITIONER = "Positioner"
+    SIGNAL = "Signal"
+    COMPUTED_SIGNAL = "ComputedSignal"


 class DeviceInputConfig(ConnectionConfig):
-    device_filter: str | list[str] | None = None
+    device_filter: list[BECDeviceFilter] = []
+    readout_filter: list[ReadoutPriority] = []
+    devices: list[str] = []
    default: str | None = None
    arg_name: str | None = None
+    apply_filter: bool = True


 class DeviceInputBase(BECWidget):
    """
-    Mixin class for device input widgets. This class provides methods to get the device list and device object based
-    on the current text of the widget.
+    Mixin base class for device input widgets.
+    It allows to filter devices from BEC based on
+    device class and readout priority.
    """

-    def __init__(self, client=None, config=None, gui_id=None):
+    _device_handler = {
+        BECDeviceFilter.DEVICE: Device,
+        BECDeviceFilter.POSITIONER: Positioner,
+        BECDeviceFilter.SIGNAL: BECSignal,
+        BECDeviceFilter.COMPUTED_SIGNAL: ComputedSignal,
+    }
+
+    _filter_handler = {
+        BECDeviceFilter.DEVICE: "filter_to_device",
+        BECDeviceFilter.POSITIONER: "filter_to_positioner",
+        BECDeviceFilter.SIGNAL: "filter_to_signal",
+        BECDeviceFilter.COMPUTED_SIGNAL: "filter_to_computed_signal",
+        ReadoutPriority.MONITORED: "readout_monitored",
+        ReadoutPriority.BASELINE: "readout_baseline",
+        ReadoutPriority.ASYNC: "readout_async",
+        ReadoutPriority.CONTINUOUS: "readout_continuous",
+        ReadoutPriority.ON_REQUEST: "readout_on_request",
+    }
+
+    def __init__(self, client=None, config=None, gui_id: str = None):
+
        if config is None:
            config = DeviceInputConfig(widget_class=self.__class__.__name__)
        else:
            if isinstance(config, dict):
                config = DeviceInputConfig(**config)
            self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id)
-
+        super().__init__(client=client, config=config, gui_id=gui_id, theme_update=True)
        self.get_bec_shortcuts()
-        self._device_filter = None
+        self._device_filter = []
+        self._readout_filter = []
        self._devices = []

-    @property
+    ### QtSlots ###
+
+    @Slot(str)
+    def set_device(self, device: str):
+        """
+        Set the device.
+
+        Args:
+            device (str): Default name.
+        """
+        if self.validate_device(device) is True:
+            WidgetIO.set_value(widget=self, value=device)
+            self.config.default = device
+        else:
+            logger.warning(f"Device {device} is not in the filtered selection.")
+
+    @Slot()
+    def update_devices_from_filters(self):
+        """Update the devices based on the current filter selection
+        in self.device_filter and self.readout_filter. If apply_filter is False,
+        it will not apply the filters, store the filter settings and return.
+        """
+        current_device = WidgetIO.get_value(widget=self, as_string=True)
+        self.config.device_filter = self.device_filter
+        self.config.readout_filter = self.readout_filter
+        if self.apply_filter is False:
+            return
+        all_dev = self.dev.enabled_devices
+        # Filter based on device class
+        devs = [dev for dev in all_dev if self._check_device_filter(dev)]
+        # Filter based on readout priority
+        devs = [dev for dev in devs if self._check_readout_filter(dev)]
+        self.devices = [device.name for device in devs]
+        self.set_device(current_device)
+
+    @Slot(list)
+    def set_available_devices(self, devices: list[str]):
+        """
+        Set the devices. If a device in the list is not valid, it will not be considered.
+
+        Args:
+            devices (list[str]): List of devices.
+        """
+        self.apply_filter = False
+        self.devices = devices
+
+    ### QtProperties ###
+
+    @Property(
+        "QStringList",
+        doc="List of devices. If updated, it will disable the apply filters property.",
+    )
    def devices(self) -> list[str]:
        """
-        Get the list of devices.
+        Get the list of devices for the applied filters.

        Returns:
            list[str]: List of devices.
@@ -40,84 +135,258 @@ class DeviceInputBase(BECWidget):
        return self._devices

    @devices.setter
-    def devices(self, value: list[str]):
-        """
-        Set the list of devices.
-
-        Args:
-            value: List of devices.
-        """
+    def devices(self, value: list):
        self._devices = value
+        self.config.devices = value
+        FilterIO.set_selection(widget=self, selection=value)

-    def set_device_filter(self, device_filter: str | list[str]):
+    @Property(str)
+    def default(self):
+        """Get the default device name. If set through this property, it will update only if the device is within the filtered selection."""
+        return self.config.default
+
+    @default.setter
+    def default(self, value: str):
+        if self.validate_device(value) is False:
+            return
+        self.config.default = value
+        WidgetIO.set_value(widget=self, value=value)
+
+    @Property(bool)
+    def apply_filter(self):
+        """Apply the filters on the devices."""
+        return self.config.apply_filter
+
+    @apply_filter.setter
+    def apply_filter(self, value: bool):
+        self.config.apply_filter = value
+        self.update_devices_from_filters()
+
+    @Property(bool)
+    def filter_to_device(self):
+        """Include devices in filters."""
+        return BECDeviceFilter.DEVICE in self.device_filter
+
+    @filter_to_device.setter
+    def filter_to_device(self, value: bool):
+        if value is True and BECDeviceFilter.DEVICE not in self.device_filter:
+            self._device_filter.append(BECDeviceFilter.DEVICE)
+        if value is False and BECDeviceFilter.DEVICE in self.device_filter:
+            self._device_filter.remove(BECDeviceFilter.DEVICE)
+        self.update_devices_from_filters()
+
+    @Property(bool)
+    def filter_to_positioner(self):
+        """Include devices of type Positioner in filters."""
+        return BECDeviceFilter.POSITIONER in self.device_filter
+
+    @filter_to_positioner.setter
+    def filter_to_positioner(self, value: bool):
+        if value is True and BECDeviceFilter.POSITIONER not in self.device_filter:
+            self._device_filter.append(BECDeviceFilter.POSITIONER)
+        if value is False and BECDeviceFilter.POSITIONER in self.device_filter:
+            self._device_filter.remove(BECDeviceFilter.POSITIONER)
+        self.update_devices_from_filters()
+
+    @Property(bool)
+    def filter_to_signal(self):
+        """Include devices of type Signal in filters."""
+        return BECDeviceFilter.SIGNAL in self.device_filter
+
+    @filter_to_signal.setter
+    def filter_to_signal(self, value: bool):
+        if value is True and BECDeviceFilter.SIGNAL not in self.device_filter:
+            self._device_filter.append(BECDeviceFilter.SIGNAL)
+        if value is False and BECDeviceFilter.SIGNAL in self.device_filter:
+            self._device_filter.remove(BECDeviceFilter.SIGNAL)
+        self.update_devices_from_filters()
+
+    @Property(bool)
+    def filter_to_computed_signal(self):
+        """Include devices of type ComputedSignal in filters."""
+        return BECDeviceFilter.COMPUTED_SIGNAL in self.device_filter
+
+    @filter_to_computed_signal.setter
+    def filter_to_computed_signal(self, value: bool):
+        if value is True and BECDeviceFilter.COMPUTED_SIGNAL not in self.device_filter:
+            self._device_filter.append(BECDeviceFilter.COMPUTED_SIGNAL)
+        if value is False and BECDeviceFilter.COMPUTED_SIGNAL in self.device_filter:
+            self._device_filter.remove(BECDeviceFilter.COMPUTED_SIGNAL)
+        self.update_devices_from_filters()
+
+    @Property(bool)
+    def readout_monitored(self):
+        """Include devices with readout priority Monitored in filters."""
+        return ReadoutPriority.MONITORED in self.readout_filter
+
+    @readout_monitored.setter
+    def readout_monitored(self, value: bool):
+        if value is True and ReadoutPriority.MONITORED not in self.readout_filter:
+            self._readout_filter.append(ReadoutPriority.MONITORED)
+        if value is False and ReadoutPriority.MONITORED in self.readout_filter:
+            self._readout_filter.remove(ReadoutPriority.MONITORED)
+        self.update_devices_from_filters()
+
+    @Property(bool)
+    def readout_baseline(self):
+        """Include devices with readout priority Baseline in filters."""
+        return ReadoutPriority.BASELINE in self.readout_filter
+
+    @readout_baseline.setter
+    def readout_baseline(self, value: bool):
+        if value is True and ReadoutPriority.BASELINE not in self.readout_filter:
+            self._readout_filter.append(ReadoutPriority.BASELINE)
+        if value is False and ReadoutPriority.BASELINE in self.readout_filter:
+            self._readout_filter.remove(ReadoutPriority.BASELINE)
+        self.update_devices_from_filters()
+
+    @Property(bool)
+    def readout_async(self):
+        """Include devices with readout priority Async in filters."""
+        return ReadoutPriority.ASYNC in self.readout_filter
+
+    @readout_async.setter
+    def readout_async(self, value: bool):
+        if value is True and ReadoutPriority.ASYNC not in self.readout_filter:
+            self._readout_filter.append(ReadoutPriority.ASYNC)
+        if value is False and ReadoutPriority.ASYNC in self.readout_filter:
+            self._readout_filter.remove(ReadoutPriority.ASYNC)
+        self.update_devices_from_filters()
+
+    @Property(bool)
+    def readout_continuous(self):
+        """Include devices with readout priority continuous in filters."""
+        return ReadoutPriority.CONTINUOUS in self.readout_filter
+
+    @readout_continuous.setter
+    def readout_continuous(self, value: bool):
+        if value is True and ReadoutPriority.CONTINUOUS not in self.readout_filter:
+            self._readout_filter.append(ReadoutPriority.CONTINUOUS)
+        if value is False and ReadoutPriority.CONTINUOUS in self.readout_filter:
+            self._readout_filter.remove(ReadoutPriority.CONTINUOUS)
+        self.update_devices_from_filters()
+
+    @Property(bool)
+    def readout_on_request(self):
+        """Include devices with readout priority OnRequest in filters."""
+        return ReadoutPriority.ON_REQUEST in self.readout_filter
+
+    @readout_on_request.setter
+    def readout_on_request(self, value: bool):
+        if value is True and ReadoutPriority.ON_REQUEST not in self.readout_filter:
+            self._readout_filter.append(ReadoutPriority.ON_REQUEST)
+        if value is False and ReadoutPriority.ON_REQUEST in self.readout_filter:
+            self._readout_filter.remove(ReadoutPriority.ON_REQUEST)
+        self.update_devices_from_filters()
+
+    ### Python Methods and Properties ###
+
+    @property
+    def device_filter(self) -> list[object]:
+        """Get the list of filters to apply on the devices."""
+        return self._device_filter
+
+    @property
+    def readout_filter(self) -> list[str]:
+        """Get the list of filters to apply on the devices"""
+        return self._readout_filter
+
+    def get_available_filters(self) -> list:
+        """Get the available filters."""
+        return [entry for entry in BECDeviceFilter]
+
+    def get_readout_priority_filters(self) -> list:
+        """Get the available readout priority filters."""
+        return [entry for entry in ReadoutPriority]
+
+    def set_device_filter(
+        self, filter_selection: str | BECDeviceFilter | list[str] | list[BECDeviceFilter]
+    ):
        """
-        Set the device filter.
+        Set the device filter. If None is passed, no filters are applied and all devices included.

        Args:
-            device_filter(str): Device filter, name of the device class.
+            filter_selection (str | list[str]): Device filters. It is recommended to make an enum for the filters.
        """
-        self.validate_device_filter(device_filter)
-        self.config.device_filter = device_filter
-        self._device_filter = device_filter
+        filters = None
+        if isinstance(filter_selection, list):
+            filters = [self._filter_handler.get(entry) for entry in filter_selection]
+        if isinstance(filter_selection, str) or isinstance(filter_selection, BECDeviceFilter):
+            filters = [self._filter_handler.get(filter_selection)]
+        if filters is None or any([entry is None for entry in filters]):
+            logger.warning(f"Device filter {filter_selection} is not in the device filter list.")
+            return
+        for entry in filters:
+            setattr(self, entry, True)

-    def set_default_device(self, default_device: str):
+    def set_readout_priority_filter(
+        self, filter_selection: str | ReadoutPriority | list[str] | list[ReadoutPriority]
+    ):
        """
-        Set the default device.
+        Set the readout priority filter. If None is passed, all filters are included.

        Args:
-            default_device(str): Default device name.
+            filter_selection (str | list[str]): Readout priority filters.
        """
-        self.validate_device(default_device)
-        self.config.default = default_device
+        filters = None
+        if isinstance(filter_selection, list):
+            filters = [self._filter_handler.get(entry) for entry in filter_selection]
+        if isinstance(filter_selection, str) or isinstance(filter_selection, ReadoutPriority):
+            filters = [self._filter_handler.get(filter_selection)]
+        if filters is None or any([entry is None for entry in filters]):
+            logger.warning(
+                f"Readout priority filter {filter_selection} is not in the readout priority list."
+            )
+            return
+        for entry in filters:
+            setattr(self, entry, True)

-    def get_device_list(self, filter: str | list[str] | None = None) -> list[str]:
-        """
-        Get the list of device names based on the filter of current BEC client.
+    def _check_device_filter(
+        self, device: Device | BECSignal | ComputedSignal | Positioner
+    ) -> bool:
+        """Check if filter for device type is applied or not.

        Args:
-            filter(str|None): Class name filter to apply on the device list.
+            device(Device | Signal | ComputedSignal | Positioner): Device object.
+        """
+        return all(isinstance(device, self._device_handler[entry]) for entry in self.device_filter)
+
+    def _check_readout_filter(
+        self, device: Device | BECSignal | ComputedSignal | Positioner
+    ) -> bool:
+        """Check if filter for readout priority is applied or not.
+
+        Args:
+            device(Device | Signal | ComputedSignal | Positioner): Device object.
+        """
+        return device.readout_priority in self.readout_filter
+
+    def get_device_object(self, device: str) -> object:
+        """
+        Get the device object based on the device name.
+
+        Args:
+            device(str): Device name.

        Returns:
-            devices(list[str]): List of device names.
+            object: Device object, can be device of type Device, Positioner, Signal or ComputedSignal.
        """
-        all_devices = self.dev.enabled_devices
-        if filter is not None:
-            self.validate_device_filter(filter)
-            if isinstance(filter, str):
-                filter = [filter]
-            devices = [device.name for device in all_devices if device.__class__.__name__ in filter]
-        else:
-            devices = [device.name for device in all_devices]
-        return devices
+        self.validate_device(device)
+        dev = getattr(self.dev, device.lower(), None)
+        if dev is None:
+            raise ValueError(
+                f"Device {device} is not found in the device manager {self.dev} as enabled device."
+            )
+        return dev

-    def get_available_filters(self):
+    def validate_device(self, device: str) -> bool:
        """
-        Get the available device classes which can be used as filters.
-        """
-        all_devices = self.dev.enabled_devices
-        filters = {device.__class__.__name__ for device in all_devices}
-        return filters
-
-    def validate_device_filter(self, filter: str | list[str]) -> None:
-        """
-        Validate the device filter if the class name is present in the current BEC instance.
-
-        Args:
-            filter(str|list[str]): Class name to use as a device filter.
-        """
-        if isinstance(filter, str):
-            filter = [filter]
-        available_filters = self.get_available_filters()
-        for f in filter:
-            if f not in available_filters:
-                raise ValueError(f"Device filter {f} is not valid.")
-
-    def validate_device(self, device: str) -> None:
-        """
-        Validate the device if it is present in current BEC instance.
+        Validate the device if it is present in the filtered device selection.

        Args:
            device(str): Device to validate.
        """
-        if device not in self.get_device_list(self.config.device_filter):
-            raise ValueError(f"Device {device} is not valid.")
+        all_devs = [dev.name for dev in self.dev.enabled_devices]
+        if device in self.devices and device in all_devs:
+            return True
+        return False
--- a/bec_widgets/widgets/base_classes/device_signal_input_base.py
+++ b/bec_widgets/widgets/base_classes/device_signal_input_base.py
@@ -0,0 +1,280 @@
+from bec_lib.callback_handler import EventType
+from bec_lib.device import Signal
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import Property, Slot
+
+from bec_widgets.utils import ConnectionConfig
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.filter_io import FilterIO
+from bec_widgets.utils.ophyd_kind_util import Kind
+from bec_widgets.utils.widget_io import WidgetIO
+
+logger = bec_logger.logger
+
+
+class DeviceSignalInputBaseConfig(ConnectionConfig):
+    """Configuration class for DeviceSignalInputBase."""
+
+    signal_filter: str | list[str] | None = None
+    default: str | None = None
+    arg_name: str | None = None
+    device: str | None = None
+    signals: list[str] | None = None
+
+
+class DeviceSignalInputBase(BECWidget):
+    """
+    Mixin base class for device signal input widgets.
+    Mixin class for device signal input widgets. This class provides methods to get the device signal list and device
+    signal object based on the current text of the widget.
+    """
+
+    _filter_handler = {
+        Kind.hinted: "include_hinted_signals",
+        Kind.normal: "include_normal_signals",
+        Kind.config: "include_config_signals",
+    }
+
+    def __init__(self, client=None, config=None, gui_id: str = None):
+        if config is None:
+            config = DeviceSignalInputBaseConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = DeviceSignalInputBaseConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+
+        self._device = None
+        self.get_bec_shortcuts()
+        self._signal_filter = []
+        self._signals = []
+        self._hinted_signals = []
+        self._normal_signals = []
+        self._config_signals = []
+        self.bec_dispatcher.client.callbacks.register(
+            EventType.DEVICE_UPDATE, self.update_signals_from_filters
+        )
+
+    ### Qt Slots ###
+
+    @Slot(str)
+    def set_signal(self, signal: str):
+        """
+        Set the signal.
+
+        Args:
+            signal (str): signal name.
+        """
+        if self.validate_signal(signal) is True:
+            WidgetIO.set_value(widget=self, value=signal)
+            self.config.default = signal
+        else:
+            logger.warning(
+                f"Signal {signal} not found for device {self.device} and filtered selection {self.signal_filter}."
+            )
+
+    @Slot(str)
+    def set_device(self, device: str | None):
+        """
+        Set the device. If device is not valid, device will be set to None which happpens
+
+        Args:
+            device(str): device name.
+        """
+        if self.validate_device(device) is False:
+            self._device = None
+        else:
+            self._device = device
+        self.update_signals_from_filters()
+
+    @Slot(dict, dict)
+    @Slot()
+    def update_signals_from_filters(
+        self, content: dict | None = None, metadata: dict | None = None
+    ):
+        """Update the filters for the device signals based on list in self.signal_filter.
+        In addition, store the hinted, normal and config signals in separate lists to allow
+        customisation within QLineEdit.
+
+        Note:
+        Signal and ComputedSignals have no signals. The naming convention follows the device name.
+        """
+        self.config.signal_filter = self.signal_filter
+        # pylint: disable=protected-access
+        self._hinted_signals = []
+        self._normal_signals = []
+        self._config_signals = []
+        if self.validate_device(self._device) is False:
+            self._device = None
+            self.config.device = self._device
+            return
+        device = self.get_device_object(self._device)
+        # See above convention for Signals and ComputedSignals
+        if isinstance(device, Signal):
+            self._signals = [self._device]
+            FilterIO.set_selection(widget=self, selection=[self._device])
+            return
+        device_info = device._info["signals"]
+        if Kind.hinted in self.signal_filter:
+            hinted_signals = [
+                signal
+                for signal, signal_info in device_info.items()
+                if (signal_info.get("kind_str", None) == str(Kind.hinted.value))
+            ]
+            self._hinted_signals = hinted_signals
+        if Kind.normal in self.signal_filter:
+            normal_signals = [
+                signal
+                for signal, signal_info in device_info.items()
+                if (signal_info.get("kind_str", None) == str(Kind.normal.value))
+            ]
+            self._normal_signals = normal_signals
+        if Kind.config in self.signal_filter:
+            config_signals = [
+                signal
+                for signal, signal_info in device_info.items()
+                if (signal_info.get("kind_str", None) == str(Kind.config.value))
+            ]
+            self._config_signals = config_signals
+        self._signals = self._hinted_signals + self._normal_signals + self._config_signals
+        FilterIO.set_selection(widget=self, selection=self.signals)
+
+    ### Qt Properties ###
+
+    @Property(str)
+    def device(self) -> str:
+        """Get the selected device."""
+        if self._device is None:
+            return ""
+        return self._device
+
+    @device.setter
+    def device(self, value: str):
+        """Set the device and update the filters, only allow devices present in the devicemanager."""
+        self._device = value
+        self.config.device = value
+        self.update_signals_from_filters()
+
+    @Property(bool)
+    def include_hinted_signals(self):
+        """Include hinted signals in filters."""
+        return Kind.hinted in self.signal_filter
+
+    @include_hinted_signals.setter
+    def include_hinted_signals(self, value: bool):
+        if value:
+            self._signal_filter.append(Kind.hinted)
+        else:
+            self._signal_filter.remove(Kind.hinted)
+        self.update_signals_from_filters()
+
+    @Property(bool)
+    def include_normal_signals(self):
+        """Include normal signals in filters."""
+        return Kind.normal in self.signal_filter
+
+    @include_normal_signals.setter
+    def include_normal_signals(self, value: bool):
+        if value:
+            self._signal_filter.append(Kind.normal)
+        else:
+            self._signal_filter.remove(Kind.normal)
+        self.update_signals_from_filters()
+
+    @Property(bool)
+    def include_config_signals(self):
+        """Include config signals in filters."""
+        return Kind.config in self.signal_filter
+
+    @include_config_signals.setter
+    def include_config_signals(self, value: bool):
+        if value:
+            self._signal_filter.append(Kind.config)
+        else:
+            self._signal_filter.remove(Kind.config)
+        self.update_signals_from_filters()
+
+    ### Properties and Methods ###
+
+    @property
+    def signals(self) -> list[str]:
+        """
+        Get the list of device signals for the applied filters.
+
+        Returns:
+            list[str]: List of device signals.
+        """
+        return self._signals
+
+    @signals.setter
+    def signals(self, value: list[str]):
+        self._signals = value
+        self.config.signals = value
+        FilterIO.set_selection(widget=self, selection=value)
+
+    @property
+    def signal_filter(self) -> list[str]:
+        """Get the list of filters to apply on the device signals."""
+        return self._signal_filter
+
+    def get_available_filters(self) -> list[str]:
+        """Get the available filters."""
+        return [entry for entry in self._filter_handler]
+
+    def set_filter(self, filter_selection: str | list[str]):
+        """
+        Set the device filter. If None, all devices are included.
+
+        Args:
+            filter_selection (str | list[str]): Device filters from BECDeviceFilter and BECReadoutPriority.
+        """
+        filters = None
+        if isinstance(filter_selection, list):
+            filters = [self._filter_handler.get(entry) for entry in filter_selection]
+        if isinstance(filter_selection, str):
+            filters = [self._filter_handler.get(filter_selection)]
+        if filters is None:
+            return
+        for entry in filters:
+            setattr(self, entry, True)
+
+    def get_device_object(self, device: str) -> object | None:
+        """
+        Get the device object based on the device name.
+
+        Args:
+            device(str): Device name.
+
+        Returns:
+            object: Device object, can be device of type Device, Positioner, Signal or ComputedSignal.
+        """
+        self.validate_device(device)
+        dev = getattr(self.dev, device.lower(), None)
+        if dev is None:
+            logger.warning(f"Device {device} not found in devicemanager.")
+            return None
+        return dev
+
+    def validate_device(self, device: str | None, raise_on_false: bool = False) -> bool:
+        """
+        Validate the device if it is present in current BEC instance.
+
+        Args:
+            device(str): Device to validate.
+        """
+        if device in self.dev:
+            return True
+        if raise_on_false is True:
+            raise ValueError(f"Device {device} not found in devicemanager.")
+        return False
+
+    def validate_signal(self, signal: str) -> bool:
+        """
+        Validate the signal if it is present in the device signals.
+
+        Args:
+            signal(str): Signal to validate.
+        """
+        if signal in self.signals:
+            return True
+        return False
--- a/bec_widgets/widgets/bec_status_box/status_item.py
+++ b/bec_widgets/widgets/bec_status_box/status_item.py
@@ -141,6 +141,7 @@ class StatusItem(QWidget):
        metrics_text = (
            f"<b>SERVICE:</b> {self.config.service_name}<br><b>STATUS:</b> {self.config.status}<br>"
        )
+        metrics_text += f"<b>BEC_LIB VERSION:</b> {self.config.info['version']}<br>"
        if self.config.metrics:
            for key, value in self.config.metrics.items():
                if key == "create_time":
--- a/bec_widgets/widgets/colormap_widget/init.py
+++ b/bec_widgets/widgets/colormap_widget/init.py
--- a/bec_widgets/widgets/colormap_widget/bec_color_map_widget.pyproject
+++ b/bec_widgets/widgets/colormap_widget/bec_color_map_widget.pyproject
@@ -0,0 +1 @@
+{'files': ['colormap_widget.py']}
--- a/bec_widgets/widgets/colormap_widget/bec_color_map_widget_plugin.py
+++ b/bec_widgets/widgets/colormap_widget/bec_color_map_widget_plugin.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.colormap_widget.colormap_widget import BECColorMapWidget
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECColorMapWidget' name='bec_color_map_widget'>
+    </widget>
+</ui>
+"""
+
+
+class BECColorMapWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECColorMapWidget(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Buttons"
+
+    def icon(self):
+        return designer_material_icon(BECColorMapWidget.ICON_NAME)
+
+    def includeFile(self):
+        return "bec_color_map_widget"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "BECColorMapWidget"
+
+    def toolTip(self):
+        return "BECColorMapWidget"
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/widgets/colormap_widget/colormap_widget.py
+++ b/bec_widgets/widgets/colormap_widget/colormap_widget.py
@@ -0,0 +1,73 @@
+from pyqtgraph.widgets.ColorMapButton import ColorMapButton
+from qtpy.QtCore import Property, Signal, Slot
+from qtpy.QtWidgets import QSizePolicy, QVBoxLayout, QWidget
+
+from bec_widgets.utils import Colors
+from bec_widgets.utils.bec_widget import BECWidget
+
+
+class BECColorMapWidget(BECWidget, QWidget):
+    colormap_changed_signal = Signal(str)
+    ICON_NAME = "palette"
+    USER_ACCESS = ["colormap"]
+
+    def __init__(self, parent=None, cmap: str = "magma"):
+        super().__init__()
+        QWidget.__init__(self, parent=parent)
+
+        # Create the ColorMapButton
+        self.button = ColorMapButton()
+
+        # Set the size policy and minimum width
+        size_policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
+        self.button.setSizePolicy(size_policy)
+        self.button.setMinimumWidth(100)
+        self.button.setMinimumHeight(30)
+
+        # Create the layout
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.button)
+        self.layout.setSpacing(0)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+
+        # Set the initial colormap
+        self.button.setColorMap(cmap)
+        self._cmap = cmap
+
+        # Connect the signal
+        self.button.sigColorMapChanged.connect(self.colormap_changed)
+
+    @Property(str)
+    def colormap(self):
+        """Get the current colormap name."""
+        return self._cmap
+
+    @colormap.setter
+    def colormap(self, name):
+        """Set the colormap by name."""
+        if self._cmap != name:
+            if Colors.validate_color_map(name, return_error=False) is False:
+                return
+            self.button.setColorMap(name)
+            self._cmap = name
+            self.colormap_changed_signal.emit(name)
+
+    @Slot()
+    def colormap_changed(self):
+        """
+        Emit the colormap changed signal with the current colormap selected in the button.
+        """
+        cmap = self.button.colorMap().name
+        self._cmap = cmap
+        self.colormap_changed_signal.emit(cmap)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    window = BECColorMapWidget()
+    window.show()
+    sys.exit(app.exec())
--- a/bec_widgets/widgets/colormap_widget/register_bec_color_map_widget.py
+++ b/bec_widgets/widgets/colormap_widget/register_bec_color_map_widget.py
@@ -0,0 +1,17 @@
+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.colormap_widget.bec_color_map_widget_plugin import (
+        BECColorMapWidgetPlugin,
+    )
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECColorMapWidgetPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/widgets/dap_combo_box/dap_combo_box_plugin.py
+++ b/bec_widgets/widgets/dap_combo_box/dap_combo_box_plugin.py
@@ -27,7 +27,7 @@ class DapComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
        return DOM_XML

    def group(self):
-        return "BEC Selection Widgets"
+        return "BEC Input Widgets"

    def icon(self):
        return designer_material_icon(DapComboBox.ICON_NAME)
--- a/bec_widgets/widgets/device_combobox/device_combo_box_plugin.py
+++ b/bec_widgets/widgets/device_combobox/device_combo_box_plugin.py
@@ -31,7 +31,7 @@ class DeviceComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
        return DOM_XML

    def group(self):
-        return "Device Control"
+        return "BEC Input Widgets"

    def icon(self):
        return designer_material_icon(DeviceComboBox.ICON_NAME)
--- a/bec_widgets/widgets/device_combobox/device_combobox.py
+++ b/bec_widgets/widgets/device_combobox/device_combobox.py
@@ -1,86 +1,163 @@
-from typing import TYPE_CHECKING
+from bec_lib.callback_handler import EventType
+from bec_lib.device import ReadoutPriority
+from qtpy.QtCore import QSize, Signal, Slot
+from qtpy.QtGui import QPainter, QPaintEvent, QPen
+from qtpy.QtWidgets import QComboBox, QSizePolicy

-from qtpy.QtWidgets import QComboBox
-
-from bec_widgets.widgets.base_classes.device_input_base import DeviceInputBase, DeviceInputConfig
-
-if TYPE_CHECKING:
-    from bec_widgets.widgets.base_classes.device_input_base import DeviceInputConfig
+from bec_widgets.utils.colors import get_accent_colors
+from bec_widgets.widgets.base_classes.device_input_base import (
+    BECDeviceFilter,
+    DeviceInputBase,
+    DeviceInputConfig,
+)


 class DeviceComboBox(DeviceInputBase, QComboBox):
    """
-    Line edit widget for device input with autocomplete for device names.
+    Combobox widget for device input with autocomplete for device names.

    Args:
        parent: Parent widget.
        client: BEC client object.
        config: Device input configuration.
        gui_id: GUI ID.
-        device_filter: Device filter, name of the device class.
+        device_filter: Device filter, name of the device class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
        default: Default device name.
        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
    """

    ICON_NAME = "list_alt"

+    device_selected = Signal(str)
+    device_config_update = Signal()
+
    def __init__(
        self,
        parent=None,
        client=None,
        config: DeviceInputConfig = None,
        gui_id: str | None = None,
-        device_filter: str | None = None,
+        device_filter: BECDeviceFilter | list[BECDeviceFilter] | None = None,
+        readout_priority_filter: (
+            str | ReadoutPriority | list[str] | list[ReadoutPriority] | None
+        ) = None,
+        available_devices: list[str] | None = None,
        default: str | None = None,
        arg_name: str | None = None,
    ):
        super().__init__(client=client, config=config, gui_id=gui_id)
        QComboBox.__init__(self, parent=parent)
-        self.setMinimumSize(125, 26)
-        self.populate_combobox()
-
        if arg_name is not None:
            self.config.arg_name = arg_name
+            self.arg_name = arg_name
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+        self.setMinimumSize(QSize(100, 0))
+        self._callback_id = None
+        self._is_valid_input = False
+        self._accent_colors = get_accent_colors()
+        # We do not consider the config that is passed here, this produced problems
+        # with QtDesigner, since config and input arguments may differ and resolve properly
+        # Implementing this logic and config recoverage is postponed.
+        # Set available devices if passed
+        if available_devices is not None:
+            self.set_available_devices(available_devices)
+        # Set readout priority filter default is all
+        if readout_priority_filter is not None:
+            self.set_readout_priority_filter(readout_priority_filter)
+        else:
+            self.set_readout_priority_filter(
+                [
+                    ReadoutPriority.MONITORED,
+                    ReadoutPriority.BASELINE,
+                    ReadoutPriority.ASYNC,
+                    ReadoutPriority.CONTINUOUS,
+                    ReadoutPriority.ON_REQUEST,
+                ]
+            )
+        # Device filter default is None
        if device_filter is not None:
            self.set_device_filter(device_filter)
+        # Set default device if passed
        if default is not None:
-            self.set_default_device(default)
+            self.set_device(default)
+        self._callback_id = self.bec_dispatcher.client.callbacks.register(
+            EventType.DEVICE_UPDATE, self.on_device_update
+        )
+        self.device_config_update.connect(self.update_devices_from_filters)
+        self.currentTextChanged.connect(self.check_validity)
+        self.check_validity(self.currentText())

-    def set_device_filter(self, device_filter: str):
+    def on_device_update(self, action: str, content: dict) -> None:
        """
-        Set the device filter.
+        Callback for device update events. Triggers the device_update signal.

        Args:
-            device_filter(str): Device filter, name of the device class.
+            action (str): The action that triggered the event.
+            content (dict): The content of the config update.
        """
-        super().set_device_filter(device_filter)
-        self.populate_combobox()
+        if action in ["add", "remove", "reload"]:
+            self.device_config_update.emit()

-    def set_default_device(self, default_device: str):
+    def cleanup(self):
+        """Cleanup the widget."""
+        if self._callback_id is not None:
+            self.bec_dispatcher.client.callbacks.remove(self._callback_id)
+
+    def get_current_device(self) -> object:
        """
-        Set the default device.
-
-        Args:
-            default_device(str): Default device name.
-        """
-        super().set_default_device(default_device)
-        self.setCurrentText(default_device)
-
-    def populate_combobox(self):
-        """Populate the combobox with the devices."""
-        self.devices = self.get_device_list(self.config.device_filter)
-        self.clear()
-        self.addItems(self.devices)
-
-    def get_device(self) -> object:
-        """
-        Get the selected device object.
+        Get the current device object based on the current value.

        Returns:
-            object: Device object.
+            object: Device object, can be device of type Device, Positioner, Signal or ComputedSignal.
        """
-        device_name = self.currentText()
-        device_obj = getattr(self.dev, device_name.lower(), None)
-        if device_obj is None:
-            raise ValueError(f"Device {device_name} is not found.")
-        return device_obj
+        dev_name = self.currentText()
+        return self.get_device_object(dev_name)
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        """Extend the paint event to set the border color based on the validity of the input.
+
+        Args:
+            event (PySide6.QtGui.QPaintEvent) : Paint event.
+        """
+        # logger.info(f"Received paint event: {event} in {self.__class__}")
+        super().paintEvent(event)
+
+        if self._is_valid_input is False and self.isEnabled() is True:
+            painter = QPainter(self)
+            pen = QPen()
+            pen.setWidth(2)
+            pen.setColor(self._accent_colors.emergency)
+            painter.setPen(pen)
+            painter.drawRect(self.rect().adjusted(1, 1, -1, -1))
+            painter.end()
+
+    @Slot(str)
+    def check_validity(self, input_text: str) -> None:
+        """
+        Check if the current value is a valid device name.
+        """
+        if self.validate_device(input_text) is True:
+            self._is_valid_input = True
+            self.device_selected.emit(input_text.lower())
+        else:
+            self._is_valid_input = False
+        self.update()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # pylint: disable=import-outside-toplevel
+    from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+    from bec_widgets.utils.colors import set_theme
+
+    app = QApplication([])
+    set_theme("dark")
+    widget = QWidget()
+    widget.setFixedSize(200, 200)
+    layout = QVBoxLayout()
+    widget.setLayout(layout)
+    combo = DeviceComboBox()
+    combo.devices = ["samx", "dev1", "dev2", "dev3", "dev4"]
+    layout.addWidget(combo)
+    widget.show()
+    app.exec_()
--- a/bec_widgets/widgets/device_line_edit/device_line_edit.py
+++ b/bec_widgets/widgets/device_line_edit/device_line_edit.py
@@ -1,13 +1,18 @@
-from typing import TYPE_CHECKING
-
+from bec_lib.callback_handler import EventType
+from bec_lib.device import ReadoutPriority
+from bec_lib.logger import bec_logger
 from qtpy.QtCore import QSize, Signal, Slot
-from qtpy.QtWidgets import QCompleter, QLineEdit, QSizePolicy
+from qtpy.QtGui import QPainter, QPaintEvent, QPen
+from qtpy.QtWidgets import QApplication, QCompleter, QLineEdit, QSizePolicy

-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.widgets.base_classes.device_input_base import DeviceInputBase, DeviceInputConfig
+from bec_widgets.utils.colors import get_accent_colors
+from bec_widgets.widgets.base_classes.device_input_base import (
+    BECDeviceFilter,
+    DeviceInputBase,
+    DeviceInputConfig,
+)

-if TYPE_CHECKING:
-    from bec_widgets.widgets.base_classes.device_input_base import DeviceInputConfig
+logger = bec_logger.logger


 class DeviceLineEdit(DeviceInputBase, QLineEdit):
@@ -19,12 +24,13 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
        client: BEC client object.
        config: Device input configuration.
        gui_id: GUI ID.
-        device_filter: Device filter, name of the device class.
+        device_filter: Device filter, name of the device class from BECDeviceFilter and ReadoutPriority. Check DeviceInputBase for more details.
        default: Default device name.
        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
    """

    device_selected = Signal(str)
+    device_config_update = Signal()

    ICON_NAME = "edit_note"

@@ -34,80 +40,137 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
        client=None,
        config: DeviceInputConfig = None,
        gui_id: str | None = None,
-        device_filter: str | list[str] | None = None,
+        device_filter: BECDeviceFilter | list[BECDeviceFilter] | None = None,
+        readout_priority_filter: (
+            str | ReadoutPriority | list[str] | list[ReadoutPriority] | None
+        ) = None,
+        available_devices: list[str] | None = None,
        default: str | None = None,
        arg_name: str | None = None,
    ):
+        self._callback_id = None
+        self._is_valid_input = False
+        self._accent_colors = get_accent_colors()
        super().__init__(client=client, config=config, gui_id=gui_id)
        QLineEdit.__init__(self, parent=parent)
-
        self.completer = QCompleter(self)
        self.setCompleter(self.completer)
-        self.populate_completer()

        if arg_name is not None:
            self.config.arg_name = arg_name
            self.arg_name = arg_name
-        if device_filter is not None:
-            self.set_device_filter(device_filter)
-        if default is not None:
-            self.set_default_device(default)
-
        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
        self.setMinimumSize(QSize(100, 0))

-        self.editingFinished.connect(self.emit_device_selected)
+        # We do not consider the config that is passed here, this produced problems
+        # with QtDesigner, since config and input arguments may differ and resolve properly
+        # Implementing this logic and config recoverage is postponed.
+        # Set available devices if passed
+        if available_devices is not None:
+            self.set_available_devices(available_devices)
+        # Set readout priority filter default is all
+        if readout_priority_filter is not None:
+            self.set_readout_priority_filter(readout_priority_filter)
+        else:
+            self.set_readout_priority_filter(
+                [
+                    ReadoutPriority.MONITORED,
+                    ReadoutPriority.BASELINE,
+                    ReadoutPriority.ASYNC,
+                    ReadoutPriority.CONTINUOUS,
+                    ReadoutPriority.ON_REQUEST,
+                ]
+            )
+        # Device filter default is None
+        if device_filter is not None:
+            self.set_device_filter(device_filter)
+        # Set default device if passed
+        if default is not None:
+            self.set_device(default)
+        self._callback_id = self.bec_dispatcher.client.callbacks.register(
+            EventType.DEVICE_UPDATE, self.on_device_update
+        )
+        self.device_config_update.connect(self.update_devices_from_filters)
+        self.textChanged.connect(self.check_validity)
+        self.check_validity(self.text())

-    @Slot()
-    def emit_device_selected(self):
+    def on_device_update(self, action: str, content: dict) -> None:
        """
-        Editing finished, let's see which device is selected and emit signal
-        """
-        device_name = self.text().lower()
-        device_obj = getattr(self.dev, device_name, None)
-        if device_obj is not None:
-            self.device_selected.emit(device_name)
-
-    def set_device_filter(self, device_filter: str | list[str]):
-        """
-        Set the device filter.
+        Callback for device update events. Triggers the device_update signal.

        Args:
-            device_filter (str | list[str]): Device filter, name of the device class.
+            action (str): The action that triggered the event.
+            content (dict): The content of the config update.
        """
-        super().set_device_filter(device_filter)
-        self.populate_completer()
+        if action in ["add", "remove", "reload"]:
+            self.device_config_update.emit()

-    def set_default_device(self, default_device: str):
+    def cleanup(self):
+        """Cleanup the widget."""
+        if self._callback_id is not None:
+            self.bec_dispatcher.client.callbacks.remove(self._callback_id)
+
+    def get_current_device(self) -> object:
        """
-        Set the default device.
-
-        Args:
-            default_device (str): Default device name.
-        """
-        super().set_default_device(default_device)
-        self.setText(default_device)
-
-    def populate_completer(self):
-        """Populate the completer with the devices."""
-        self.devices = self.get_device_list(self.config.device_filter)
-        self.completer.setModel(self.create_completer_model(self.devices))
-
-    def create_completer_model(self, devices: list[str]):
-        """Create a model for the completer."""
-        from qtpy.QtCore import QStringListModel
-
-        return QStringListModel(devices, self)
-
-    def get_device(self) -> object:
-        """
-        Get the selected device object.
+        Get the current device object based on the current value.

        Returns:
-            object: Device object.
+            object: Device object, can be device of type Device, Positioner, Signal or ComputedSignal.
        """
-        device_name = self.text()
-        device_obj = getattr(self.dev, device_name.lower(), None)
-        if device_obj is None:
-            raise ValueError(f"Device {device_name} is not found.")
-        return device_obj
+        dev_name = self.text()
+        return self.get_device_object(dev_name)
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        """Extend the paint event to set the border color based on the validity of the input.
+
+        Args:
+            event (PySide6.QtGui.QPaintEvent) : Paint event.
+        """
+        # logger.info(f"Received paint event: {event} in {self.__class__}")
+        super().paintEvent(event)
+
+        if self._is_valid_input is False and self.isEnabled() is True:
+            painter = QPainter(self)
+            pen = QPen()
+            pen.setWidth(2)
+            pen.setColor(self._accent_colors.emergency)
+            painter.setPen(pen)
+            painter.drawRect(self.rect().adjusted(1, 1, -1, -1))
+            painter.end()
+
+    @Slot(str)
+    def check_validity(self, input_text: str) -> None:
+        """
+        Check if the current value is a valid device name.
+        """
+        if self.validate_device(input_text) is True:
+            self._is_valid_input = True
+            self.device_selected.emit(input_text.lower())
+        else:
+            self._is_valid_input = False
+        self.update()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # pylint: disable=import-outside-toplevel
+    from qtpy.QtWidgets import QVBoxLayout, QWidget
+
+    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.widgets.signal_combobox.signal_combobox import SignalComboBox
+
+    app = QApplication([])
+    set_theme("dark")
+    widget = QWidget()
+    widget.setFixedSize(200, 200)
+    layout = QVBoxLayout()
+    widget.setLayout(layout)
+    line_edit = DeviceLineEdit()
+    line_edit.filter_to_positioner = True
+    signal_line_edit = SignalComboBox()
+    line_edit.textChanged.connect(signal_line_edit.set_device)
+    line_edit.set_available_devices(["samx", "samy", "samz"])
+    line_edit.set_device("samx")
+    layout.addWidget(line_edit)
+    layout.addWidget(signal_line_edit)
+    widget.show()
+    app.exec_()
--- a/bec_widgets/widgets/device_line_edit/device_line_edit_plugin.py
+++ b/bec_widgets/widgets/device_line_edit/device_line_edit_plugin.py
@@ -31,7 +31,7 @@ class DeviceLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
        return DOM_XML

    def group(self):
-        return "Device Control"
+        return "BEC Input Widgets"

    def icon(self):
        return designer_material_icon(DeviceLineEdit.ICON_NAME)
--- a/bec_widgets/widgets/dock/dock.py
+++ b/bec_widgets/widgets/dock/dock.py
@@ -2,6 +2,7 @@ from __future__ import annotations

 from typing import TYPE_CHECKING, Any, Literal, Optional

+from qtpy.QtCore import QSize
 from pydantic import Field
 from pyqtgraph.dockarea import Dock, DockLabel
 from qtpy import QtCore, QtGui
@@ -116,6 +117,7 @@ class BECDock(BECWidget, Dock):
        "remove",
        "attach",
        "detach",
+        "close",
    ]

    def __init__(
@@ -126,6 +128,7 @@ class BECDock(BECWidget, Dock):
        name: str | None = None,
        client=None,
        gui_id: str | None = None,
+        temp: bool = False,
        closable: bool = True,
        **kwargs,
    ) -> None:
@@ -147,6 +150,8 @@ class BECDock(BECWidget, Dock):
        # Layout Manager
        self.layout_manager = GridLayoutManager(self.layout)

+        self.temp = temp
+
    def dropEvent(self, event):
        source = event.source()
        old_area = source.area
@@ -172,6 +177,24 @@ class BECDock(BECWidget, Dock):
        else:
            super().float()

+        if self.temp:
+            self.make_dock_temporary()
+
+    def make_dock_temporary(self):
+        """
+        Make the dock temporary.
+        """
+
+        from bec_widgets.widgets.dock import BECDockArea
+
+        self.orig_area.docks.pop(self.name(), None)
+        self.orig_area = BECDockArea()
+        self.area = self.orig_area
+        self.area.panels[self.name()] = self
+        self.config.parent_dock_area = self.area.gui_id
+        self.area.temporary = False
+        self.hide_title_bar()
+
    @property
    def widget_list(self) -> list[BECWidget]:
        """
@@ -333,3 +356,7 @@ class BECDock(BECWidget, Dock):
        self.cleanup()
        super().close()
        self.parent_dock_area.dock_area.docks.pop(self.name(), None)
+
+        if self.temp:
+            self.area.deleteLater()
+            self.deleteLater()
--- a/bec_widgets/widgets/dock/dock_area.py
+++ b/bec_widgets/widgets/dock/dock_area.py
@@ -278,6 +278,7 @@ class BECDockArea(BECWidget, QWidget):
        name: str = None,
        position: Literal["bottom", "top", "left", "right", "above", "below"] = None,
        relative_to: BECDock | None = None,
+        temporary: bool = False,
        closable: bool = True,
        floating: bool = False,
        prefix: str = "dock",
@@ -294,6 +295,7 @@ class BECDockArea(BECWidget, QWidget):
            name(str): The name of the dock to be displayed and for further references. Has to be unique.
            position(Literal["bottom", "top", "left", "right", "above", "below"]): The position of the dock.
            relative_to(BECDock): The dock to which the new dock should be added relative to.
+            temp(bool): Whether the dock is temporary. Upon closing the dock is not returned to the parent dock area.
            closable(bool): Whether the dock is closable.
            floating(bool): Whether the dock is detached after creating.
            prefix(str): The prefix for the dock name if no name is provided.
@@ -317,7 +319,7 @@ class BECDockArea(BECWidget, QWidget):
        if position is None:
            position = "bottom"

-        dock = BECDock(name=name, parent_dock_area=self, closable=closable)
+        dock = BECDock(name=name, parent_dock_area=self, closable=closable, temp=temporary)
        dock.config.position = position
        self.config.docks[name] = dock.config

@@ -338,10 +340,19 @@ class BECDockArea(BECWidget, QWidget):
        ):  # TODO still decide how initial instructions should be handled
            self._instructions_visible = False
            self.update()
-        if floating:
+        if floating or temporary:
            dock.detach()
+        print("dock added")
        return dock

+    # def add_temp_dock(self):
+    #     area = BECDockArea()
+    #     area.show()
+    #     area.add_dock("dock1", widget="BECFigure")
+
+    def addDock(self, *args, **kwargs):
+        return self.add_dock(*args, **kwargs)
+
    def detach_dock(self, dock_name: str) -> BECDock:
        """
        Undock a dock from the dock area.
@@ -402,6 +413,11 @@ class BECDockArea(BECWidget, QWidget):
        self.cleanup()
        super().close()

+    def closeEvent(self, event):
+        print("close event called")
+        self.cleanup()
+        super().closeEvent(event)
+

 if __name__ == "__main__":
    from qtpy.QtWidgets import QApplication
@@ -412,4 +428,5 @@ if __name__ == "__main__":
    set_theme("auto")
    dock_area = BECDockArea()
    dock_area.show()
+    dock_area.add_dock("dock1", widget="BECFigure", temporary=True)
    app.exec_()
--- a/bec_widgets/widgets/figure/plots/plot_base.py
+++ b/bec_widgets/widgets/figure/plots/plot_base.py
@@ -147,6 +147,9 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
        for axis in ["left", "bottom", "right", "top"]:
            self.plot_item.getAxis(axis).setPen(text_pen)
            self.plot_item.getAxis(axis).setTextPen(text_pen)
+        if self.plot_item.legend is not None:
+            for sample, label in self.plot_item.legend.items:
+                label.setText(label.text, color=palette.text().color())

    def set(self, **kwargs) -> None:
        """
@@ -394,8 +397,8 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
        """Hook the crosshair to all plots."""
        if self.crosshair is None:
            self.crosshair = Crosshair(self.plot_item, precision=3)
-            self.crosshair.positionChanged.connect(self.crosshair_position_changed)
-            self.crosshair.positionClicked.connect(self.crosshair_position_clicked)
+            self.crosshair.crosshairChanged.connect(self.crosshair_position_changed)
+            self.crosshair.crosshairClicked.connect(self.crosshair_position_clicked)
            self.crosshair.coordinatesChanged1D.connect(self.crosshair_coordinates_changed)
            self.crosshair.coordinatesClicked1D.connect(self.crosshair_coordinates_clicked)
            self.crosshair.coordinatesChanged2D.connect(self.crosshair_coordinates_changed)
@@ -404,8 +407,8 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
    def unhook_crosshair(self) -> None:
        """Unhook the crosshair from all plots."""
        if self.crosshair is not None:
-            self.crosshair.positionChanged.disconnect(self.crosshair_position_changed)
-            self.crosshair.positionClicked.disconnect(self.crosshair_position_clicked)
+            self.crosshair.crosshairChanged.disconnect(self.crosshair_position_changed)
+            self.crosshair.crosshairClicked.disconnect(self.crosshair_position_clicked)
            self.crosshair.coordinatesChanged1D.disconnect(self.crosshair_coordinates_changed)
            self.crosshair.coordinatesClicked1D.disconnect(self.crosshair_coordinates_clicked)
            self.crosshair.coordinatesChanged2D.disconnect(self.crosshair_coordinates_changed)
--- a/bec_widgets/widgets/image/image_widget.py
+++ b/bec_widgets/widgets/image/image_widget.py
@@ -4,6 +4,7 @@ import sys
 from typing import Literal, Optional

 import pyqtgraph as pg
+from bec_lib.device import ReadoutPriority
 from qtpy.QtWidgets import QComboBox, QVBoxLayout, QWidget

 from bec_widgets.qt_utils.error_popups import SafeSlot, WarningPopupUtility
@@ -16,6 +17,7 @@ from bec_widgets.qt_utils.toolbar import (
    WidgetAction,
 )
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.figure import BECFigure
 from bec_widgets.widgets.figure.plots.axis_settings import AxisSettings
@@ -69,7 +71,11 @@ class BECImageWidget(BECWidget, QWidget):
        self.toolbar = ModularToolBar(
            actions={
                "monitor": DeviceSelectionAction(
-                    "Monitor:", DeviceComboBox(device_filter="Device")
+                    "Monitor:",
+                    DeviceComboBox(
+                        device_filter=BECDeviceFilter.DEVICE,
+                        readout_priority_filter=[ReadoutPriority.ASYNC],
+                    ),
                ),
                "monitor_type": WidgetAction(widget=self.dim_combo_box),
                "connect": MaterialIconAction(icon_name="link", tooltip="Connect Device"),
--- a/bec_widgets/widgets/motor_map/motor_map_widget.py
+++ b/bec_widgets/widgets/motor_map/motor_map_widget.py
@@ -2,11 +2,13 @@ from __future__ import annotations

 import sys

+from bec_lib.device import ReadoutPriority
 from qtpy.QtWidgets import QVBoxLayout, QWidget

 from bec_widgets.qt_utils.settings_dialog import SettingsDialog
 from bec_widgets.qt_utils.toolbar import DeviceSelectionAction, MaterialIconAction, ModularToolBar
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.figure import BECFigure
 from bec_widgets.widgets.figure.plots.motor_map.motor_map import MotorMapConfig
@@ -50,10 +52,10 @@ class BECMotorMapWidget(BECWidget, QWidget):
        self.toolbar = ModularToolBar(
            actions={
                "motor_x": DeviceSelectionAction(
-                    "Motor X:", DeviceComboBox(device_filter="Positioner")
+                    "Motor X:", DeviceComboBox(device_filter=[BECDeviceFilter.POSITIONER])
                ),
                "motor_y": DeviceSelectionAction(
-                    "Motor Y:", DeviceComboBox(device_filter="Positioner")
+                    "Motor Y:", DeviceComboBox(device_filter=[BECDeviceFilter.POSITIONER])
                ),
                "connect": MaterialIconAction(icon_name="link", tooltip="Connect Motors"),
                "history": MaterialIconAction(icon_name="history", tooltip="Reset Trace History"),
--- a/bec_widgets/widgets/positioner_box/positioner_box.py
+++ b/bec_widgets/widgets/positioner_box/positioner_box.py
@@ -18,6 +18,7 @@ from bec_widgets.qt_utils.compact_popup import CompactPopupWidget
 from bec_widgets.utils import UILoader
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import get_accent_colors, set_theme
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.device_line_edit.device_line_edit import DeviceLineEdit

 logger = bec_logger.logger
@@ -97,7 +98,9 @@ class PositionerBox(BECWidget, CompactPopupWidget):
        self._dialog = QDialog(self)
        self._dialog.setWindowTitle("Positioner Selection")
        layout = QVBoxLayout()
-        line_edit = DeviceLineEdit(self, client=self.client, device_filter="Positioner")
+        line_edit = DeviceLineEdit(
+            self, client=self.client, device_filter=[BECDeviceFilter.POSITIONER]
+        )
        line_edit.textChanged.connect(self.set_positioner)
        layout.addWidget(line_edit)
        close_button = QPushButton("Close")
--- a/bec_widgets/widgets/scan_control/scan_group_box.py
+++ b/bec_widgets/widgets/scan_control/scan_group_box.py
@@ -21,6 +21,7 @@ from qtpy.QtWidgets import (
 )

 from bec_widgets.utils.widget_io import WidgetIO
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.device_line_edit.device_line_edit import DeviceLineEdit

 logger = bec_logger.logger
@@ -233,6 +234,7 @@ class ScanGroupBox(QGroupBox):
                default = None
            widget = widget_class(arg_name=arg_name, default=default)
            if isinstance(widget, DeviceLineEdit):
+                widget.set_device_filter(BECDeviceFilter.DEVICE)
                self.selected_devices[widget] = ""
                widget.device_selected.connect(self.emit_device_selected)
            tooltip = item.get("tooltip", None)
@@ -306,7 +308,7 @@ class ScanGroupBox(QGroupBox):
                try:  # In case that the bundle size changes
                    widget = self.layout.itemAtPosition(i, j).widget()
                    if isinstance(widget, DeviceLineEdit) and device_object:
-                        value = widget.get_device()
+                        value = widget.get_current_device()
                    else:
                        value = WidgetIO.get_value(widget)
                    args.append(value)
@@ -319,7 +321,7 @@ class ScanGroupBox(QGroupBox):
        for i in range(self.layout.columnCount()):
            widget = self.layout.itemAtPosition(1, i).widget()
            if isinstance(widget, DeviceLineEdit) and device_object:
-                value = widget.get_device()
+                value = widget.get_current_device().name
            else:
                value = WidgetIO.get_value(widget)
            kwargs[widget.arg_name] = value
--- a/bec_widgets/widgets/signal_combobox/init.py
+++ b/bec_widgets/widgets/signal_combobox/init.py
--- a/bec_widgets/widgets/signal_combobox/register_signal_combobox.py
+++ b/bec_widgets/widgets/signal_combobox/register_signal_combobox.py
@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.signal_combobox.signal_combobox_plugin import SignalComboBoxPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(SignalComboBoxPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/widgets/signal_combobox/signal_combobox.py
+++ b/bec_widgets/widgets/signal_combobox/signal_combobox.py
@@ -0,0 +1,115 @@
+from bec_lib.device import Positioner
+from qtpy.QtCore import QSize, Signal, Slot
+from qtpy.QtWidgets import QComboBox, QSizePolicy
+
+from bec_widgets.utils.filter_io import ComboBoxFilterHandler, FilterIO
+from bec_widgets.utils.ophyd_kind_util import Kind
+from bec_widgets.widgets.base_classes.device_signal_input_base import DeviceSignalInputBase
+
+
+class SignalComboBox(DeviceSignalInputBase, QComboBox):
+    """
+    Line edit widget for device input with autocomplete for device names.
+
+    Args:
+        parent: Parent widget.
+        client: BEC client object.
+        config: Device input configuration.
+        gui_id: GUI ID.
+        device_filter: Device filter, name of the device class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
+        default: Default device name.
+        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
+    """
+
+    ICON_NAME = "list_alt"
+
+    device_signal_changed = Signal(str)
+
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        config: DeviceSignalInputBase = None,
+        gui_id: str | None = None,
+        device: str | None = None,
+        signal_filter: str | list[str] | None = None,
+        default: str | None = None,
+        arg_name: str | None = None,
+    ):
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QComboBox.__init__(self, parent=parent)
+        if arg_name is not None:
+            self.config.arg_name = arg_name
+            self.arg_name = arg_name
+        if default is not None:
+            self.set_device(default)
+
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+        self.setMinimumSize(QSize(100, 0))
+        # We do not consider the config that is passed here, this produced problems
+        # with QtDesigner, since config and input arguments may differ and resolve properly
+        # Implementing this logic and config recoverage is postponed.
+        self.currentTextChanged.connect(self.on_text_changed)
+        if signal_filter is not None:
+            self.set_filter(signal_filter)
+        else:
+            self.set_filter([Kind.hinted, Kind.normal, Kind.config])
+        if device is not None:
+            self.set_device(device)
+        if default is not None:
+            self.set_signal(default)
+
+    def update_signals_from_filters(self):
+        """Update the filters for the combobox"""
+        super().update_signals_from_filters()
+        # pylint: disable=protected-access
+        if FilterIO._find_handler(self) is ComboBoxFilterHandler:
+            if len(self._config_signals) > 0:
+                self.insertItem(
+                    len(self._hinted_signals) + len(self._normal_signals), "Config Signals"
+                )
+                self.model().item(len(self._hinted_signals) + len(self._normal_signals)).setEnabled(
+                    False
+                )
+            if len(self._normal_signals) > 0:
+                self.insertItem(len(self._hinted_signals), "Normal Signals")
+                self.model().item(len(self._hinted_signals)).setEnabled(False)
+            if len(self._hinted_signals) > 0:
+                self.insertItem(0, "Hinted Signals")
+                self.model().item(0).setEnabled(False)
+
+    @Slot(str)
+    def on_text_changed(self, text: str):
+        """Slot for text changed. If a device is selected and the signal is changed and valid it emits a signal.
+        For a positioner, the readback value has to be renamed to the device name.
+
+        Args:
+            text (str): Text in the combobox.
+        """
+        if self.validate_device(self.device) is False:
+            return
+        if self.validate_signal(text) is False:
+            return
+        if text == "readback" and isinstance(self.get_device_object(self.device), Positioner):
+            device_signal = self.device
+        else:
+            device_signal = f"{self.device}_{text}"
+        self.device_signal_changed.emit(device_signal)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # pylint: disable=import-outside-toplevel
+    from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+    from bec_widgets.utils.colors import set_theme
+
+    app = QApplication([])
+    set_theme("dark")
+    widget = QWidget()
+    widget.setFixedSize(200, 200)
+    layout = QVBoxLayout()
+    widget.setLayout(layout)
+    box = SignalComboBox(device="samx")
+    layout.addWidget(box)
+    widget.show()
+    app.exec_()
--- a/bec_widgets/widgets/signal_combobox/signal_combobox.pyproject
+++ b/bec_widgets/widgets/signal_combobox/signal_combobox.pyproject
@@ -0,0 +1 @@
+{'files': ['signal_combobox.py']}
--- a/bec_widgets/widgets/signal_combobox/signal_combobox_plugin.py
+++ b/bec_widgets/widgets/signal_combobox/signal_combobox_plugin.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.signal_combobox.signal_combobox import SignalComboBox
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='SignalComboBox' name='signal_combobox'>
+    </widget>
+</ui>
+"""
+
+
+class SignalComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = SignalComboBox(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Input Widgets"
+
+    def icon(self):
+        return designer_material_icon(SignalComboBox.ICON_NAME)
+
+    def includeFile(self):
+        return "signal_combobox"
+
+    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 "SignalComboBox"
+
+    def toolTip(self):
+        return ""
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/widgets/signal_line_edit/init.py
+++ b/bec_widgets/widgets/signal_line_edit/init.py
--- a/bec_widgets/widgets/signal_line_edit/register_signal_line_edit.py
+++ b/bec_widgets/widgets/signal_line_edit/register_signal_line_edit.py
@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.signal_line_edit.signal_line_edit_plugin import SignalLineEditPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(SignalLineEditPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/widgets/signal_line_edit/signal_line_edit.py
+++ b/bec_widgets/widgets/signal_line_edit/signal_line_edit.py
@@ -0,0 +1,140 @@
+from bec_lib.device import Positioner
+from qtpy.QtCore import QSize, Signal, Slot
+from qtpy.QtGui import QPainter, QPaintEvent, QPen
+from qtpy.QtWidgets import QCompleter, QLineEdit, QSizePolicy
+
+from bec_widgets.utils.colors import get_accent_colors
+from bec_widgets.utils.ophyd_kind_util import Kind
+from bec_widgets.widgets.base_classes.device_signal_input_base import DeviceSignalInputBase
+
+
+class SignalLineEdit(DeviceSignalInputBase, QLineEdit):
+    """
+    Line edit widget for device input with autocomplete for device names.
+
+    Args:
+        parent: Parent widget.
+        client: BEC client object.
+        config: Device input configuration.
+        gui_id: GUI ID.
+        device_filter: Device filter, name of the device class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
+        default: Default device name.
+        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
+    """
+
+    device_signal_changed = Signal(str)
+
+    ICON_NAME = "vital_signs"
+
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        config: DeviceSignalInputBase = None,
+        gui_id: str | None = None,
+        device: str | None = None,
+        signal_filter: str | list[str] | None = None,
+        default: str | None = None,
+        arg_name: str | None = None,
+    ):
+        self._is_valid_input = False
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QLineEdit.__init__(self, parent=parent)
+        self._accent_colors = get_accent_colors()
+        self.completer = QCompleter(self)
+        self.setCompleter(self.completer)
+        if arg_name is not None:
+            self.config.arg_name = arg_name
+            self.arg_name = arg_name
+        if default is not None:
+            self.set_device(default)
+
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+        self.setMinimumSize(QSize(100, 0))
+        # We do not consider the config that is passed here, this produced problems
+        # with QtDesigner, since config and input arguments may differ and resolve properly
+        # Implementing this logic and config recoverage is postponed.
+        if signal_filter is not None:
+            self.set_filter(signal_filter)
+        else:
+            self.set_filter([Kind.hinted, Kind.normal, Kind.config])
+        if device is not None:
+            self.set_device(device)
+        if default is not None:
+            self.set_signal(default)
+        self.textChanged.connect(self.validate_device)
+        self.validate_device(self.text())
+
+    def get_current_device(self) -> object:
+        """
+        Get the current device object based on the current value.
+
+        Returns:
+            object: Device object, can be device of type Device, Positioner, Signal or ComputedSignal.
+        """
+        dev_name = self.text()
+        return self.get_device_object(dev_name)
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        """Extend the paint event to set the border color based on the validity of the input.
+
+        Args:
+            event (PySide6.QtGui.QPaintEvent) : Paint event.
+        """
+        super().paintEvent(event)
+        painter = QPainter(self)
+        pen = QPen()
+        pen.setWidth(2)
+
+        if self._is_valid_input is False and self.isEnabled() is True:
+            pen.setColor(self._accent_colors.emergency)
+            painter.setPen(pen)
+            painter.drawRect(self.rect().adjusted(1, 1, -1, -1))
+
+    @Slot(str)
+    def check_validity(self, input_text: str) -> None:
+        """
+        Check if the current value is a valid device name.
+        """
+        if self.validate_signal(input_text) is True:
+            self._is_valid_input = True
+            self.on_text_changed(input_text)
+        else:
+            self._is_valid_input = False
+        self.update()
+
+    @Slot(str)
+    def on_text_changed(self, text: str):
+        """Slot for text changed. If a device is selected and the signal is changed and valid it emits a signal.
+        For a positioner, the readback value has to be renamed to the device name.
+
+        Args:
+            text (str): Text in the combobox.
+        """
+        print("test")
+        if self.validate_device(self.device) is False:
+            return
+        if self.validate_signal(text) is False:
+            return
+        if text == "readback" and isinstance(self.get_device_object(self.device), Positioner):
+            device_signal = self.device
+        else:
+            device_signal = f"{self.device}_{text}"
+        self.device_signal_changed.emit(device_signal)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # pylint: disable=import-outside-toplevel
+    from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+    from bec_widgets.utils.colors import set_theme
+
+    app = QApplication([])
+    set_theme("dark")
+    widget = QWidget()
+    widget.setFixedSize(200, 200)
+    layout = QVBoxLayout()
+    widget.setLayout(layout)
+    layout.addWidget(SignalLineEdit(device="samx"))
+    widget.show()
+    app.exec_()
--- a/bec_widgets/widgets/signal_line_edit/signal_line_edit.pyproject
+++ b/bec_widgets/widgets/signal_line_edit/signal_line_edit.pyproject
@@ -0,0 +1 @@
+{'files': ['signal_line_edit.py']}
--- a/bec_widgets/widgets/signal_line_edit/signal_line_edit_plugin.py
+++ b/bec_widgets/widgets/signal_line_edit/signal_line_edit_plugin.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.signal_line_edit.signal_line_edit import SignalLineEdit
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='SignalLineEdit' name='signal_line_edit'>
+    </widget>
+</ui>
+"""
+
+
+class SignalLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = SignalLineEdit(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Input Widgets"
+
+    def icon(self):
+        return designer_material_icon(SignalLineEdit.ICON_NAME)
+
+    def includeFile(self):
+        return "signal_line_edit"
+
+    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 "SignalLineEdit"
+
+    def toolTip(self):
+        return ""
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/widgets/waveform/waveform_popups/curve_dialog/curve_dialog.py
+++ b/bec_widgets/widgets/waveform/waveform_popups/curve_dialog/curve_dialog.py
@@ -53,7 +53,7 @@ class CurveSettings(SettingWidget):
        x_entry = self.target_widget.waveform._x_axis_mode["entry"]
        self._enable_ui_elements(x_name, x_entry)
        cm = self.target_widget.config.color_palette
-        self.ui.color_map_selector_scan.combo.setCurrentText(cm)
+        self.ui.color_map_selector_scan.colormap = cm

        # Scan Curve Table
        for source in ["scan_segment", "async"]:
@@ -115,10 +115,10 @@ class CurveSettings(SettingWidget):
    @Slot()
    def change_colormap(self, target: Literal["scan", "dap"]):
        if target == "scan":
-            cm = self.ui.color_map_selector_scan.combo.currentText()
+            cm = self.ui.color_map_selector_scan.colormap
            table = self.ui.scan_table
        if target == "dap":
-            cm = self.ui.color_map_selector_dap.combo.currentText()
+            cm = self.ui.color_map_selector_dap.colormap
            table = self.ui.dap_table
        rows = table.rowCount()
        colors = Colors.golden_angle_color(colormap=cm, num=max(10, rows + 1), format="HEX")
--- a/bec_widgets/widgets/waveform/waveform_popups/curve_dialog/curve_dialog.ui
+++ b/bec_widgets/widgets/waveform/waveform_popups/curve_dialog/curve_dialog.ui
@@ -231,7 +231,14 @@
           </widget>
          </item>
          <item row="0" column="3">
-           <widget class="ColormapSelector" name="color_map_selector_scan"/>
+              <widget class="BECColorMapWidget" name="color_map_selector_scan">
+                  <property name="sizePolicy">
+                      <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+                          <horstretch>0</horstretch>
+                          <verstretch>0</verstretch>
+                      </sizepolicy>
+                  </property>
+              </widget>
          </item>
         </layout>
        </widget>
@@ -330,7 +337,14 @@
           </widget>
          </item>
          <item row="0" column="3">
-           <widget class="ColormapSelector" name="color_map_selector_dap"/>
+              <widget class="BECColorMapWidget" name="color_map_selector_dap">
+                  <property name="sizePolicy">
+                      <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+                          <horstretch>0</horstretch>
+                          <verstretch>0</verstretch>
+                      </sizepolicy>
+                  </property>
+              </widget>
          </item>
         </layout>
        </widget>
@@ -348,9 +362,9 @@
   <header>device_line_edit</header>
  </customwidget>
  <customwidget>
-   <class>ColormapSelector</class>
+      <class>BECColorMapWidget</class>
   <extends>QWidget</extends>
-   <header>colormap_selector</header>
+      <header>bec_color_map_widget</header>
  </customwidget>
 </customwidgets>
 <resources/>
--- a/docs/assets/widget_screenshots/device_inputs.png
+++ b/docs/assets/widget_screenshots/device_inputs.png
--- a/docs/assets/widget_screenshots/signal_inputs.png
+++ b/docs/assets/widget_screenshots/signal_inputs.png
--- a/docs/user/widgets/buttons_appearance/buttons_appearance.md
+++ b/docs/user/widgets/buttons_appearance/buttons_appearance.md
@@ -39,6 +39,17 @@ The `Colormap Selector` is a specialized combobox that allows users to select a
 **Key Features:**
 - **Colormap Selection**: Provides a dropdown to select from all available colormaps in `pyqtgraph`.
 - **Visual Preview**: Displays a small preview of the colormap next to its name, enhancing usability.
+
+## Colormap Button
+
+The `Colormap Button` is a custom widget that displays the current colormap and, upon clicking, shows a nested menu for selecting a different colormap. It integrates the `ColorMapMenu` from `pyqtgraph`, providing an intuitive and interactive way for users to choose colormaps within the GUI.
+
+**Key Features:**
+- **Current Colormap Display**: Shows the name and a gradient icon of the current colormap directly on the button.
+- **Nested Menu Selection**: Offers a nested menu with categorized colormaps, making it easy to find and select the desired colormap.
+- **Signal Emission**: Emits a signal when the colormap changes, providing the new colormap name as a string.
+- **Qt Designer Integration**: Exposes properties and signals to be used within Qt Designer, allowing for customization within the designer interface.
+- **Resizable and Styled**: Features adjustable size policies and styles to match the look and feel of standard `QPushButton` widgets, including rounded edges.
 `````

 ````{tab} Examples
@@ -104,6 +115,33 @@ class MyGui(QWidget):
 my_gui = MyGui()
 my_gui.show()
 ```
+
+## Example 4 - Adding a Colormap Button
+
+```python
+from qtpy.QtWidgets import QWidget, QVBoxLayout
+from bec_widgets.widgets.buttons import ColormapButton
+
+class MyGui(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setLayout(QVBoxLayout(self))
+
+        # Create and add the ColormapButton to the layout
+        self.colormap_button = ColormapButton()
+        self.layout().addWidget(self.colormap_button)
+
+        # Connect the signal to handle colormap changes
+        self.colormap_button.colormap_changed_signal.connect(self.on_colormap_changed)
+
+    def on_colormap_changed(self, colormap_name):
+        print(f"Selected colormap: {colormap_name}")
+
+# Example of how this custom GUI might be used:
+my_gui = MyGui()
+my_gui.show()
+```
+
 ````

 ````{tab} API
--- a/docs/user/widgets/device_input/QProperties_DeviceInput.png
+++ b/docs/user/widgets/device_input/QProperties_DeviceInput.png
--- a/docs/user/widgets/device_input/device_input.md
+++ b/docs/user/widgets/device_input/device_input.md
@@ -13,9 +13,11 @@ The `DeviceLineEdit` widget provides a line edit interface with autocomplete fun
 The `DeviceComboBox` widget offers a dropdown interface for device selection, providing a more visual way to browse through available devices.

 ## Key Features:
- **Device Filtering**: Both widgets allow users to filter devices by their class names, ensuring that only relevant devices are shown.
+- **Device Filtering**: Both widgets allow users to filter devices by device type and readout priority, ensuring that only relevant devices are shown.
 - **Default Device Setting**: Users can set a default device to be pre-selected when the widget is initialized.
+- **Set Device Selection**: Both widgets allow users to set the available devices to be displayed independent of the applied filters. 
 - **Real-Time Autocomplete (LineEdit)**: The `DeviceLineEdit` widget supports real-time autocomplete, helping users find devices faster.
+- **Real-Time Input Validation (LineEdit)**: User input is validated in real-time with a red border around the `DeviceLineEdit` indicating an invalid input. 
 - **Dropdown Selection (ComboBox)**: The `DeviceComboBox` widget displays devices in a dropdown list, making selection straightforward.
 - **QtDesigner Integration**: Both widgets can be added as custom widgets in `QtDesigner` or instantiated directly in code.

@@ -28,11 +30,15 @@ Both `DeviceLineEdit` and `DeviceComboBox` can be integrated within a GUI applic

 ## Example 1 - Creating a DeviceLineEdit in Code

-In this example, we demonstrate how to create a `DeviceLineEdit` widget in code and customize its behavior.
+In this example, we demonstrate how to create a `DeviceLineEdit` widget in code and customize its behavior. 
+We filter down to Positioners with readout_priority Baseline. 
+Note, if we do not specify a device_filter or readout_filter, all enabled devices will be included.

 ```python
 from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
-from bec_widgets.widgets.device_line_edit import DeviceLineEdit
+from bec_widgets.widgets.device_line_edit.device_line_edit import DeviceLineEdit
+from bec_lib.device import ReadoutPriority
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter

 class MyGui(QWidget):
    def __init__(self):
@@ -40,7 +46,7 @@ class MyGui(QWidget):
        self.setLayout(QVBoxLayout(self))  # Initialize the layout for the widget

        # Create and add the DeviceLineEdit to the layout
-        self.device_line_edit = DeviceLineEdit(device_filter="Motor")
+        self.device_line_edit = DeviceLineEdit(device_filter=BECDeviceFilter.POSITIONER, readout_priority_filter=ReadoutPriority.BASELINE)
        self.layout().addWidget(self.device_line_edit)

 # Example of how this custom GUI might be used:
@@ -56,7 +62,9 @@ Similarly, here is an example of creating a `DeviceComboBox` widget in code and

 ```python
 from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
-from bec_widgets.widgets.device_combo_box import DeviceComboBox
+from bec_widgets.widgets.device_combobox.device_combobox import DeviceComboBox
+from bec_lib.device import ReadoutPriority
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter

 class MyGui(QWidget):
    def __init__(self):
@@ -64,8 +72,8 @@ class MyGui(QWidget):
        self.setLayout(QVBoxLayout(self))  # Initialize the layout for the widget

        # Create and add the DeviceComboBox to the layout
-        self.device_combo_box = DeviceComboBox(device_filter="Motor")
-        self.layout().addWidget(self.device_combo_box)
+        self.device_combobox = DeviceComboBox(device_filter=BECDeviceFilter.POSITIONER, readout_priority_filter=ReadoutPriority.BASELINE)
+        self.layout().addWidget(self.device_combobox)

 # Example of how this custom GUI might be used:
 app = QApplication([])
@@ -80,11 +88,24 @@ Both `DeviceLineEdit` and `DeviceComboBox` allow you to set a default device tha

 ```python
 # Set default device for DeviceLineEdit
-self.device_line_edit.set_default_device("motor1")
+self.device_line_edit.set_device("motor1")

 # Set default device for DeviceComboBox
-self.device_combo_box.set_default_device("motor2")
+self.device_combo_box.set_device("motor2")
+
+# Set the available devices to be displayed independent of the applied filters
+self.device_combo_box.set_available_devices(["motor1", "motor2", "motor3"])
 ```
+````
+````{tab} BEC Designer
+Both widgets are also available as plugins for the BEC Designer. We have included Qt properties for both widgets, allowing customization of filtering and default device settings directly from the designer. In addition to the common signals and slots for `DeviceLineEdit` and `DeviceComboBox`, the following slots are available:
+- `set_device(str)` to set the default device
+- `update_devices()` to refresh the devices list
+
+The following Qt properties are also included:
+```{figure} ./QProperties_DeviceInput.png
+```
+
 ````

 ````{tab} API - ComboBox
--- a/docs/user/widgets/signal_input/signal_input.md
+++ b/docs/user/widgets/signal_input/signal_input.md
@@ -0,0 +1,114 @@
+(user.widgets.signal_input)=
+
+# Signal Input Widgets
+
+````{tab} Overview
+The `Signal Input Widgets` consist of two primary widgets: `SignalLineEdit` and `SignalComboBox`. Both widgets are designed to facilitate the selection of the available signals for a selected device within the current BEC session. These widgets allow users to filter, search, and select signals dynamically. The widgets can either be integrated into a GUI through direct code instantiation or by using `QtDesigner`. 
+
+## SignalLineEdit
+The `SignalLineEdit` widget provides a line edit interface with autocomplete functionality for the available of signals associated with the selected device. This widget is ideal for users who prefer to type in the signal name directly. If no device is selected, the autocomplete will be empty. In addition, the widget will display a red border around the line edit if the input signal is invalid.
+
+## SignalComboBox
+The `SignalComboBox` widget offers a dropdown interface for choosing a signal from the available signals of a device. It will further categorise the signals according to its `kind`: `hinted`, `normal` and `config`. For more information about `kind`, please check the [ophyd documentation](https://nsls-ii.github.io/ophyd/signals.html#kind). This widget is ideal for users who prefer to select signals from a list.
+
+## Key Features:
+- **Signal Filtering**: Both widgets allow users to filter devices by signal types(`kind`). No selected filter will show all signals.
+- **Real-Time Autocomplete (LineEdit)**: The `SignalLineEdit` widget supports real-time autocomplete, helping users find devices faster.
+- **Real-Time Input Validation (LineEdit)**: User input is validated in real-time with a red border around the `SignalLineEdit` indicating an invalid input. 
+- **Dropdown Selection (SignalComboBox)**: The `SignalComboBox` widget displays the sorted signals of the device 
+- **QtDesigner Integration**: Both widgets can be added as custom widgets in `QtDesigner` or instantiated directly in code.
+
+````
+
+````{tab} Examples
+
+Both `SignalLineEdit` and `SignalComboBox` can be integrated within a GUI application through direct code instantiation or by using `QtDesigner`. Below are examples demonstrating how to create and use these widgets.
+
+
+## Example 1 - Creating a SignalLineEdit in Code
+
+In this example, we demonstrate how to create a `SignalLineEdit` widget in code and customize its behavior. 
+We will select `samx`, which is a motor in the BEC simulation device config, and filter the signals to `normal` and `hinted`.
+Note, not specifying signal_filter will include all signals.
+
+```python
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+from bec_widgets.widgets.signal_line_edit.signal_line_edit import SignalLineEdit
+from bec_widgets.widgets.base_classes.device_signal_input_base import BECSignalFilter
+
+class MyGui(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setLayout(QVBoxLayout(self))  # Initialize the layout for the widget
+
+        # Create and add the DeviceLineEdit to the layout
+        self.signal_line_edit = SignalLineEdit(device="samx", signal_filter=[BECSignalFilter.NORMAL, BECSignalFilter.HINTED])
+        self.layout().addWidget(self.signal_line_edit)
+
+# Example of how this custom GUI might be used:
+app = QApplication([])
+my_gui = MyGui()
+my_gui.show()
+app.exec_()
+```
+
+## Example 2 - Creating a DeviceComboBox in Code
+
+Similarly, here is an example of creating a `DeviceComboBox` widget in code and customizing its behavior.
+
+```python
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+from bec_widgets.widgets.signal_combobox.signal_combobox import SignalComboBox
+from bec_widgets.widgets.base_classes.device_signal_input_base import BECSignalFilter
+
+class MyGui(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setLayout(QVBoxLayout(self))  # Initialize the layout for the widget
+
+        # Create and add the DeviceLineEdit to the layout
+        self.signal_combobox = SignalComboBox(device="samx", signal_filter=[BECSignalFilter.NORMAL, BECSignalFilter.HINTED])
+        self.layout().addWidget(self.signal_combobox)
+
+# Example of how this custom GUI might be used:
+app = QApplication([])
+my_gui = MyGui()
+my_gui.show()
+app.exec_()
+```
+
+## Example 3 - Setting Default Device
+
+Both `SignalLineEdit` and `SignalComboBox` allow you to set a default device that will be selected when the widget is initialized.
+
+```python
+# Set default device for DeviceLineEdit
+self.signal_line_edit.set_device("motor1")
+
+# Set default device for DeviceComboBox
+self.signal_combobox.set_device("motor2")
+```
+````
+````{tab} BEC Designer
+Both widgets are also available as plugins for the BEC Designer. We have included Qt properties for both widgets, allowing customization of filtering and default device settings directly from the designer. In addition to the common signals and slots for `SignalLineEdit` and `SignalComboBox`, the following slots are available:
+- `set_device(str)` to set the default device
+- `set_signal(str)` to set the default signal
+- `update_signals_from_filters()` to refresh the devices list based on the current filters
+
+The following Qt properties are also included:
+```{figure} ./signal_input_qproperties.png
+```
+
+````
+
+````{tab} API - ComboBox
+```{eval-rst} 
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.SignalComboBox.rst
+```
+````
+
+````{tab} API - LineEdit
+```{eval-rst}
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.SignalLineEdit.rst
+```
+````
--- a/docs/user/widgets/signal_input/signal_input_qproperties.png
+++ b/docs/user/widgets/signal_input/signal_input_qproperties.png
--- a/docs/user/widgets/text_box/text_box.md
+++ b/docs/user/widgets/text_box/text_box.md
@@ -29,16 +29,16 @@ In this example, we demonstrate how to add a `TextBox` widget to a `BECDockArea`
 text_box = gui.add_dock().add_widget("TextBox")

 # Set the text to display
-text_box.set_text("Hello, World!")
+text_box.set_plain_text("Hello, World!")
 ```

 ## Example 2 - Displaying HTML Content

-The `TextBox` widget can automatically detect and render HTML content. This example shows how to display formatted HTML text.
+The `TextBox` widget can also render HTML content. This example shows how to display formatted HTML text.

 ```python
 # Set the text to display as HTML
-text_box.set_text("<h1>Welcome to BEC Widgets</h1><p>This is an example of displaying <strong>HTML</strong> text.</p>")
+text_box.set_html_text("<h1>Welcome to BEC Widgets</h1><p>This is an example of displaying <strong>HTML</strong> text.</p>")
 ```

 ````
--- a/docs/user/widgets/widgets.md
+++ b/docs/user/widgets/widgets.md
@@ -159,6 +159,14 @@ Various buttons which manage the control of the BEC Queue.
 Choose individual device from current session.
 ```

+```{grid-item-card} Signal Input Widgets
+:link: user.widgets.signal_input
+:link-type: ref
+:img-top: /assets/widget_screenshots/signal_inputs.png
+
+Choose individual signals available for a selected device.
+```
+
 ```{grid-item-card} Text Box Widget
 :link: user.widgets.text_box
 :link-type: ref
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"

 [project]
 name = "bec_widgets"
-version = "1.0.2"
+version = "1.4.0"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -38,7 +38,7 @@ dev = [
    "pytest~=8.0",
 ]
 pyqt6 = ["PyQt6>=6.7", "PyQt6-WebEngine>=6.7"]
-pyside6 = ["PySide6~=6.7.2"]
+pyside6 = ["PySide6==6.7.2"]

 [project.urls]
 "Bug Tracker" = "https://gitlab.psi.ch/bec/bec_widgets/issues"
--- a/tests/end-2-end/test_bec_dock_rpc_e2e.py
+++ b/tests/end-2-end/test_bec_dock_rpc_e2e.py
@@ -170,12 +170,17 @@ def test_ring_bar(rpc_server_dock):

    bar_config = bar._config_dict

-    expected_colors = [list(color) for color in Colors.golden_angle_color("viridis", 5, "RGB")]
+    expected_colors_light = [
+        list(color) for color in Colors.golden_angle_color("viridis", 5, "RGB", theme="light")
+    ]
+    expected_colors_dark = [
+        list(color) for color in Colors.golden_angle_color("viridis", 5, "RGB", theme="dark")
+    ]
    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
+    assert bar_colors == expected_colors_light or bar_colors == expected_colors_dark


 def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
--- a/tests/unit_tests/client_mocks.py
+++ b/tests/unit_tests/client_mocks.py
@@ -3,147 +3,9 @@ from unittest.mock import MagicMock, patch

 import fakeredis
 import pytest
-from bec_lib.client import BECClient
-from bec_lib.device import Positioner, ReadoutPriority
-from bec_lib.devicemanager import DeviceContainer
 from bec_lib.redis_connector import RedisConnector

-
-class FakeDevice:
-    """Fake minimal positioner class for testing."""
-
-    def __init__(self, name, enabled=True, readout_priority=ReadoutPriority.MONITORED):
-        self.name = name
-        self.enabled = enabled
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
-        self.readout_priority = readout_priority
-        self._config = {
-            "readoutPriority": "baseline",
-            "deviceClass": "ophyd_devices.SimPositioner",
-            "deviceConfig": {
-                "delay": 1,
-                "limits": [-50, 50],
-                "tolerance": 0.01,
-                "update_frequency": 400,
-            },
-            "deviceTags": ["user motors"],
-            "enabled": enabled,
-            "readOnly": False,
-            "name": self.name,
-        }
-
-    def __contains__(self, item):
-        return item == self.name
-
-    @property
-    def _hints(self):
-        return [self.name]
-
-    def set_value(self, fake_value: float = 1.0) -> None:
-        """
-        Setup fake value for device readout
-        Args:
-            fake_value(float): Desired fake value
-        """
-        self.signals[self.name]["value"] = fake_value
-
-    def describe(self) -> dict:
-        """
-        Get the description of the device
-        Returns:
-            dict: Description of the device
-        """
-        return self.description
-
-
-class FakePositioner(FakeDevice):
-    def __init__(
-        self,
-        name,
-        enabled=True,
-        limits=None,
-        read_value=1.0,
-        readout_priority=ReadoutPriority.MONITORED,
-    ):
-        super().__init__(name, enabled, readout_priority)
-        self.limits = limits if limits is not None else [0, 0]
-        self.read_value = read_value
-        self.name = name
-
-    @property
-    def precision(self):
-        return 3
-
-    def set_read_value(self, value):
-        self.read_value = value
-
-    def read(self):
-        return {
-            self.name: {"value": self.read_value},
-            f"{self.name}_setpoint": {"value": self.read_value},
-            f"{self.name}_motor_is_moving": {"value": 0},
-        }
-
-    def set_limits(self, limits):
-        self.limits = limits
-
-    def move(self, value, relative=False):
-        """Simulates moving the device to a new position."""
-        if relative:
-            self.read_value += value
-        else:
-            self.read_value = value
-        # Respect the limits
-        self.read_value = max(min(self.read_value, self.limits[1]), self.limits[0])
-
-    @property
-    def readback(self):
-        return MagicMock(get=MagicMock(return_value=self.read_value))
-
-
-class Positioner(FakePositioner):
-    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
-
-    def __init__(self, name="test", limits=None, read_value=1.0):
-        super().__init__(name, limits, read_value)
-
-
-class Device(FakeDevice):
-    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
-
-    def __init__(self, name, enabled=True):
-        super().__init__(name, enabled)
-
-
-class DMMock:
-    def __init__(self):
-        self.devices = DeviceContainer()
-
-    def add_devives(self, devices: list):
-        for device in devices:
-            self.devices[device.name] = device
-
-
-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"),
-    FakeDevice("gauss_adc1"),
-    FakeDevice("gauss_adc2"),
-    FakeDevice("gauss_adc3"),
-    FakeDevice("bpm4i"),
-    FakeDevice("bpm3a"),
-    FakeDevice("bpm3i"),
-    FakeDevice("eiger"),
-    FakeDevice("waveform1d"),
-    FakeDevice("async_device", readout_priority=ReadoutPriority.ASYNC),
-    Positioner("test", limits=[-10, 10], read_value=2.0),
-    Device("test_device"),
-]
+from bec_widgets.tests.utils import DEVICES, DMMock, FakePositioner, Positioner


 def fake_redis_server(host, port):
--- a/tests/unit_tests/test_bec_image_widget.py
+++ b/tests/unit_tests/test_bec_image_widget.py
@@ -3,6 +3,7 @@ from unittest.mock import MagicMock, patch
 import pyqtgraph as pg
 import pytest

+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.image.image_widget import BECImageWidget

 from .client_mocks import mocked_client
@@ -11,7 +12,6 @@ from .client_mocks import mocked_client
@pytest.fixture
 def image_widget(qtbot, mocked_client):
    widget = BECImageWidget(client=mocked_client())
-    widget.toolbar.widgets["monitor"].device_combobox.set_device_filter("FakeDevice")
    qtbot.addWidget(widget)
    qtbot.waitExposed(widget)
    yield widget
@@ -32,7 +32,8 @@ def test_image_widget_init(image_widget):
    assert image_widget._image is not None

    assert (
-        image_widget.toolbar.widgets["monitor"].device_combobox.config.device_filter == "FakeDevice"
+        BECDeviceFilter.DEVICE
+        in image_widget.toolbar.widgets["monitor"].device_combobox.config.device_filter
    )
    assert image_widget.toolbar.widgets["drag_mode"].action.isChecked() == True
    assert image_widget.toolbar.widgets["rectangle_mode"].action.isChecked() == False
--- a/tests/unit_tests/test_client_utils.py
+++ b/tests/unit_tests/test_client_utils.py
@@ -4,8 +4,7 @@ import pytest

 from bec_widgets.cli.client import BECFigure
 from bec_widgets.cli.client_utils import BECGuiClientMixin, _start_plot_process
-
-from .client_mocks import FakeDevice
+from bec_widgets.tests.utils import FakeDevice


@pytest.fixture
--- a/tests/unit_tests/test_color_validation.py
+++ b/tests/unit_tests/test_color_validation.py
@@ -1,5 +1,6 @@
 import pytest
 from pydantic import ValidationError
+from qtpy.QtGui import QColor

 from bec_widgets.utils import Colors
 from bec_widgets.widgets.figure.plots.waveform.waveform_curve import CurveConfig
@@ -73,3 +74,39 @@ 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"
+
+
+@pytest.mark.parametrize("num", [10, 100, 400])
+def test_evenly_spaced_colors(num):
+    colors_qcolor = Colors.evenly_spaced_colors(colormap="magma", num=num, format="QColor")
+    colors_hex = Colors.evenly_spaced_colors(colormap="magma", num=num, format="HEX")
+    colors_rgb = Colors.evenly_spaced_colors(colormap="magma", num=num, format="RGB")
+
+    assert len(colors_qcolor) == num
+    assert len(colors_hex) == num
+    assert len(colors_rgb) == num
+
+    assert all(isinstance(color, QColor) for color in colors_qcolor)
+    assert all(isinstance(color, str) for color in colors_hex)
+    assert all(isinstance(color, tuple) for color in colors_rgb)
+
+    assert all(color.isValid() for color in colors_qcolor)
+    assert all(color.startswith("#") for color in colors_hex)
+
+
+@pytest.mark.parametrize("num", [10, 100, 400])
+def test_golder_angle_colors(num):
+    colors_qcolor = Colors.golden_angle_color(colormap="magma", num=num, format="QColor")
+    colors_hex = Colors.golden_angle_color(colormap="magma", num=num, format="HEX")
+    colors_rgb = Colors.golden_angle_color(colormap="magma", num=num, format="RGB")
+
+    assert len(colors_qcolor) == num
+    assert len(colors_hex) == num
+    assert len(colors_rgb) == num
+
+    assert all(isinstance(color, QColor) for color in colors_qcolor)
+    assert all(isinstance(color, str) for color in colors_hex)
+    assert all(isinstance(color, tuple) for color in colors_rgb)
+
+    assert all(color.isValid() for color in colors_qcolor)
+    assert all(color.startswith("#") for color in colors_hex)
--- a/tests/unit_tests/test_colormap_widget.py
+++ b/tests/unit_tests/test_colormap_widget.py
@@ -0,0 +1,69 @@
+import pytest
+from pyqtgraph.widgets.ColorMapButton import ColorMapButton
+
+from bec_widgets.widgets.colormap_widget.colormap_widget import BECColorMapWidget
+
+
+@pytest.fixture
+def color_map_widget(qtbot):
+    widget = BECColorMapWidget()
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_color_map_widget_init(color_map_widget):
+    """Test that the widget initializes correctly."""
+    assert color_map_widget is not None
+    assert isinstance(color_map_widget, BECColorMapWidget)
+    assert color_map_widget.colormap == "magma"
+    assert isinstance(color_map_widget.button, ColorMapButton)
+    # Check that the button has the correct initial colormap
+    assert color_map_widget.button.colorMap().name == "magma"
+
+
+def test_color_map_widget_set_valid_colormap(color_map_widget):
+    """
+    Test setting a valid colormap.
+    """
+    new_cmap = "viridis"
+    color_map_widget.colormap = new_cmap
+    assert color_map_widget.colormap == new_cmap
+    assert color_map_widget.button.colorMap().name == new_cmap
+
+
+def test_color_map_widget_set_invalid_colormap(color_map_widget):
+    """Test setting an invalid colormap."""
+    invalid_cmap = "invalid_colormap_name"
+    old_cmap = color_map_widget.colormap
+    color_map_widget.colormap = invalid_cmap
+    # Since invalid, the colormap should not change
+    assert color_map_widget.colormap == old_cmap
+    assert color_map_widget.button.colorMap().name == old_cmap
+
+
+def test_color_map_widget_signal_emitted(color_map_widget, qtbot):
+    """Test that the signal is emitted when the colormap changes."""
+    new_cmap = "plasma"
+    with qtbot.waitSignal(color_map_widget.colormap_changed_signal, timeout=1000) as blocker:
+        color_map_widget.colormap = new_cmap
+    assert blocker.signal_triggered
+    assert blocker.args == [new_cmap]
+    assert color_map_widget.colormap == new_cmap
+
+
+def test_color_map_widget_signal_not_emitted_for_invalid_colormap(color_map_widget, qtbot):
+    """Test that the signal is not emitted when an invalid colormap is set."""
+    invalid_cmap = "invalid_colormap_name"
+    with qtbot.assertNotEmitted(color_map_widget.colormap_changed_signal):
+        color_map_widget.colormap = invalid_cmap
+    # The colormap should remain unchanged
+    assert color_map_widget.colormap == "magma"
+
+
+def test_color_map_widget_resize(color_map_widget):
+    """Test that the widget resizes properly."""
+    width, height = 200, 50
+    color_map_widget.resize(width, height)
+    assert color_map_widget.width() == width
+    assert color_map_widget.height() == height
--- a/tests/unit_tests/test_crosshair.py
+++ b/tests/unit_tests/test_crosshair.py
@@ -1,7 +1,7 @@
-# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import numpy as np
+import pyqtgraph as pg
 import pytest
-from qtpy.QtCore import QPointF
+from qtpy.QtCore import QPointF, Qt

 from bec_widgets.widgets.image.image_widget import BECImageWidget
 from bec_widgets.widgets.waveform.waveform_widget import BECWaveformWidget
@@ -36,10 +36,6 @@ def image_widget_with_crosshair(qtbot, mocked_client):
 def test_mouse_moved_lines(plot_widget_with_crosshair):
    crosshair, plot_item = plot_widget_with_crosshair

-    # Connect the signals to slots that will store the emitted values
-    emitted_values_1D = []
-    crosshair.coordinatesChanged1D.connect(emitted_values_1D.append)
-
    # Simulate a mouse moved event at a specific position
    pos_in_view = QPointF(2, 5)
    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
@@ -56,21 +52,17 @@ def test_mouse_moved_lines(plot_widget_with_crosshair):
 def test_mouse_moved_signals(plot_widget_with_crosshair):
    crosshair, plot_item = plot_widget_with_crosshair

-    # Create a slot that will store the emitted values as tuples
    emitted_values_1D = []

    def slot(coordinates):
        emitted_values_1D.append(coordinates)

-    # Connect the signal to the custom slot
    crosshair.coordinatesChanged1D.connect(slot)

-    # Simulate a mouse moved event at a specific position
    pos_in_view = QPointF(2, 5)
    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
    event_mock = [pos_in_scene]

-    # Call the mouse_moved method
    crosshair.mouse_moved(event_mock)

    # Assert the expected behavior
@@ -83,8 +75,8 @@ def test_mouse_moved_signals_outside(plot_widget_with_crosshair):
    # Create a slot that will store the emitted values as tuples
    emitted_values_1D = []

-    def slot(x, y_values):
-        emitted_values_1D.append((x, y_values))
+    def slot(coordinates):
+        emitted_values_1D.append(coordinates)

    # Connect the signal to the custom slot
    crosshair.coordinatesChanged1D.connect(slot)
@@ -104,40 +96,132 @@ def test_mouse_moved_signals_outside(plot_widget_with_crosshair):
 def test_mouse_moved_signals_2D(image_widget_with_crosshair):
    crosshair, plot_item = image_widget_with_crosshair

-    # Create a slot that will store the emitted values as tuples
    emitted_values_2D = []

    def slot(coordinates):
        emitted_values_2D.append(coordinates)

-    # Connect the signal to the custom slot
    crosshair.coordinatesChanged2D.connect(slot)
-    # Simulate a mouse moved event at a specific position
+
    pos_in_view = QPointF(22.0, 55.0)
    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
    event_mock = [pos_in_scene]
-    # Call the mouse_moved method
+
    crosshair.mouse_moved(event_mock)
-    # Assert the expected behavior
+
    assert emitted_values_2D == [("test", 22.0, 55.0)]


 def test_mouse_moved_signals_2D_outside(image_widget_with_crosshair):
    crosshair, plot_item = image_widget_with_crosshair

-    # Create a slot that will store the emitted values as tuples
    emitted_values_2D = []

-    def slot(x, y):
-        emitted_values_2D.append((x, y))
+    def slot(coordinates):
+        emitted_values_2D.append(coordinates)

-    # Connect the signal to the custom slot
    crosshair.coordinatesChanged2D.connect(slot)
-    # Simulate a mouse moved event at a specific position
+
    pos_in_view = QPointF(220.0, 555.0)
    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
    event_mock = [pos_in_scene]
-    # Call the mouse_moved method
+
    crosshair.mouse_moved(event_mock)
-    # Assert the expected behavior
+
    assert emitted_values_2D == []
+
+
+def test_marker_positions_after_mouse_move(plot_widget_with_crosshair):
+    crosshair, plot_item = plot_widget_with_crosshair
+
+    pos_in_view = QPointF(2, 5)
+    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
+
+    crosshair.mouse_moved(event_mock)
+
+    marker = crosshair.marker_moved_1d["Curve 1"]
+    marker_x, marker_y = marker.getData()
+    assert marker_x == [2]
+    assert marker_y == [5]
+
+
+def test_scale_emitted_coordinates(plot_widget_with_crosshair):
+    crosshair, _ = plot_widget_with_crosshair
+
+    x, y = crosshair.scale_emitted_coordinates(2, 5)
+    assert x == 2
+    assert y == 5
+
+    crosshair.is_log_x = True
+    crosshair.is_log_y = True
+
+    x, y = crosshair.scale_emitted_coordinates(np.log10(2), np.log10(5))
+    assert np.isclose(x, 2)
+    assert np.isclose(y, 5)
+
+
+def test_crosshair_changed_signal(plot_widget_with_crosshair):
+    crosshair, plot_item = plot_widget_with_crosshair
+
+    emitted_positions = []
+
+    def slot(position):
+        emitted_positions.append(position)
+
+    crosshair.crosshairChanged.connect(slot)
+
+    pos_in_view = QPointF(2, 5)
+    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
+
+    crosshair.mouse_moved(event_mock)
+
+    x, y = emitted_positions[0]
+
+    assert np.isclose(x, 2)
+    assert np.isclose(y, 5)
+
+
+def test_marker_positions_after_mouse_move(plot_widget_with_crosshair):
+    crosshair, plot_item = plot_widget_with_crosshair
+
+    pos_in_view = QPointF(2, 5)
+    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
+
+    crosshair.mouse_moved(event_mock)
+
+    marker = crosshair.marker_moved_1d["Curve 1"]
+    marker_x, marker_y = marker.getData()
+    assert marker_x == [2]
+    assert marker_y == [5]
+
+
+def test_crosshair_clicked_signal(qtbot, plot_widget_with_crosshair):
+    crosshair, plot_item = plot_widget_with_crosshair
+
+    emitted_positions = []
+
+    def slot(position):
+        emitted_positions.append(position)
+
+    crosshair.crosshairClicked.connect(slot)
+
+    x_data = 2
+    y_data = 5
+
+    # Map data coordinates to scene coordinates
+    pos_in_scene = plot_item.vb.mapViewToScene(QPointF(x_data, y_data))
+    # Map scene coordinates to widget coordinates
+    graphics_view = plot_item.vb.scene().views()[0]
+    qtbot.waitExposed(graphics_view)
+    pos_in_widget = graphics_view.mapFromScene(pos_in_scene)
+
+    # Simulate mouse click
+    qtbot.mouseClick(graphics_view.viewport(), Qt.LeftButton, pos=pos_in_widget)
+
+    x, y = emitted_positions[0]
+
+    assert np.isclose(round(x, 1), 2)
+    assert np.isclose(round(y, 1), 5)
--- a/tests/unit_tests/test_device_input_base.py
+++ b/tests/unit_tests/test_device_input_base.py
@@ -1,13 +1,20 @@
+from unittest import mock
+
 import pytest
+from bec_lib.device import ReadoutPriority
 from qtpy.QtWidgets import QWidget

-from bec_widgets.widgets.base_classes.device_input_base import DeviceInputBase
+from bec_widgets.tests.utils import FakePositioner
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter, DeviceInputBase

 from .client_mocks import mocked_client
+from .conftest import create_widget


 # DeviceInputBase is meant to be mixed in a QWidget
 class DeviceInputWidget(DeviceInputBase, QWidget):
+    """Thin wrapper around DeviceInputBase to make it a QWidget"""
+
    def __init__(self, parent=None, client=None, config=None, gui_id=None):
        super().__init__(client=client, config=config, gui_id=gui_id)
        QWidget.__init__(self, parent=parent)
@@ -15,62 +22,113 @@ class DeviceInputWidget(DeviceInputBase, QWidget):

@pytest.fixture
 def device_input_base(qtbot, mocked_client):
-    widget = DeviceInputWidget(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
+    """Fixture with mocked FilterIO and WidgetIO"""
+    with mock.patch("bec_widgets.utils.filter_io.FilterIO.set_selection"):
+        with mock.patch("bec_widgets.utils.widget_io.WidgetIO.set_value"):
+            with mock.patch("bec_widgets.utils.widget_io.WidgetIO.get_value"):
+                widget = create_widget(qtbot=qtbot, widget=DeviceInputWidget, client=mocked_client)
+                yield widget


 def test_device_input_base_init(device_input_base):
+    """Test init"""
    assert device_input_base is not None
    assert device_input_base.client is not None
    assert isinstance(device_input_base, DeviceInputBase)
    assert device_input_base.config.widget_class == "DeviceInputWidget"
-    assert device_input_base.config.device_filter is None
+    assert device_input_base.config.device_filter == []
    assert device_input_base.config.default is None
    assert device_input_base.devices == []


 def test_device_input_base_init_with_config(mocked_client):
+    """Test init with Config"""
    config = {
        "widget_class": "DeviceInputWidget",
        "gui_id": "test_gui_id",
-        "device_filter": "FakePositioner",
+        "device_filter": [BECDeviceFilter.POSITIONER],
        "default": "samx",
    }
    widget = DeviceInputWidget(client=mocked_client, config=config)
    assert widget.config.gui_id == "test_gui_id"
-    assert widget.config.device_filter == "FakePositioner"
+    assert widget.config.device_filter == [BECDeviceFilter.POSITIONER]
    assert widget.config.default == "samx"


 def test_device_input_base_set_device_filter(device_input_base):
-    device_input_base.set_device_filter("FakePositioner")
-    assert device_input_base.config.device_filter == "FakePositioner"
+    """Test device filter setter."""
+    device_input_base.set_device_filter(BECDeviceFilter.POSITIONER)
+    assert device_input_base.config.device_filter == [BECDeviceFilter.POSITIONER]


 def test_device_input_base_set_device_filter_error(device_input_base):
-    with pytest.raises(ValueError) as excinfo:
-        device_input_base.set_device_filter("NonExistingClass")
-        assert "Device filter NonExistingClass is not in the device list." in str(excinfo.value)
+    """Test set_device_filter with Noneexisting class. This should not raise. It writes a log message entry."""
+    device_input_base.set_device_filter("NonExistingClass")
+    assert device_input_base.device_filter == []


 def test_device_input_base_set_default_device(device_input_base):
-    device_input_base.set_default_device("samx")
+    """Test setting the default device. Also tests the update_devices method."""
+    device_input_base.set_device("samx")
+    assert device_input_base.config.default == None
+    device_input_base.set_device_filter(BECDeviceFilter.POSITIONER)
+    device_input_base.set_readout_priority_filter(ReadoutPriority.MONITORED)
+    device_input_base.set_device("samx")
    assert device_input_base.config.default == "samx"


-def test_device_input_base_set_default_device_error(device_input_base):
-    with pytest.raises(ValueError) as excinfo:
-        device_input_base.set_default_device("NonExistingDevice")
-        assert "Default device NonExistingDevice is not in the device list." in str(excinfo.value)
-
-
-def test_device_input_base_get_device_list(device_input_base):
-    devices = device_input_base.get_device_list("FakePositioner")
-    assert devices == ["samx", "samy", "samz", "aptrx", "aptry"]
-
-
 def test_device_input_base_get_filters(device_input_base):
+    """Test getting the available filters."""
    filters = device_input_base.get_available_filters()
-    assert filters == {"FakePositioner", "FakeDevice", "Positioner", "Device"}
+    selection = [
+        BECDeviceFilter.POSITIONER,
+        BECDeviceFilter.DEVICE,
+        BECDeviceFilter.COMPUTED_SIGNAL,
+        BECDeviceFilter.SIGNAL,
+    ] + [
+        ReadoutPriority.MONITORED,
+        ReadoutPriority.BASELINE,
+        ReadoutPriority.ASYNC,
+        ReadoutPriority.ON_REQUEST,
+    ]
+    assert [entry for entry in filters if entry in selection]
+
+
+def test_device_input_base_properties(device_input_base):
+    """Test setting the properties of the device input base."""
+    assert device_input_base.device_filter == []
+    device_input_base.filter_to_device = True
+    assert device_input_base.device_filter == [BECDeviceFilter.DEVICE]
+    device_input_base.filter_to_positioner = True
+    assert device_input_base.device_filter == [BECDeviceFilter.DEVICE, BECDeviceFilter.POSITIONER]
+    device_input_base.filter_to_computed_signal = True
+    assert device_input_base.device_filter == [
+        BECDeviceFilter.DEVICE,
+        BECDeviceFilter.POSITIONER,
+        BECDeviceFilter.COMPUTED_SIGNAL,
+    ]
+    device_input_base.filter_to_signal = True
+    assert device_input_base.device_filter == [
+        BECDeviceFilter.DEVICE,
+        BECDeviceFilter.POSITIONER,
+        BECDeviceFilter.COMPUTED_SIGNAL,
+        BECDeviceFilter.SIGNAL,
+    ]
+    assert device_input_base.readout_filter == []
+    device_input_base.readout_async = True
+    assert device_input_base.readout_filter == [ReadoutPriority.ASYNC]
+    device_input_base.readout_baseline = True
+    assert device_input_base.readout_filter == [ReadoutPriority.ASYNC, ReadoutPriority.BASELINE]
+    device_input_base.readout_monitored = True
+    assert device_input_base.readout_filter == [
+        ReadoutPriority.ASYNC,
+        ReadoutPriority.BASELINE,
+        ReadoutPriority.MONITORED,
+    ]
+    device_input_base.readout_on_request = True
+    assert device_input_base.readout_filter == [
+        ReadoutPriority.ASYNC,
+        ReadoutPriority.BASELINE,
+        ReadoutPriority.MONITORED,
+        ReadoutPriority.ON_REQUEST,
+    ]
--- a/tests/unit_tests/test_device_input_widgets.py
+++ b/tests/unit_tests/test_device_input_widgets.py
@@ -1,5 +1,7 @@
 import pytest
+from bec_lib.device import ReadoutPriority

+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.device_line_edit.device_line_edit import DeviceLineEdit

@@ -14,27 +16,12 @@ def device_input_combobox(qtbot, mocked_client):
    yield widget


-@pytest.fixture
-def device_input_combobox_with_config(qtbot, mocked_client):
-    config = {
-        "widget_class": "DeviceComboBox",
-        "gui_id": "test_gui_id",
-        "device_filter": "FakePositioner",
-        "default": "samx",
-        "arg_name": "test_arg_name",
-    }
-    widget = DeviceComboBox(client=mocked_client, config=config)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
@pytest.fixture
 def device_input_combobox_with_kwargs(qtbot, mocked_client):
    widget = DeviceComboBox(
        client=mocked_client,
        gui_id="test_gui_id",
-        device_filter="FakePositioner",
+        device_filter=[BECDeviceFilter.POSITIONER],
        default="samx",
        arg_name="test_arg_name",
    )
@@ -48,8 +35,6 @@ def test_device_input_combobox_init(device_input_combobox):
    assert device_input_combobox.client is not None
    assert isinstance(device_input_combobox, DeviceComboBox)
    assert device_input_combobox.config.widget_class == "DeviceComboBox"
-    assert device_input_combobox.config.device_filter is None
-    assert device_input_combobox.config.default is None
    assert device_input_combobox.devices == [
        "samx",
        "samy",
@@ -71,16 +56,9 @@ def test_device_input_combobox_init(device_input_combobox):
    ]


-def test_device_input_combobox_init_with_config(device_input_combobox_with_config):
-    assert device_input_combobox_with_config.config.gui_id == "test_gui_id"
-    assert device_input_combobox_with_config.config.device_filter == "FakePositioner"
-    assert device_input_combobox_with_config.config.default == "samx"
-    assert device_input_combobox_with_config.config.arg_name == "test_arg_name"
-
-
 def test_device_input_combobox_init_with_kwargs(device_input_combobox_with_kwargs):
    assert device_input_combobox_with_kwargs.config.gui_id == "test_gui_id"
-    assert device_input_combobox_with_kwargs.config.device_filter == "FakePositioner"
+    assert device_input_combobox_with_kwargs.config.device_filter == [BECDeviceFilter.POSITIONER]
    assert device_input_combobox_with_kwargs.config.default == "samx"
    assert device_input_combobox_with_kwargs.config.arg_name == "test_arg_name"

@@ -88,7 +66,7 @@ def test_device_input_combobox_init_with_kwargs(device_input_combobox_with_kwarg
 def test_get_device_from_input_combobox_init(device_input_combobox):
    device_input_combobox.setCurrentIndex(0)
    device_text = device_input_combobox.currentText()
-    current_device = device_input_combobox.get_device()
+    current_device = device_input_combobox.get_current_device()

    assert current_device.name == device_text

@@ -101,27 +79,12 @@ def device_input_line_edit(qtbot, mocked_client):
    yield widget


-@pytest.fixture
-def device_input_line_edit_with_config(qtbot, mocked_client):
-    config = {
-        "widget_class": "DeviceLineEdit",
-        "gui_id": "test_gui_id",
-        "device_filter": "FakePositioner",
-        "default": "samx",
-        "arg_name": "test_arg_name",
-    }
-    widget = DeviceLineEdit(client=mocked_client, config=config)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
@pytest.fixture
 def device_input_line_edit_with_kwargs(qtbot, mocked_client):
    widget = DeviceLineEdit(
        client=mocked_client,
        gui_id="test_gui_id",
-        device_filter="FakePositioner",
+        device_filter=[BECDeviceFilter.POSITIONER],
        default="samx",
        arg_name="test_arg_name",
    )
@@ -135,7 +98,14 @@ def test_device_input_line_edit_init(device_input_line_edit):
    assert device_input_line_edit.client is not None
    assert isinstance(device_input_line_edit, DeviceLineEdit)
    assert device_input_line_edit.config.widget_class == "DeviceLineEdit"
-    assert device_input_line_edit.config.device_filter is None
+    assert device_input_line_edit.config.device_filter == []
+    assert device_input_line_edit.config.readout_filter == [
+        ReadoutPriority.MONITORED,
+        ReadoutPriority.BASELINE,
+        ReadoutPriority.ASYNC,
+        ReadoutPriority.CONTINUOUS,
+        ReadoutPriority.ON_REQUEST,
+    ]
    assert device_input_line_edit.config.default is None
    assert device_input_line_edit.devices == [
        "samx",
@@ -158,16 +128,9 @@ def test_device_input_line_edit_init(device_input_line_edit):
    ]


-def test_device_input_line_edit_init_with_config(device_input_line_edit_with_config):
-    assert device_input_line_edit_with_config.config.gui_id == "test_gui_id"
-    assert device_input_line_edit_with_config.config.device_filter == "FakePositioner"
-    assert device_input_line_edit_with_config.config.default == "samx"
-    assert device_input_line_edit_with_config.config.arg_name == "test_arg_name"
-
-
 def test_device_input_line_edit_init_with_kwargs(device_input_line_edit_with_kwargs):
    assert device_input_line_edit_with_kwargs.config.gui_id == "test_gui_id"
-    assert device_input_line_edit_with_kwargs.config.device_filter == "FakePositioner"
+    assert device_input_line_edit_with_kwargs.config.device_filter == [BECDeviceFilter.POSITIONER]
    assert device_input_line_edit_with_kwargs.config.default == "samx"
    assert device_input_line_edit_with_kwargs.config.arg_name == "test_arg_name"

@@ -175,6 +138,6 @@ def test_device_input_line_edit_init_with_kwargs(device_input_line_edit_with_kwa
 def test_get_device_from_input_line_edit_init(device_input_line_edit):
    device_input_line_edit.setText("samx")
    device_text = device_input_line_edit.text()
-    current_device = device_input_line_edit.get_device()
+    current_device = device_input_line_edit.get_current_device()

    assert current_device.name == device_text
--- a/tests/unit_tests/test_device_signal_input.py
+++ b/tests/unit_tests/test_device_signal_input.py
@@ -0,0 +1,121 @@
+from unittest import mock
+
+import pytest
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils.ophyd_kind_util import Kind
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
+from bec_widgets.widgets.base_classes.device_signal_input_base import DeviceSignalInputBase
+from bec_widgets.widgets.device_combobox.device_combobox import DeviceComboBox
+from bec_widgets.widgets.signal_combobox.signal_combobox import SignalComboBox
+from bec_widgets.widgets.signal_line_edit.signal_line_edit import SignalLineEdit
+
+from .client_mocks import mocked_client
+from .conftest import create_widget
+
+
+class DeviceInputWidget(DeviceSignalInputBase, QWidget):
+    """Thin wrapper around DeviceInputBase to make it a QWidget"""
+
+    def __init__(self, parent=None, client=None, config=None, gui_id=None):
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QWidget.__init__(self, parent=parent)
+
+
+@pytest.fixture
+def device_signal_base(qtbot, mocked_client):
+    """Fixture with mocked FilterIO and WidgetIO"""
+    with mock.patch("bec_widgets.utils.filter_io.FilterIO.set_selection"):
+        with mock.patch("bec_widgets.utils.widget_io.WidgetIO.set_value"):
+            widget = create_widget(qtbot=qtbot, widget=DeviceInputWidget, client=mocked_client)
+            yield widget
+
+
+@pytest.fixture
+def device_signal_combobox(qtbot, mocked_client):
+    """Fixture with mocked FilterIO and WidgetIO"""
+    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
+    yield widget
+
+
+@pytest.fixture
+def device_signal_line_edit(qtbot, mocked_client):
+    """Fixture with mocked FilterIO and WidgetIO"""
+    widget = create_widget(qtbot=qtbot, widget=SignalLineEdit, client=mocked_client)
+    yield widget
+
+
+@pytest.fixture
+def test_device_signal_combo(qtbot, mocked_client):
+    """Fixture to create a SignalComboBox widget and a DeviceInputWidget widget"""
+    input = create_widget(
+        qtbot=qtbot,
+        widget=DeviceComboBox,
+        client=mocked_client,
+        device_filter=[BECDeviceFilter.POSITIONER],
+    )
+    signal = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
+    yield input, signal
+
+
+def test_device_signal_base_init(device_signal_base):
+    """Test if the DeviceSignalInputBase is initialized correctly"""
+    assert device_signal_base._device is None
+    assert device_signal_base._signal_filter == []
+    assert device_signal_base._signals == []
+    assert device_signal_base._hinted_signals == []
+    assert device_signal_base._normal_signals == []
+    assert device_signal_base._config_signals == []
+
+
+def test_device_signal_qproperties(device_signal_base):
+    """Test if the DeviceSignalInputBase has the correct QProperties"""
+    device_signal_base.include_config_signals = True
+    assert device_signal_base._signal_filter == [Kind.config]
+    device_signal_base.include_normal_signals = True
+    assert device_signal_base._signal_filter == [Kind.config, Kind.normal]
+    device_signal_base.include_hinted_signals = True
+    assert device_signal_base._signal_filter == [Kind.config, Kind.normal, Kind.hinted]
+
+
+def test_device_signal_set_device(device_signal_base):
+    """Test if the set_device method works correctly"""
+    device_signal_base.include_hinted_signals = True
+    device_signal_base.set_device("samx")
+    assert device_signal_base.device == "samx"
+    assert device_signal_base.signals == ["readback"]
+    device_signal_base.include_normal_signals = True
+    assert device_signal_base.signals == ["readback", "setpoint"]
+    device_signal_base.include_config_signals = True
+    assert device_signal_base.signals == ["readback", "setpoint", "velocity"]
+
+
+def test_signal_combobox(qtbot, device_signal_combobox):
+    """Test the signal_combobox"""
+    container = []
+
+    def test_cb(input):
+        container.append(input)
+
+    device_signal_combobox.device_signal_changed.connect(test_cb)
+    assert device_signal_combobox._signals == []
+    device_signal_combobox.include_normal_signals = True
+    device_signal_combobox.include_hinted_signals = True
+    device_signal_combobox.include_config_signals = True
+    assert device_signal_combobox.signals == []
+    device_signal_combobox.set_device("samx")
+    assert device_signal_combobox.signals == ["readback", "setpoint", "velocity"]
+    qtbot.wait(100)
+    assert container == ["samx"]
+
+
+def test_signal_lineeidt(device_signal_line_edit):
+    """Test the signal_combobox"""
+
+    assert device_signal_line_edit._signals == []
+    device_signal_line_edit.include_normal_signals = True
+    device_signal_line_edit.include_hinted_signals = True
+    device_signal_line_edit.include_config_signals = True
+    assert device_signal_line_edit.signals == []
+    device_signal_line_edit.set_device("samx")
+    assert device_signal_line_edit.signals == ["readback", "setpoint", "velocity"]
--- a/tests/unit_tests/test_filter_io.py
+++ b/tests/unit_tests/test_filter_io.py
@@ -0,0 +1,45 @@
+import pytest
+
+from bec_widgets.utils.filter_io import FilterIO
+from bec_widgets.widgets.dap_combo_box.dap_combo_box import DapComboBox
+from bec_widgets.widgets.device_line_edit.device_line_edit import DeviceLineEdit
+
+from .client_mocks import mocked_client
+from .conftest import create_widget
+
+
+@pytest.fixture(scope="function")
+def dap_mock(qtbot, mocked_client):
+    """Fixture for QLineEdit widget"""
+    models = ["GaussianModel", "LorentzModel", "SineModel"]
+    mocked_client.dap._available_dap_plugins.keys.return_value = models
+    widget = create_widget(qtbot, DapComboBox, client=mocked_client)
+    return widget
+
+
+@pytest.fixture(scope="function")
+def line_edit_mock(qtbot, mocked_client):
+    """Fixture for QLineEdit widget"""
+    widget = create_widget(qtbot, DeviceLineEdit, client=mocked_client)
+    return widget
+
+
+def test_set_selection_combo_box(dap_mock):
+    """Test set selection for QComboBox using DapComboBox"""
+    assert dap_mock.fit_model_combobox.count() == 3
+    FilterIO.set_selection(dap_mock.fit_model_combobox, selection=["testA", "testB"])
+    assert dap_mock.fit_model_combobox.count() == 2
+    assert FilterIO.check_input(widget=dap_mock.fit_model_combobox, text="testA") is True
+
+
+def test_set_selection_line_edit(line_edit_mock):
+    """Test set selection for QComboBox using DapComboBox"""
+    FilterIO.set_selection(line_edit_mock, selection=["testA", "testB"])
+    assert line_edit_mock.completer.model().rowCount() == 2
+    model = line_edit_mock.completer.model()
+    model_data = [model.data(model.index(i)) for i in range(model.rowCount())]
+    assert model_data == ["testA", "testB"]
+    assert FilterIO.check_input(widget=line_edit_mock, text="testA") is True
+    FilterIO.set_selection(line_edit_mock, selection=["testC"])
+    assert FilterIO.check_input(widget=line_edit_mock, text="testA") is False
+    assert FilterIO.check_input(widget=line_edit_mock, text="testC") is True
--- a/tests/unit_tests/test_motor_map_widget.py
+++ b/tests/unit_tests/test_motor_map_widget.py
@@ -2,6 +2,7 @@ from unittest.mock import MagicMock, patch

 import pytest

+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_settings import MotorMapSettings
 from bec_widgets.widgets.motor_map.motor_map_widget import BECMotorMapWidget

@@ -11,8 +12,8 @@ from .client_mocks import mocked_client
@pytest.fixture
 def motor_map_widget(qtbot, mocked_client):
    widget = BECMotorMapWidget(client=mocked_client())
-    widget.toolbar.widgets["motor_x"].device_combobox.set_device_filter("FakePositioner")
-    widget.toolbar.widgets["motor_y"].device_combobox.set_device_filter("FakePositioner")
+    widget.toolbar.widgets["motor_x"].device_combobox.set_device_filter(BECDeviceFilter.POSITIONER)
+    widget.toolbar.widgets["motor_y"].device_combobox.set_device_filter(BECDeviceFilter.POSITIONER)
    qtbot.addWidget(widget)
    qtbot.waitExposed(widget)
    yield widget
@@ -35,14 +36,12 @@ def test_motor_map_widget_init(motor_map_widget):
    assert motor_map_widget.toolbar.widgets["connect"].action.isEnabled() == True
    assert motor_map_widget.toolbar.widgets["config"].action.isEnabled() == False
    assert motor_map_widget.toolbar.widgets["history"].action.isEnabled() == False
-    assert (
-        motor_map_widget.toolbar.widgets["motor_x"].device_combobox.config.device_filter
-        == "FakePositioner"
-    )
-    assert (
-        motor_map_widget.toolbar.widgets["motor_y"].device_combobox.config.device_filter
-        == "FakePositioner"
-    )
+    assert motor_map_widget.toolbar.widgets["motor_x"].device_combobox.config.device_filter == [
+        BECDeviceFilter.POSITIONER
+    ]
+    assert motor_map_widget.toolbar.widgets["motor_y"].device_combobox.config.device_filter == [
+        BECDeviceFilter.POSITIONER
+    ]
    assert motor_map_widget.map.motor_x is None
    assert motor_map_widget.map.motor_y is None

--- a/tests/unit_tests/test_scan_control.py
+++ b/tests/unit_tests/test_scan_control.py
@@ -372,22 +372,21 @@ def test_run_line_scan_with_parameters(scan_control, mocked_client):
    scan_name = "line_scan"
    kwargs = {"exp_time": 0.1, "steps": 10, "relative": True, "burst_at_each_point": 1}
    args = {"device": "samx", "start": -5, "stop": 5}
+    mock_slot = MagicMock()
+    scan_control.scan_args.connect(mock_slot)

    scan_control.comboBox_scan_selection.setCurrentText(scan_name)

    # Set kwargs in the UI
    for kwarg_box in scan_control.kwarg_boxes:
        for widget in kwarg_box.widgets:
-            for key, value in kwargs.items():
-                if widget.arg_name == key:
-                    WidgetIO.set_value(widget, value)
-                    break
+            if widget.arg_name in kwargs:
+                WidgetIO.set_value(widget, kwargs[widget.arg_name])
+
    # Set args in the UI
    for widget in scan_control.arg_box.widgets:
-        for key, value in args.items():
-            if widget.arg_name == key:
-                WidgetIO.set_value(widget, value)
-                break
+        if widget.arg_name in args:
+            WidgetIO.set_value(widget, args[widget.arg_name])

    # Mock the scan function
    mocked_scan_function = MagicMock()
@@ -405,6 +404,88 @@ def test_run_line_scan_with_parameters(scan_control, mocked_client):
    assert called_args == tuple(expected_args_list)
    assert called_kwargs == kwargs

+    # Check the emitted signal
+    mock_slot.assert_called_once()
+    emitted_args_list = mock_slot.call_args[0][0]
+    assert len(emitted_args_list) == 3  # Expected 3 arguments for line_scan
+    assert emitted_args_list == [expected_device, -5.0, 5.0]
+
+
+def test_run_grid_scan_with_parameters(scan_control, mocked_client):
+    scan_name = "grid_scan"
+    kwargs = {"exp_time": 0.2, "settling_time": 0.1, "relative": False, "burst_at_each_point": 2}
+    args_row1 = {"device": "samx", "start": -10, "stop": 10, "steps": 20}
+    args_row2 = {"device": "samy", "start": -5, "stop": 5, "steps": 10}
+    mock_slot = MagicMock()
+    scan_control.scan_args.connect(mock_slot)
+
+    scan_control.comboBox_scan_selection.setCurrentText(scan_name)
+
+    # Ensure there are two rows in the arg_box
+    current_rows = scan_control.arg_box.count_arg_rows()
+    required_rows = 2
+    while current_rows < required_rows:
+        scan_control.arg_box.add_widget_bundle()
+        current_rows += 1
+
+    # Set kwargs in the UI
+    for kwarg_box in scan_control.kwarg_boxes:
+        for widget in kwarg_box.widgets:
+            if widget.arg_name in kwargs:
+                WidgetIO.set_value(widget, kwargs[widget.arg_name])
+
+    # Set args in the UI for both rows
+    arg_widgets = scan_control.arg_box.widgets  # This is a flat list of widgets
+    num_columns = len(scan_control.arg_box.inputs)
+    num_rows = int(len(arg_widgets) / num_columns)
+    assert num_rows == required_rows  # We expect 2 rows for grid_scan
+
+    # Set values for first row
+    for i in range(num_columns):
+        widget = arg_widgets[i]
+        arg_name = widget.arg_name
+        if arg_name in args_row1:
+            WidgetIO.set_value(widget, args_row1[arg_name])
+
+    # Set values for second row
+    for i in range(num_columns):
+        widget = arg_widgets[num_columns + i]  # Next row
+        arg_name = widget.arg_name
+        if arg_name in args_row2:
+            WidgetIO.set_value(widget, args_row2[arg_name])
+
+    # Mock the scan function
+    mocked_scan_function = MagicMock()
+    setattr(mocked_client.scans, scan_name, mocked_scan_function)
+
+    # Run the scan
+    scan_control.button_run_scan.click()
+
+    # Retrieve the actual arguments passed to the mock
+    called_args, called_kwargs = mocked_scan_function.call_args
+
+    # Check if the scan function was called correctly
+    expected_device1 = mocked_client.device_manager.devices.samx
+    expected_device2 = mocked_client.device_manager.devices.samy
+    expected_args_list = [
+        expected_device1,
+        args_row1["start"],
+        args_row1["stop"],
+        args_row1["steps"],
+        expected_device2,
+        args_row2["start"],
+        args_row2["stop"],
+        args_row2["steps"],
+    ]
+    assert called_args == tuple(expected_args_list)
+    assert called_kwargs == kwargs
+
+    # Check the emitted signal
+    mock_slot.assert_called_once()
+    emitted_args_list = mock_slot.call_args[0][0]
+    assert len(emitted_args_list) == 8  # Expected 8 arguments for grid_scan
+    assert emitted_args_list == expected_args_list
+

 def test_changing_scans_remember_parameters(scan_control, mocked_client):
    scan_name = "line_scan"
--- a/tests/unit_tests/test_waveform1d.py
+++ b/tests/unit_tests/test_waveform1d.py
@@ -152,12 +152,30 @@ def test_getting_curve(qtbot, mocked_client):
    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
    w1 = bec_figure.plot()
    c1 = w1.add_curve_bec(x_name="samx", y_name="bpm4i", gui_id="test_curve")
-    c1_expected_config = CurveConfig(
+    c1_expected_config_dark = CurveConfig(
        widget_class="BECCurve",
        gui_id="test_curve",
        parent_id=w1.gui_id,
        label="bpm4i-bpm4i",
-        color="#b73779",
+        color="#3b0f70",
+        symbol="o",
+        symbol_color=None,
+        symbol_size=7,
+        pen_width=4,
+        pen_style="solid",
+        source="scan_segment",
+        signals=Signal(
+            source="scan_segment",
+            x=SignalData(name="samx", entry="samx", unit=None, modifier=None),
+            y=SignalData(name="bpm4i", entry="bpm4i", unit=None, modifier=None),
+        ),
+    )
+    c1_expected_config_light = CurveConfig(
+        widget_class="BECCurve",
+        gui_id="test_curve",
+        parent_id=w1.gui_id,
+        label="bpm4i-bpm4i",
+        color="#000004",
        symbol="o",
        symbol_color=None,
        symbol_size=7,
@@ -171,14 +189,39 @@ def test_getting_curve(qtbot, mocked_client):
        ),
    )

-    assert w1.curves[0].config == c1_expected_config
-    assert w1._curves_data["scan_segment"]["bpm4i-bpm4i"].config == c1_expected_config
-    assert w1.get_curve(0).config == c1_expected_config
-    assert w1.get_curve_config("bpm4i-bpm4i", dict_output=True) == c1_expected_config.model_dump()
-    assert w1.get_curve_config("bpm4i-bpm4i", dict_output=False) == c1_expected_config
-    assert w1.get_curve("bpm4i-bpm4i").config == c1_expected_config
-    assert c1.get_config(False) == c1_expected_config
-    assert c1.get_config() == c1_expected_config.model_dump()
+    assert (
+        w1.curves[0].config == c1_expected_config_dark
+        or w1.curves[0].config == c1_expected_config_light
+    )
+    assert (
+        w1._curves_data["scan_segment"]["bpm4i-bpm4i"].config == c1_expected_config_dark
+        or w1._curves_data["scan_segment"]["bpm4i-bpm4i"].config == c1_expected_config_light
+    )
+    assert (
+        w1.get_curve(0).config == c1_expected_config_dark
+        or w1.get_curve(0).config == c1_expected_config_light
+    )
+    assert (
+        w1.get_curve_config("bpm4i-bpm4i", dict_output=True) == c1_expected_config_dark.model_dump()
+        or w1.get_curve_config("bpm4i-bpm4i", dict_output=True)
+        == c1_expected_config_light.model_dump()
+    )
+    assert (
+        w1.get_curve_config("bpm4i-bpm4i", dict_output=False) == c1_expected_config_dark
+        or w1.get_curve_config("bpm4i-bpm4i", dict_output=False) == c1_expected_config_light
+    )
+    assert (
+        w1.get_curve("bpm4i-bpm4i").config == c1_expected_config_dark
+        or w1.get_curve("bpm4i-bpm4i").config == c1_expected_config_light
+    )
+    assert (
+        c1.get_config(False) == c1_expected_config_dark
+        or c1.get_config(False) == c1_expected_config_light
+    )
+    assert (
+        c1.get_config() == c1_expected_config_dark.model_dump()
+        or c1.get_config() == c1_expected_config_light.model_dump()
+    )


 def test_getting_curve_errors(qtbot, mocked_client):
Author	SHA1	Message	Date
wyzula-jan	65dceead0c	WIP adjustments to be compatible with latest bec widgets and bec	2024-11-11 16:41:28 +01:00
wyzula-jan	20125139f0	fix(dock): REBASE docks can be created as temporary, when closed the dock will not return to original dock area	2024-11-11 16:31:05 +01:00
semantic-release	bf0b49b863	1.4.0 Automatically generated by python-semantic-release	2024-11-11 14:19:33 +00:00
wyzula-jan	11e5937ae0	fix(crosshair): label of coordinates of TextItem displays numbers in general format	2024-11-11 15:09:55 +01:00
wyzula-jan	4f31ea655c	fix(crosshair): label of coordinates of TextItem is updated according to the current theme of qapp	2024-11-11 15:09:55 +01:00
wyzula-jan	64df805a9e	test(crosshair): tests extended	2024-11-11 15:09:55 +01:00
wyzula-jan	035136d517	feat(crosshair): TextItem to display crosshair coordinates	2024-11-11 15:09:55 +01:00
wyzula-jan	b2eb71aae0	fix(crosshair): log is separately scaled for backend logic and for signal emit	2024-11-11 15:09:55 +01:00
semantic-release	1e6659c379	1.3.3 Automatically generated by python-semantic-release	2024-11-07 23:02:04 +00:00
wyzula-jan	5fabd4bea9	fix(scan_control): DeviceLineEdit kwargs readings changed to get name of the positioner	2024-11-07 16:47:42 +01:00
appel_c	4f0693cae3	docs: update outdated text in docs	2024-11-07 12:49:36 +01:00
semantic-release	ba76d6bb86	1.3.2 Automatically generated by python-semantic-release	2024-11-05 14:53:05 +00:00
wyzula-jan	2304c9f849	fix(plot_base): legend text color is changed when changing dark-light theme	2024-11-05 10:37:53 +01:00
wyzula-jan	c6e48ec1fe	build: PySide6 version fixed 6.7.2	2024-11-04 14:41:43 +01:00
semantic-release	f837129023	1.3.1 Automatically generated by python-semantic-release	2024-10-31 14:37:23 +00:00
wyzula-jan	940ee6552c	fix(ophyd_kind_util): Kind enums are imported from the bec widget util class	2024-10-31 12:26:10 +01:00
semantic-release	86b60b4aed	1.3.0 Automatically generated by python-semantic-release	2024-10-30 13:19:18 +00:00
wyzula-jan	14dd8c5b29	fix(colors): extend color map validation for matplotlib and colorcet maps (if available)	2024-10-28 17:17:03 +01:00
wyzula-jan	b039933405	feat(colormap_button): colormap button with menu to select colormap filtered by the colormap type	2024-10-28 13:48:56 +01:00
semantic-release	d8c80293c7	1.2.0 Automatically generated by python-semantic-release	2024-10-25 17:17:49 +00:00
wyzula-jan	40c9fea35f	feat(colors): evenly spaced color generation + new golden ratio calculation	2024-10-25 19:08:13 +02:00
appel_c	5d4b86e1c6	refactor: add bec_lib version to statusbox	2024-10-25 16:12:06 +02:00
semantic-release	5681c0cbd1	1.1.0 Automatically generated by python-semantic-release	2024-10-25 08:19:34 +00:00
appel_c	91959e82de	refactor: do not flush selection upon receiving config update; allow widgetIO to receive kwargs to be able to use get_value to receive string instead of int for QComboBox	2024-10-24 18:09:18 +02:00
appel_c	5eb15b785f	refactor: allow to set selection in DeviceInput; automatic update of selection on device config update; cleanup	2024-10-24 13:38:26 +02:00
appel_c	6fb20552ff	refactor: cleanup, added device_signal for signal inputs	2024-10-24 09:21:32 +02:00
appel_c	0350833f36	feat: add filter i/o utility class	2024-10-22 16:56:16 +02:00
wyzula-jan	acb79020d4	test(scan_control): tests added for grid_scan to ensure scan_args signal validity	2024-10-22 16:05:14 +02:00