bec-widgets 0.117.1__py3-none-any.whl → 0.119.0__py3-none-any.whl

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -164,7 +164,7 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
 
         self.d1 = self.dock.add_dock(name="dock_1", position="right")
         self.im = self.d1.add_widget("BECImageWidget")
-        self.im.image("eiger")
+        self.im.image("waveform", "1d")
 
         self.d2 = self.dock.add_dock(name="dock_2", position="bottom")
         self.wf = self.d2.add_widget("BECWaveformWidget", row=0, col=0)

bec_widgets/qt_utils/compact_popup.py

@@ -1,7 +1,8 @@
+import time
 from types import SimpleNamespace
 
 from bec_qthemes import material_icon
-from qtpy.QtCore import Property, Qt
+from qtpy.QtCore import Property, Qt, Signal
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import (
     QDialog,
@@ -9,6 +10,7 @@ from qtpy.QtWidgets import (
     QLabel,
     QPushButton,
     QSizePolicy,
+    QSpacerItem,
     QVBoxLayout,
     QWidget,
 )
@@ -98,6 +100,7 @@ class PopupDialog(QDialog):
     def closeEvent(self, event):
         self.content_widget.setVisible(False)
         self.content_widget.setParent(self.parent)
+        self.done(True)
 
 
 class CompactPopupWidget(QWidget):
@@ -107,29 +110,35 @@ class CompactPopupWidget(QWidget):
     In the compact form, a LED-like indicator shows a status indicator.
     """
 
+    expand = Signal(bool)
+
     def __init__(self, parent=None, layout=QVBoxLayout):
         super().__init__(parent)
 
         self._popup_window = None
+        self._expand_popup = True
 
         QVBoxLayout(self)
-        self.compact_view = QWidget(self)
-        self.compact_view.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-        QHBoxLayout(self.compact_view)
-        self.compact_view.layout().setSpacing(0)
-        self.compact_view.layout().setContentsMargins(0, 0, 0, 0)
-        self.compact_label = QLabel(self.compact_view)
-        self.compact_status = LedLabel(self.compact_view)
-        self.compact_show_popup = QPushButton(self.compact_view)
+        self.compact_view_widget = QWidget(self)
+        self.compact_view_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        QHBoxLayout(self.compact_view_widget)
+        self.compact_view_widget.layout().setSpacing(0)
+        self.compact_view_widget.layout().setContentsMargins(0, 0, 0, 0)
+        self.compact_view_widget.layout().addSpacerItem(
+            QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Fixed)
+        )
+        self.compact_label = QLabel(self.compact_view_widget)
+        self.compact_status = LedLabel(self.compact_view_widget)
+        self.compact_show_popup = QPushButton(self.compact_view_widget)
         self.compact_show_popup.setFlat(True)
         self.compact_show_popup.setIcon(
-            material_icon(icon_name="pan_zoom", size=(10, 10), convert_to_pixmap=False)
+            material_icon(icon_name="expand_content", size=(10, 10), convert_to_pixmap=False)
         )
-        self.compact_view.layout().addWidget(self.compact_label)
-        self.compact_view.layout().addWidget(self.compact_status)
-        self.compact_view.layout().addWidget(self.compact_show_popup)
-        self.compact_view.setVisible(False)
-        self.layout().addWidget(self.compact_view)
+        self.compact_view_widget.layout().addWidget(self.compact_label)
+        self.compact_view_widget.layout().addWidget(self.compact_status)
+        self.compact_view_widget.layout().addWidget(self.compact_show_popup)
+        self.compact_view_widget.setVisible(False)
+        self.layout().addWidget(self.compact_view_widget)
         self.container = QWidget(self)
         self.layout().addWidget(self.container)
         self.container.setVisible(True)
@@ -148,8 +157,36 @@ class CompactPopupWidget(QWidget):
 
     def show_popup(self):
         """Display the contained widgets in a popup dialog"""
-        self._popup_window = PopupDialog(self.container)
-        self._popup_window.show()
+        if self._expand_popup:
+            # show popup
+            self._popup_window = PopupDialog(self.container)
+            self._popup_window.show()
+            self._popup_window.finished.connect(lambda: self.expand.emit(False))
+            self.expand.emit(True)
+        else:
+            if self.compact_view:
+                # expand in place
+                self.compact_view = False
+                self.compact_view_widget.setVisible(True)
+                self.compact_label.setVisible(False)
+                self.compact_status.setVisible(False)
+                self.compact_show_popup.setIcon(
+                    material_icon(
+                        icon_name="collapse_content", size=(10, 10), convert_to_pixmap=False
+                    )
+                )
+                self.expand.emit(True)
+            else:
+                # back to compact form
+                self.compact_label.setVisible(True)
+                self.compact_status.setVisible(True)
+                self.compact_show_popup.setIcon(
+                    material_icon(
+                        icon_name="expand_content", size=(10, 10), convert_to_pixmap=False
+                    )
+                )
+                self.compact_view = True
+                self.expand.emit(False)
 
     def setSizePolicy(self, size_policy1, size_policy2=None):
         # setting size policy on the compact popup widget will set
@@ -172,11 +209,11 @@ class CompactPopupWidget(QWidget):
         self.container.layout().addWidget(widget)
 
     @Property(bool)
-    def compact(self):
-        return self.compact_view.isVisible()
+    def compact_view(self):
+        return self.compact_label.isVisible()
 
-    @compact.setter
-    def compact(self, set_compact: bool):
+    @compact_view.setter
+    def compact_view(self, set_compact: bool):
         """Sets the compact form
 
         If set_compact is True, the compact view is displayed ; otherwise,
@@ -184,11 +221,11 @@ class CompactPopupWidget(QWidget):
         the container widget or the compact view widget.
         """
         if set_compact:
-            self.compact_view.setVisible(True)
+            self.compact_view_widget.setVisible(True)
             self.container.setVisible(False)
             QWidget.setSizePolicy(self, QSizePolicy.Fixed, QSizePolicy.Fixed)
         else:
-            self.compact_view.setVisible(False)
+            self.compact_view_widget.setVisible(False)
             self.container.setVisible(True)
             QWidget.setSizePolicy(self, self.container.sizePolicy())
         if self.parentWidget():
@@ -215,6 +252,14 @@ class CompactPopupWidget(QWidget):
         self.compact_label.setToolTip(tooltip)
         self.compact_status.setToolTip(tooltip)
 
+    @Property(bool)
+    def expand_popup(self):
+        return self._expand_popup
+
+    @expand_popup.setter
+    def expand_popup(self, popup: bool):
+        self._expand_popup = popup
+
     def closeEvent(self, event):
         # Called by Qt, on closing - since the children widgets can be
         # BECWidgets, it is good to explicitely call 'close' on them,

bec_widgets/qt_utils/toolbar.py

@@ -7,9 +7,18 @@ from collections import defaultdict
 from typing import Literal
 
 from bec_qthemes._icon.material_icons import material_icon
-from qtpy.QtCore import QSize
+from qtpy.QtCore import QSize, Qt
 from qtpy.QtGui import QAction, QColor, QIcon
-from qtpy.QtWidgets import QHBoxLayout, QLabel, QMenu, QSizePolicy, QToolBar, QToolButton, QWidget
+from qtpy.QtWidgets import (
+    QComboBox,
+    QHBoxLayout,
+    QLabel,
+    QMenu,
+    QSizePolicy,
+    QToolBar,
+    QToolButton,
+    QWidget,
+)
 
 import bec_widgets
 
@@ -154,22 +163,52 @@ class WidgetAction(ToolBarAction):
 
     """
 
-    def __init__(self, label: str | None = None, widget: QWidget = None):
-        super().__init__()
+    def __init__(self, label: str | None = None, widget: QWidget = None, parent=None):
+        super().__init__(parent)
         self.label = label
         self.widget = widget
 
-    def add_to_toolbar(self, toolbar, target):
-        widget = QWidget()
-        layout = QHBoxLayout(widget)
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        container = QWidget()
+        layout = QHBoxLayout(container)
         layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(5)
+
         if self.label is not None:
-            label = QLabel(f"{self.label}")
-            label.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
-            layout.addWidget(label)
-        self.widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
+            label_widget = QLabel(f"{self.label}")
+            label_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
+            label_widget.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
+            layout.addWidget(label_widget)
+
+        if isinstance(self.widget, QComboBox):
+            self.widget.setSizeAdjustPolicy(QComboBox.AdjustToContents)
+
+            size_policy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+            self.widget.setSizePolicy(size_policy)
+
+            self.widget.setMinimumWidth(self.calculate_minimum_width(self.widget))
+
+        else:
+            self.widget.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+
         layout.addWidget(self.widget)
-        toolbar.addWidget(widget)
+
+        toolbar.addWidget(container)
+
+    @staticmethod
+    def calculate_minimum_width(combo_box: QComboBox) -> int:
+        """
+        Calculate the minimum width required to display the longest item in the combo box.
+
+        Args:
+            combo_box (QComboBox): The combo box to calculate the width for.
+
+        Returns:
+            int: The calculated minimum width in pixels.
+        """
+        font_metrics = combo_box.fontMetrics()
+        max_width = max(font_metrics.width(combo_box.itemText(i)) for i in range(combo_box.count()))
+        return max_width + 60
 
 
 class ExpandableMenuAction(ToolBarAction):

bec_widgets/widgets/device_line_edit/device_line_edit.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from qtpy.QtCore import QSize
+from qtpy.QtCore import QSize, Signal, Slot
 from qtpy.QtWidgets import QCompleter, QLineEdit, QSizePolicy
 
 from bec_widgets.utils.bec_widget import BECWidget
@@ -24,6 +24,8 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         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)
+
     ICON_NAME = "edit_note"
 
     def __init__(
@@ -54,6 +56,18 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
         self.setMinimumSize(QSize(100, 0))
 
+        self.editingFinished.connect(self.emit_device_selected)
+
+    @Slot()
+    def emit_device_selected(self):
+        """
+        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.

bec_widgets/widgets/figure/figure.py

@@ -321,6 +321,7 @@ class BECFigure(BECWidget, pg.GraphicsLayoutWidget):
         self,
         image,
         monitor: str = None,
+        monitor_type: Literal["1d", "2d"] = "2d",
         color_bar: Literal["simple", "full"] = "full",
         color_map: str = "magma",
         data: np.ndarray = None,
@@ -337,7 +338,13 @@ class BECFigure(BECWidget, pg.GraphicsLayoutWidget):
             data (np.ndarray): Custom data to display.
         """
         if monitor is not None and data is None:
-            image.image(monitor=monitor, color_map=color_map, vrange=vrange, color_bar=color_bar)
+            image.image(
+                monitor=monitor,
+                monitor_type=monitor_type,
+                color_map=color_map,
+                vrange=vrange,
+                color_bar=color_bar,
+            )
         elif data is not None and monitor is None:
             image.add_custom_image(
                 name="custom", data=data, color_map=color_map, vrange=vrange, color_bar=color_bar
@@ -355,6 +362,7 @@ class BECFigure(BECWidget, pg.GraphicsLayoutWidget):
     def image(
         self,
         monitor: str = None,
+        monitor_type: Literal["1d", "2d"] = "2d",
         color_bar: Literal["simple", "full"] = "full",
         color_map: str = "magma",
         data: np.ndarray = None,
@@ -393,6 +401,7 @@ class BECFigure(BECWidget, pg.GraphicsLayoutWidget):
         image = self._init_image(
             image=image,
             monitor=monitor,
+            monitor_type=monitor_type,
             color_bar=color_bar,
             color_map=color_map,
             data=data,

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

@@ -7,10 +7,10 @@ import numpy as np
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from pydantic import BaseModel, Field, ValidationError
-from qtpy.QtCore import QThread
+from qtpy.QtCore import QThread, Slot
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.qt_utils.error_popups import SafeSlot as Slot
+# from bec_widgets.qt_utils.error_popups import SafeSlot as Slot
 from bec_widgets.utils import EntryValidator
 from bec_widgets.widgets.figure.plots.image.image_item import BECImageItem, ImageItemConfig
 from bec_widgets.widgets.figure.plots.image.image_processor import (
@@ -80,6 +80,8 @@ class BECImageShow(BECPlotBase):
         )
         # Get bec shortcuts dev, scans, queue, scan_storage, dap
         self.single_image = single_image
+        self.image_type = "device_monitor_2d"
+        self.scan_id = None
         self.get_bec_shortcuts()
         self.entry_validator = EntryValidator(self.dev)
         self._images = defaultdict(dict)
@@ -105,7 +107,7 @@ class BECImageShow(BECPlotBase):
 
     def find_image_by_monitor(self, item_id: str) -> BECImageItem:
         """
-        Find the widget by its gui_id.
+        Find the image item by its gui_id.
 
         Args:
             item_id(str): The gui_id of the widget.
@@ -230,6 +232,7 @@ class BECImageShow(BECPlotBase):
     def image(
         self,
         monitor: str,
+        monitor_type: Literal["1d", "2d"] = "2d",
         color_map: Optional[str] = "magma",
         color_bar: Optional[Literal["simple", "full"]] = "full",
         downsample: Optional[bool] = True,
@@ -243,6 +246,7 @@ class BECImageShow(BECPlotBase):
 
         Args:
             monitor(str): The name of the monitor to display.
+            monitor_type(Literal["1d","2d"]): The type of monitor to display.
             color_bar(Literal["simple","full"]): The type of color bar to display.
             color_map(str): The color map to use for the image.
             data(np.ndarray): Custom data to display.
@@ -251,7 +255,12 @@ class BECImageShow(BECPlotBase):
         Returns:
             BECImageItem: The image item.
         """
-        image_source = "device_monitor_2d"
+        if monitor_type == "1d":
+            image_source = "device_monitor_1d"
+            self.image_type = "device_monitor_1d"
+        elif monitor_type == "2d":
+            image_source = "device_monitor_2d"
+            self.image_type = "device_monitor_2d"
 
         image_exits = self._check_image_id(monitor, self._images)
         if image_exits:
@@ -292,7 +301,6 @@ class BECImageShow(BECPlotBase):
         **kwargs,
     ):
         image_source = "custom"
-        # image_source = "device_monitor_2d"
 
         image_exits = self._check_image_id(name, self._images)
         if image_exits:
@@ -516,9 +524,58 @@ class BECImageShow(BECPlotBase):
         """
         data = msg["data"]
         device = msg["device"]
-        image = self._images["device_monitor_2d"][device]
-        image.raw_data = data
-        self.process_image(device, image, data)
+        if self.image_type == "device_monitor_1d":
+            image = self._images["device_monitor_1d"][device]
+            current_scan_id = metadata.get("scan_id", None)
+            if current_scan_id is None:
+                return
+            if current_scan_id != self.scan_id:
+                self.reset()
+                self.scan_id = current_scan_id
+                image.image_buffer_list = []
+                image.max_len = 0
+            image_buffer = self.adjust_image_buffer(image, data)
+            image.raw_data = image_buffer
+            self.process_image(device, image, image_buffer)
+        elif self.image_type == "device_monitor_2d":
+            image = self._images["device_monitor_2d"][device]
+            image.raw_data = data
+            self.process_image(device, image, data)
+
+    def adjust_image_buffer(self, image: BECImageItem, new_data: np.ndarray) -> np.ndarray:
+        """
+        Adjusts the image buffer to accommodate the new data, ensuring that all rows have the same length.
+
+        Args:
+            image: The image object (used to store buffer list and max_len).
+            new_data (np.ndarray): The new incoming 1D waveform data.
+
+        Returns:
+            np.ndarray: The updated image buffer with adjusted shapes.
+        """
+        new_len = new_data.shape[0]
+        if not hasattr(image, "image_buffer_list"):
+            image.image_buffer_list = []
+            image.max_len = 0
+
+        if new_len > image.max_len:
+            image.max_len = new_len
+            for i in range(len(image.image_buffer_list)):
+                wf = image.image_buffer_list[i]
+                pad_width = image.max_len - wf.shape[0]
+                if pad_width > 0:
+                    image.image_buffer_list[i] = np.pad(
+                        wf, (0, pad_width), mode="constant", constant_values=0
+                    )
+            image.image_buffer_list.append(new_data)
+        else:
+            pad_width = image.max_len - new_len
+            if pad_width > 0:
+                new_data = np.pad(new_data, (0, pad_width), mode="constant", constant_values=0)
+            image.image_buffer_list.append(new_data)
+
+        image_buffer = np.array(image.image_buffer_list)
+        return image_buffer
 
     @Slot(str, np.ndarray)
     def update_image(self, device: str, data: np.ndarray):
@@ -529,7 +586,7 @@ class BECImageShow(BECPlotBase):
             device(str): The name of the device.
             data(np.ndarray): The data to be updated.
         """
-        image_to_update = self._images["device_monitor_2d"][device]
+        image_to_update = self._images[self.image_type][device]
         image_to_update.updateImage(data, autoLevels=image_to_update.config.autorange)
 
     @Slot(str, ImageStats)
@@ -540,7 +597,7 @@ class BECImageShow(BECPlotBase):
         Args:
             stats(ImageStats): The statistics of the image.
         """
-        image_to_update = self._images["device_monitor_2d"][device]
+        image_to_update = self._images[self.image_type][device]
         if image_to_update.config.autorange:
             image_to_update.auto_update_vrange(stats)
 
@@ -553,7 +610,7 @@ class BECImageShow(BECPlotBase):
                 data = image.raw_data
                 self.process_image(image_id, image, data)
 
-    def _connect_device_monitor_2d(self, monitor: str):
+    def _connect_device_monitor(self, monitor: str):
         """
         Connect to the device monitor.
 
@@ -566,29 +623,36 @@ class BECImageShow(BECPlotBase):
         except AttributeError:
             previous_monitor = None
         if previous_monitor and image_item.connected is True:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor_1d(previous_monitor)
+            )
             self.bec_dispatcher.disconnect_slot(
                 self.on_image_update, MessageEndpoints.device_monitor_2d(previous_monitor)
             )
             image_item.connected = False
         if monitor and image_item.connected is False:
             self.entry_validator.validate_monitor(monitor)
-            self.bec_dispatcher.connect_slot(
-                self.on_image_update, MessageEndpoints.device_monitor_2d(monitor)
-            )
+            if self.image_type == "device_monitor_1d":
+                self.bec_dispatcher.connect_slot(
+                    self.on_image_update, MessageEndpoints.device_monitor_1d(monitor)
+                )
+            elif self.image_type == "device_monitor_2d":
+                self.bec_dispatcher.connect_slot(
+                    self.on_image_update, MessageEndpoints.device_monitor_2d(monitor)
+                )
             image_item.set_monitor(monitor)
             image_item.connected = True
 
     def _add_image_object(
         self, source: str, name: str, config: ImageItemConfig, data=None
-    ) -> BECImageItem:  # TODO fix types
+    ) -> BECImageItem:
         config.parent_id = self.gui_id
         if self.single_image is True and len(self.images) > 0:
             self.remove_image(0)
         image = BECImageItem(config=config, parent_image=self)
         self.plot_item.addItem(image)
         self._images[source][name] = image
-        if source == "device_monitor_2d":
-            self._connect_device_monitor_2d(config.monitor)
+        self._connect_device_monitor(config.monitor)
         self.config.images[name] = config
         if data is not None:
             image.setImage(data)
@@ -673,6 +737,9 @@ class BECImageShow(BECPlotBase):
         """
         image = self.find_image_by_monitor(image_id)
         if image:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor_1d(image.config.monitor)
+            )
             self.bec_dispatcher.disconnect_slot(
                 self.on_image_update, MessageEndpoints.device_monitor_2d(image.config.monitor)
             )
@@ -681,9 +748,9 @@ class BECImageShow(BECPlotBase):
         """
         Clean up the widget.
         """
-        for monitor in self._images["device_monitor_2d"]:
+        for monitor in self._images[self.image_type]:
             self.bec_dispatcher.disconnect_slot(
-                self.on_image_update, MessageEndpoints.device_monitor_2d(monitor)
+                self.on_image_update, MessageEndpoints.device_monitor_1d(monitor)
             )
         self.images.clear()
 

bec_widgets/widgets/image/image_widget.py

@@ -4,7 +4,7 @@ import sys
 from typing import Literal, Optional
 
 import pyqtgraph as pg
-from qtpy.QtWidgets import QVBoxLayout, QWidget
+from qtpy.QtWidgets import QComboBox, QVBoxLayout, QWidget
 
 from bec_widgets.qt_utils.error_popups import SafeSlot, WarningPopupUtility
 from bec_widgets.qt_utils.settings_dialog import SettingsDialog
@@ -13,6 +13,7 @@ from bec_widgets.qt_utils.toolbar import (
     MaterialIconAction,
     ModularToolBar,
     SeparatorAction,
+    WidgetAction,
 )
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.widgets.device_combobox.device_combobox import DeviceComboBox
@@ -63,11 +64,14 @@ class BECImageWidget(BECWidget, QWidget):
         self.layout.setContentsMargins(0, 0, 0, 0)
 
         self.fig = BECFigure()
+        self.dim_combo_box = QComboBox()
+        self.dim_combo_box.addItems(["1d", "2d"])
         self.toolbar = ModularToolBar(
             actions={
                 "monitor": DeviceSelectionAction(
                     "Monitor:", DeviceComboBox(device_filter="Device")
                 ),
+                "monitor_type": WidgetAction(widget=self.dim_combo_box),
                 "connect": MaterialIconAction(icon_name="link", tooltip="Connect Device"),
                 "separator_0": SeparatorAction(),
                 "save": MaterialIconAction(icon_name="save", tooltip="Open Export Dialog"),
@@ -163,7 +167,8 @@ class BECImageWidget(BECWidget, QWidget):
     def _connect_action(self):
         monitor_combo = self.toolbar.widgets["monitor"].device_combobox
         monitor_name = monitor_combo.currentText()
-        self.image(monitor_name)
+        monitor_type = self.toolbar.widgets["monitor_type"].widget.currentText()
+        self.image(monitor=monitor_name, monitor_type=monitor_type)
         monitor_combo.setStyleSheet("QComboBox { background-color: " "; }")
 
     def show_axis_settings(self):
@@ -182,6 +187,7 @@ class BECImageWidget(BECWidget, QWidget):
     def image(
         self,
         monitor: str,
+        monitor_type: Optional[Literal["1d", "2d"]] = "2d",
         color_map: Optional[str] = "magma",
         color_bar: Optional[Literal["simple", "full"]] = "full",
         downsample: Optional[bool] = True,
@@ -195,8 +201,14 @@ class BECImageWidget(BECWidget, QWidget):
             self.toolbar.widgets["monitor"].device_combobox.setStyleSheet(
                 "QComboBox {{ background-color: " "; }}"
             )
+        if self.toolbar.widgets["monitor_type"].widget.currentText() != monitor_type:
+            self.toolbar.widgets["monitor_type"].widget.setCurrentText(monitor_type)
+            self.toolbar.widgets["monitor_type"].widget.setStyleSheet(
+                "QComboBox {{ background-color: " "; }}"
+            )
         return self._image.image(
             monitor=monitor,
+            monitor_type=monitor_type,
             color_map=color_map,
             color_bar=color_bar,
             downsample=downsample,
@@ -486,6 +498,7 @@ def main():  # pragma: no cover
 
     app = QApplication(sys.argv)
     widget = BECImageWidget()
+    widget.image("waveform", "1d")
     widget.show()
     sys.exit(app.exec_())
 

bec_widgets/widgets/positioner_box/positioner_box.py

@@ -14,6 +14,7 @@ from qtpy.QtCore import Property, Signal, Slot
 from qtpy.QtGui import QDoubleValidator
 from qtpy.QtWidgets import QDialog, QDoubleSpinBox, QPushButton, QVBoxLayout, QWidget
 
+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
@@ -24,7 +25,7 @@ logger = bec_logger.logger
 MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 
 
-class PositionerBox(BECWidget, QWidget):
+class PositionerBox(BECWidget, CompactPopupWidget):
     """Simple Widget to control a positioner in box form"""
 
     ui_file = "positioner_box.ui"
@@ -44,7 +45,7 @@ class PositionerBox(BECWidget, QWidget):
             device (Positioner): The device to control.
         """
         super().__init__(**kwargs)
-        QWidget.__init__(self, parent=parent)
+        CompactPopupWidget.__init__(self, parent=parent, layout=QVBoxLayout)
         self.get_bec_shortcuts()
         self._device = ""
         self._limits = None
@@ -63,8 +64,7 @@ class PositionerBox(BECWidget, QWidget):
         current_path = os.path.dirname(__file__)
         self.ui = UILoader(self).loader(os.path.join(current_path, self.ui_file))
 
-        self.layout = QVBoxLayout(self)
-        self.layout.addWidget(self.ui)
+        self.addWidget(self.ui)
         self.layout.setSpacing(0)
         self.layout.setContentsMargins(0, 0, 0, 0)
 
@@ -135,8 +135,12 @@ class PositionerBox(BECWidget, QWidget):
         """Setter, checks if device is a string"""
         if not value or not isinstance(value, str):
             return
+        if not self._check_device_is_valid(value):
+            return
         old_device = self._device
         self._device = value
+        if not self.label:
+            self.label = value
         self.device_changed.emit(old_device, value)
 
     @Property(bool)
@@ -241,9 +245,11 @@ class PositionerBox(BECWidget, QWidget):
             if is_moving:
                 self.ui.spinner_widget.start()
                 self.ui.spinner_widget.setToolTip("Device is moving")
+                self.set_global_state("warning")
             else:
                 self.ui.spinner_widget.stop()
                 self.ui.spinner_widget.setToolTip("Device is idle")
+                self.set_global_state("success")
 
         if readback_val is not None:
             self.ui.readback.setText(f"{readback_val:.{precision}f}")