bec-widgets 1.21.3__py3-none-any.whl → 1.22.0__py3-none-any.whl

CHANGELOG.md

@@ -1,6 +1,54 @@
 # CHANGELOG
 
 
+## v1.22.0 (2025-02-19)
+
+### Bug Fixes
+
+- **modular_toolbar**: Add action to an already existing bundle
+  ([`4c4f159`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4c4f1592c29974bb095c3c8325e93a1383efa289))
+
+- **toolbar**: Qmenu Icons are visible
+  ([`c2c0221`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c2c022154bddc15d81eb55aad912d8fe1e34c698))
+
+- **toolbar**: Update_separators logic updated, there cannot be two separators next to each other
+  ([`facb8c3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/facb8c30ffa3b12a97c7c68f8594b0354372ca17))
+
+- **toolbar**: Widget actions are more compact
+  ([`ef36a71`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ef36a7124d54319c2cd592433c95e4f7513e982e))
+
+### Features
+
+- **toolbar**: Switchabletoolbarbutton
+  ([`333570b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/333570ba2fe67cb51fdbab17718003dfdb7f7b55))
+
+### Refactoring
+
+- **toolbar**: Added dark mode button for testing appearance for the toolbar example
+  ([`6b08f7c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6b08f7cfb2115609a6dc6f681631ecfae23fa899))
+
+### Testing
+
+- **toolbar**: Blocking tests fixed
+  ([`6ae33a2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6ae33a23a62eafb7c820e1fde9d6d91ec1796e55))
+
+
+## v1.21.4 (2025-02-19)
+
+### Bug Fixes
+
+- **colors**: Pyqtgraph styling updated on the app level
+  ([`ae18279`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ae182796855719437bdf911c2e969e3f438d6982))
+
+- **plot_base**: Mouse interactions default state fetch to toolbar
+  ([`97c0ed5`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/97c0ed53df21053fef9811c3dea3b79020137030))
+
+### Refactoring
+
+- **plot_base**: Change the PlotWidget to GraphicalLayoutWidget
+  ([`ff8e282`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ff8e282034f0970b69cf0447fc5f88b4f30bf470))
+
+
 ## v1.21.3 (2025-02-19)
 
 ### Bug Fixes

PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bec_widgets
-Version: 1.21.3
+Version: 1.22.0
 Summary: BEC Widgets
 Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec_widgets/issues
 Project-URL: Homepage, https://gitlab.psi.ch/bec/bec_widgets

bec_widgets/qt_utils/round_frame.py

@@ -1,6 +1,6 @@
 import pyqtgraph as pg
 from qtpy.QtCore import Property
-from qtpy.QtWidgets import QApplication, QFrame, QVBoxLayout, QWidget
+from qtpy.QtWidgets import QApplication, QFrame, QHBoxLayout, QVBoxLayout, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
@@ -31,22 +31,20 @@ class RoundedFrame(BECWidget, QFrame):
         # Apply rounded frame styling
         self.setProperty("skip_settings", True)
         self.setObjectName("roundedFrame")
-        self.update_style()
 
         # Create a layout for the frame
-        layout = QVBoxLayout(self)
-        layout.setContentsMargins(5, 5, 5, 5)  # Set 5px margin
+        self.layout = QHBoxLayout(self)
+        self.layout.setContentsMargins(5, 5, 5, 5)  # Set 5px margin
 
         # Add the content widget to the layout
         if content_widget:
-            layout.addWidget(content_widget)
+            self.layout.addWidget(content_widget)
 
         # Store reference to the content widget
         self.content_widget = content_widget
 
-        # Automatically apply initial styles to the PlotWidget if applicable
-        if isinstance(content_widget, pg.PlotWidget):
-            self.apply_plot_widget_style()
+        # Automatically apply initial styles to the GraphicalLayoutWidget if applicable
+        self.apply_plot_widget_style()
 
         self._connect_to_theme_change()
 
@@ -65,10 +63,6 @@ class RoundedFrame(BECWidget, QFrame):
 
         self.update_style()
 
-        # Update PlotWidget's background color and axis styles if applicable
-        if isinstance(self.content_widget, pg.PlotWidget):
-            self.apply_plot_widget_style()
-
     @Property(int)
     def radius(self):
         """Radius of the rounded corners."""
@@ -92,6 +86,7 @@ class RoundedFrame(BECWidget, QFrame):
                 }}
             """
             )
+        self.apply_plot_widget_style()
 
     def apply_plot_widget_style(self, border: str = "none"):
         """
@@ -100,35 +95,16 @@ class RoundedFrame(BECWidget, QFrame):
         Args:
             border (str): Border style (e.g., 'none', '1px solid red').
         """
-        if isinstance(self.content_widget, pg.PlotWidget):
-            # Sync PlotWidget's background color with the RoundedFrame's background color
-            self.content_widget.setBackground(self.background_color)
-
-            # Calculate contrast-optimized axis and label colors
-            if self.background_color == "#e9ecef":  # Light mode
-                label_color = "#000000"
-                axis_color = "#666666"
-            else:  # Dark mode
-                label_color = "#FFFFFF"
-                axis_color = "#CCCCCC"
-
-            # Apply axis label and tick colors
-            plot_item = self.content_widget.getPlotItem()
-            for axis in ["left", "right", "top", "bottom"]:
-                plot_item.getAxis(axis).setPen(pg.mkPen(color=axis_color))
-                plot_item.getAxis(axis).setTextPen(pg.mkPen(color=label_color))
-
-            # Change title color
-            plot_item.titleLabel.setText(plot_item.titleLabel.text, color=label_color)
-
+        if isinstance(self.content_widget, pg.GraphicsLayoutWidget):
             # Apply border style via stylesheet
             self.content_widget.setStyleSheet(
                 f"""
-                PlotWidget {{
+                GraphicsLayoutWidget {{
                     border: {border}; /* Explicitly set the border */
                 }}
             """
             )
+            self.content_widget.setBackground(self.background_color)
 
 
 class ExampleApp(QWidget):  # pragma: no cover
@@ -142,26 +118,27 @@ class ExampleApp(QWidget):  # pragma: no cover
         dark_button = DarkModeButton()
 
         # Create PlotWidgets
-        plot1 = pg.PlotWidget()
-        plot1.plot([1, 3, 2, 4, 6, 5], pen="r")
+        plot1 = pg.GraphicsLayoutWidget()
+        plot_item_1 = pg.PlotItem()
+        plot_item_1.plot([1, 3, 2, 4, 6, 5], pen="r")
+        plot1.plot_item = plot_item_1
 
-        plot2 = pg.PlotWidget()
-        plot2.plot([1, 2, 4, 8, 16, 32], pen="r")
+        plot2 = pg.GraphicsLayoutWidget()
+        plot_item_2 = pg.PlotItem()
+        plot_item_2.plot([1, 2, 4, 8, 16, 32], pen="r")
+        plot2.plot_item = plot_item_2
 
         # Wrap PlotWidgets in RoundedFrame
         rounded_plot1 = RoundedFrame(content_widget=plot1, theme_update=True)
         rounded_plot2 = RoundedFrame(content_widget=plot2, theme_update=True)
-        round = RoundedFrame()
 
         # Add to layout
         layout.addWidget(dark_button)
         layout.addWidget(rounded_plot1)
         layout.addWidget(rounded_plot2)
-        layout.addWidget(round)
 
         self.setLayout(layout)
 
-        # Simulate theme change after 2 seconds
         from qtpy.QtCore import QTimer
 
         def change_theme():

bec_widgets/qt_utils/toolbar.py

@@ -8,7 +8,7 @@ from collections import defaultdict
 from typing import Dict, List, Literal, Tuple
 
 from bec_qthemes._icon.material_icons import material_icon
-from qtpy.QtCore import QSize, Qt
+from qtpy.QtCore import QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QColor, QIcon
 from qtpy.QtWidgets import (
     QApplication,
@@ -18,15 +18,54 @@ from qtpy.QtWidgets import (
     QMainWindow,
     QMenu,
     QSizePolicy,
+    QStyle,
     QToolBar,
     QToolButton,
+    QVBoxLayout,
     QWidget,
 )
 
 import bec_widgets
+from bec_widgets.utils.colors import set_theme
+from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
 MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
+# Ensure that icons are shown in menus (especially on macOS)
+QApplication.setAttribute(Qt.AA_DontShowIconsInMenus, False)
+
+
+class LongPressToolButton(QToolButton):
+    def __init__(self, *args, long_press_threshold=500, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.long_press_threshold = long_press_threshold
+        self._long_press_timer = QTimer(self)
+        self._long_press_timer.setSingleShot(True)
+        self._long_press_timer.timeout.connect(self.handleLongPress)
+        self._pressed = False
+        self._longPressed = False
+
+    def mousePressEvent(self, event):
+        self._pressed = True
+        self._longPressed = False
+        self._long_press_timer.start(self.long_press_threshold)
+        super().mousePressEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        self._pressed = False
+        if self._longPressed:
+            self._longPressed = False
+            self._long_press_timer.stop()
+            event.accept()  # Prevent normal click action after a long press
+            return
+        self._long_press_timer.stop()
+        super().mouseReleaseEvent(event)
+
+    def handleLongPress(self):
+        if self._pressed:
+            self._longPressed = True
+            self.showMenu()
+
 
 class ToolBarAction(ABC):
     """
@@ -84,6 +123,21 @@ class IconAction(ToolBarAction):
         toolbar.addAction(self.action)
 
 
+class QtIconAction(ToolBarAction):
+    def __init__(self, standard_icon, tooltip=None, checkable=False, parent=None):
+        super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
+        self.standard_icon = standard_icon
+        self.icon = QApplication.style().standardIcon(standard_icon)
+        self.action = QAction(self.icon, self.tooltip, parent)
+        self.action.setCheckable(self.checkable)
+
+    def add_to_toolbar(self, toolbar, target):
+        toolbar.addAction(self.action)
+
+    def get_icon(self):
+        return self.icon
+
+
 class MaterialIconAction(ToolBarAction):
     """
     Action with a Material icon for the toolbar.
@@ -111,7 +165,7 @@ class MaterialIconAction(ToolBarAction):
         self.icon_name = icon_name
         self.filled = filled
         self.color = color
-        # Generate the icon
+        # Generate the icon using the material_icon helper
         self.icon = material_icon(
             self.icon_name,
             size=(20, 20),
@@ -119,7 +173,6 @@ class MaterialIconAction(ToolBarAction):
             filled=self.filled,
             color=self.color,
         )
-        # Immediately create an QAction with the given parent
         self.action = QAction(self.icon, self.tooltip, parent=parent)
         self.action.setCheckable(self.checkable)
 
@@ -152,7 +205,7 @@ class DeviceSelectionAction(ToolBarAction):
         device_combobox (DeviceComboBox): The combobox for selecting the device.
     """
 
-    def __init__(self, label: str, device_combobox):
+    def __init__(self, label: str | None = None, device_combobox=None):
         super().__init__()
         self.label = label
         self.device_combobox = device_combobox
@@ -161,15 +214,99 @@ class DeviceSelectionAction(ToolBarAction):
     def add_to_toolbar(self, toolbar, target):
         widget = QWidget()
         layout = QHBoxLayout(widget)
-        label = QLabel(f"{self.label}")
-        layout.addWidget(label)
-        layout.addWidget(self.device_combobox)
-        toolbar.addWidget(widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        if self.label is not None:
+            label = QLabel(f"{self.label}")
+            layout.addWidget(label)
+        if self.device_combobox is not None:
+            layout.addWidget(self.device_combobox)
+            toolbar.addWidget(widget)
 
     def set_combobox_style(self, color: str):
         self.device_combobox.setStyleSheet(f"QComboBox {{ background-color: {color}; }}")
 
 
+class SwitchableToolBarAction(ToolBarAction):
+    """
+    A split toolbar action that combines a main action and a drop-down menu for additional actions.
+
+    The main button displays the currently selected action's icon and tooltip. Clicking on the main button
+    triggers that action. Clicking on the drop-down arrow displays a menu with alternative actions. When an
+    alternative action is selected, it becomes the new default and its callback is immediately executed.
+
+    This design mimics the behavior seen in Adobe Photoshop or Affinity Designer toolbars.
+
+    Args:
+        actions (dict): A dictionary mapping a unique key to a ToolBarAction instance.
+        initial_action (str, optional): The key of the initial default action. If not provided, the first action is used.
+        tooltip (str, optional): An optional tooltip for the split action; if provided, it overrides the default action's tooltip.
+        checkable (bool, optional): Whether the action is checkable. Defaults to True.
+        parent (QWidget, optional): Parent widget for the underlying QAction.
+    """
+
+    def __init__(
+        self,
+        actions: Dict[str, ToolBarAction],
+        initial_action: str = None,
+        tooltip: str = None,
+        checkable: bool = True,
+        parent=None,
+    ):
+        super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
+        self.actions = actions
+        self.current_key = initial_action if initial_action is not None else next(iter(actions))
+        self.parent = parent
+        self.checkable = checkable
+        self.main_button = None
+        self.menu_actions: Dict[str, QAction] = {}
+
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """
+        Adds the split action to the toolbar.
+
+        Args:
+            toolbar (QToolBar): The toolbar to add the action to.
+            target (QWidget): The target widget for the action.
+        """
+        self.main_button = LongPressToolButton(toolbar)
+        self.main_button.setPopupMode(QToolButton.MenuButtonPopup)
+        self.main_button.setCheckable(self.checkable)
+        default_action = self.actions[self.current_key]
+        self.main_button.setIcon(default_action.get_icon())
+        self.main_button.setToolTip(default_action.tooltip)
+        self.main_button.clicked.connect(self._trigger_current_action)
+        menu = QMenu(self.main_button)
+        self.menu_actions = {}
+        for key, action_obj in self.actions.items():
+            menu_action = QAction(action_obj.get_icon(), action_obj.tooltip, self.main_button)
+            menu_action.setIconVisibleInMenu(True)
+            menu_action.setCheckable(self.checkable)
+            menu_action.setChecked(key == self.current_key)
+            menu_action.triggered.connect(lambda checked, k=key: self._set_default_action(k))
+            menu.addAction(menu_action)
+            self.menu_actions[key] = menu_action
+        self.main_button.setMenu(menu)
+        toolbar.addWidget(self.main_button)
+
+    def _trigger_current_action(self):
+        action_obj = self.actions[self.current_key]
+        action_obj.action.trigger()
+
+    def _set_default_action(self, key: str):
+        self.current_key = key
+        new_action = self.actions[self.current_key]
+        self.main_button.setIcon(new_action.get_icon())
+        self.main_button.setToolTip(new_action.tooltip)
+        # Update check state of menu items
+        for k, menu_act in self.menu_actions.items():
+            menu_act.setChecked(k == key)
+        new_action.action.trigger()
+
+    def get_icon(self) -> QIcon:
+        return self.actions[self.current_key].get_icon()
+
+
 class WidgetAction(ToolBarAction):
     """
     Action for adding any widget to the toolbar.
@@ -180,15 +317,23 @@ class WidgetAction(ToolBarAction):
     """
 
     def __init__(self, label: str | None = None, widget: QWidget = None, parent=None):
-        super().__init__(parent)
+        super().__init__(icon_path=None, tooltip=label, checkable=False)
         self.label = label
         self.widget = widget
+        self.container = None
 
     def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
-        container = QWidget()
-        layout = QHBoxLayout(container)
+        """
+        Adds the widget to the toolbar.
+
+        Args:
+            toolbar (QToolBar): The toolbar to add the widget to.
+            target (QWidget): The target widget for the action.
+        """
+        self.container = QWidget()
+        layout = QHBoxLayout(self.container)
         layout.setContentsMargins(0, 0, 0, 0)
-        layout.setSpacing(5)
+        layout.setSpacing(0)
 
         if self.label is not None:
             label_widget = QLabel(f"{self.label}")
@@ -209,19 +354,12 @@ class WidgetAction(ToolBarAction):
 
         layout.addWidget(self.widget)
 
-        toolbar.addWidget(container)
+        toolbar.addWidget(self.container)
+        # Store the container as the action to allow toggling visibility.
+        self.action = self.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
@@ -261,12 +399,15 @@ class ExpandableMenuAction(ToolBarAction):
         menu = QMenu(button)
         for action_id, action in self.actions.items():
             sub_action = QAction(action.tooltip, target)
-            if hasattr(action, "icon_path"):
+            sub_action.setIconVisibleInMenu(True)
+            if action.icon_path:
                 icon = QIcon()
                 icon.addFile(action.icon_path, size=QSize(20, 20))
                 sub_action.setIcon(icon)
-            elif hasattr(action, "get_icon"):
-                sub_action.setIcon(action.get_icon())
+            elif hasattr(action, "get_icon") and callable(action.get_icon):
+                sub_icon = action.get_icon()
+                if sub_icon and not sub_icon.isNull():
+                    sub_action.setIcon(sub_icon)
             sub_action.setCheckable(action.checkable)
             menu.addAction(sub_action)
             self.widgets[action_id] = sub_action
@@ -289,7 +430,6 @@ class ToolbarBundle:
         self.bundle_id = bundle_id
         self._actions: dict[str, ToolBarAction] = {}
 
-        # If you passed in a list of tuples, load them into the dictionary
         if actions is not None:
             for action_id, action in actions:
                 self._actions[action_id] = action
@@ -331,7 +471,7 @@ class ModularToolBar(QToolBar):
         actions (dict, optional): A dictionary of action creators to populate the toolbar. Defaults to None.
         target_widget (QWidget, optional): The widget that the actions will target. Defaults to None.
         orientation (Literal["horizontal", "vertical"], optional): The initial orientation of the toolbar. Defaults to "horizontal".
-        background_color (str, optional): The background color of the toolbar. Defaults to "rgba(0, 0, 0, 0)" - transparent background.
+        background_color (str, optional): The background color of the toolbar. Defaults to "rgba(0, 0, 0, 0)".
     """
 
     def __init__(
@@ -378,7 +518,7 @@ class ModularToolBar(QToolBar):
         Sets the background color and other appearance settings.
 
         Args:
-            color(str): The background color of the toolbar.
+            color (str): The background color of the toolbar.
         """
         self.setIconSize(QSize(20, 20))
         self.setMovable(False)
@@ -402,100 +542,133 @@ class ModularToolBar(QToolBar):
 
     def update_material_icon_colors(self, new_color: str | tuple | QColor):
         """
-        Updates the color of all MaterialIconAction icons in the toolbar.
+        Updates the color of all MaterialIconAction icons.
 
         Args:
-            new_color (str | tuple | QColor): The new color for the icons.
+            new_color (str | tuple | QColor): The new color.
         """
         for action in self.widgets.values():
             if isinstance(action, MaterialIconAction):
                 action.color = new_color
-                # Refresh the icon
                 updated_icon = action.get_icon()
                 action.action.setIcon(updated_icon)
 
     def add_action(self, action_id: str, action: ToolBarAction, target_widget: QWidget):
         """
-        Adds a new standalone action to the toolbar dynamically.
+        Adds a new standalone action dynamically.
 
         Args:
-            action_id (str): Unique identifier for the action.
-            action (ToolBarAction): The action to add to the toolbar.
-            target_widget (QWidget): The target widget for the action.
+            action_id (str): Unique identifier.
+            action (ToolBarAction): The action to add.
+            target_widget (QWidget): The target widget.
         """
         if action_id in self.widgets:
             raise ValueError(f"Action with ID '{action_id}' already exists.")
         action.add_to_toolbar(self, target_widget)
         self.widgets[action_id] = action
         self.toolbar_items.append(("action", action_id))
-        self.update_separators()  # Update separators after adding the action
+        self.update_separators()
 
     def hide_action(self, action_id: str):
         """
-        Hides a specific action on the toolbar.
+        Hides a specific action.
 
         Args:
-            action_id (str): Unique identifier for the action to hide.
+            action_id (str): Unique identifier.
         """
         if action_id not in self.widgets:
             raise ValueError(f"Action with ID '{action_id}' does not exist.")
         action = self.widgets[action_id]
-        if hasattr(action, "action") and isinstance(action.action, QAction):
+        if hasattr(action, "action") and action.action is not None:
             action.action.setVisible(False)
-            self.update_separators()  # Update separators after hiding the action
+            self.update_separators()
 
     def show_action(self, action_id: str):
         """
-        Shows a specific action on the toolbar.
+        Shows a specific action.
 
         Args:
-            action_id (str): Unique identifier for the action to show.
+            action_id (str): Unique identifier.
         """
         if action_id not in self.widgets:
             raise ValueError(f"Action with ID '{action_id}' does not exist.")
         action = self.widgets[action_id]
-        if hasattr(action, "action") and isinstance(action.action, QAction):
+        if hasattr(action, "action") and action.action is not None:
             action.action.setVisible(True)
-            self.update_separators()  # Update separators after showing the action
+            self.update_separators()
 
     def add_bundle(self, bundle: ToolbarBundle, target_widget: QWidget):
         """
-        Adds a bundle of actions to the toolbar, separated by a separator.
+        Adds a bundle of actions, separated by a separator.
 
         Args:
-            bundle (ToolbarBundle): The bundle to add.
-            target_widget (QWidget): The target widget for the actions.
+            bundle (ToolbarBundle): The bundle.
+            target_widget (QWidget): The target widget.
         """
         if bundle.bundle_id in self.bundles:
             raise ValueError(f"ToolbarBundle with ID '{bundle.bundle_id}' already exists.")
 
-        # Add a separator before the bundle (but not to first one)
         if self.toolbar_items:
             sep = SeparatorAction()
             sep.add_to_toolbar(self, target_widget)
             self.toolbar_items.append(("separator", None))
 
-        # Add each action in the bundle
         for action_id, action_obj in bundle.actions.items():
             action_obj.add_to_toolbar(self, target_widget)
             self.widgets[action_id] = action_obj
 
-        # Register the bundle
         self.bundles[bundle.bundle_id] = list(bundle.actions.keys())
         self.toolbar_items.append(("bundle", bundle.bundle_id))
+        self.update_separators()
+
+    def add_action_to_bundle(self, bundle_id: str, action_id: str, action, target_widget: QWidget):
+        """
+        Dynamically adds an action to an existing bundle.
+
+        Args:
+            bundle_id (str): The bundle ID.
+            action_id (str): Unique identifier.
+            action (ToolBarAction): The action to add.
+            target_widget (QWidget): The target widget.
+        """
+        if bundle_id not in self.bundles:
+            raise ValueError(f"Bundle '{bundle_id}' does not exist.")
+        if action_id in self.widgets:
+            raise ValueError(f"Action with ID '{action_id}' already exists.")
+
+        action.add_to_toolbar(self, target_widget)
+        new_qaction = action.action
+        self.removeAction(new_qaction)
+
+        bundle_action_ids = self.bundles[bundle_id]
+        if bundle_action_ids:
+            last_bundle_action = self.widgets[bundle_action_ids[-1]].action
+            actions_list = self.actions()
+            try:
+                index = actions_list.index(last_bundle_action)
+            except ValueError:
+                self.addAction(new_qaction)
+            else:
+                if index + 1 < len(actions_list):
+                    before_action = actions_list[index + 1]
+                    self.insertAction(before_action, new_qaction)
+                else:
+                    self.addAction(new_qaction)
+        else:
+            self.addAction(new_qaction)
 
-        self.update_separators()  # Update separators after adding the bundle
+        self.widgets[action_id] = action
+        self.bundles[bundle_id].append(action_id)
+        self.update_separators()
 
     def contextMenuEvent(self, event):
         """
-        Overrides the context menu event to show a list of toolbar actions with checkboxes and icons, including separators.
+        Overrides the context menu event to show toolbar actions with checkboxes and icons.
 
         Args:
-            event(QContextMenuEvent): The context menu event.
+            event (QContextMenuEvent): The context menu event.
         """
         menu = QMenu(self)
-
-        # Iterate through the toolbar items in order
         for item_type, identifier in self.toolbar_items:
             if item_type == "separator":
                 menu.addSeparator()
@@ -503,18 +676,16 @@ class ModularToolBar(QToolBar):
                 self.handle_bundle_context_menu(menu, identifier)
             elif item_type == "action":
                 self.handle_action_context_menu(menu, identifier)
-
-        # Connect the triggered signal after all actions are added
         menu.triggered.connect(self.handle_menu_triggered)
         menu.exec_(event.globalPos())
 
     def handle_bundle_context_menu(self, menu: QMenu, bundle_id: str):
         """
-        Adds a set of bundle actions to the context menu.
+        Adds bundle actions to the context menu.
 
         Args:
-            menu (QMenu): The context menu to which the actions are added.
-            bundle_id (str): The identifier for the bundle.
+            menu (QMenu): The context menu.
+            bundle_id (str): The bundle identifier.
         """
         action_ids = self.bundles.get(bundle_id, [])
         for act_id in action_ids:
@@ -535,7 +706,6 @@ class ModularToolBar(QToolBar):
             # Set the icon if available
             if qaction.icon() and not qaction.icon().isNull():
                 menu_action.setIcon(qaction.icon())
-
             menu.addAction(menu_action)
 
     def handle_action_context_menu(self, menu: QMenu, action_id: str):
@@ -565,73 +735,95 @@ class ModularToolBar(QToolBar):
         menu.addAction(menu_action)
 
     def handle_menu_triggered(self, action):
-        """Handles the toggling of toolbar actions from the context menu."""
+        """
+        Handles the triggered signal from the context menu.
+
+        Args:
+            action: Action triggered.
+        """
         action_id = action.data()
         if action_id:
             self.toggle_action_visibility(action_id, action.isChecked())
 
     def toggle_action_visibility(self, action_id: str, visible: bool):
         """
-        Toggles the visibility of a specific action on the toolbar.
+        Toggles the visibility of a specific action.
 
         Args:
-            action_id(str): Unique identifier for the action to toggle.
-            visible(bool): Whether the action should be visible.
+            action_id (str): Unique identifier.
+            visible (bool): Whether the action should be visible.
         """
         if action_id not in self.widgets:
             return
-
         tool_action = self.widgets[action_id]
-        if hasattr(tool_action, "action") and isinstance(tool_action.action, QAction):
+        if hasattr(tool_action, "action") and tool_action.action is not None:
             tool_action.action.setVisible(visible)
             self.update_separators()
 
     def update_separators(self):
         """
-        Hide separators that are adjacent to another separator or have no actions next to them.
+        Hide separators that are adjacent to another separator or have no non-separator actions between them.
         """
         toolbar_actions = self.actions()
-
+        # First pass: set visibility based on surrounding non-separator actions.
         for i, action in enumerate(toolbar_actions):
             if not action.isSeparator():
                 continue
-            # Find the previous visible action
             prev_visible = None
             for j in range(i - 1, -1, -1):
                 if toolbar_actions[j].isVisible():
                     prev_visible = toolbar_actions[j]
                     break
-
-            # Find the next visible action
             next_visible = None
             for j in range(i + 1, len(toolbar_actions)):
                 if toolbar_actions[j].isVisible():
                     next_visible = toolbar_actions[j]
                     break
-
-            # Determine if the separator should be hidden
-            # Hide if both previous and next visible actions are separators or non-existent
             if (prev_visible is None or prev_visible.isSeparator()) and (
                 next_visible is None or next_visible.isSeparator()
             ):
                 action.setVisible(False)
             else:
                 action.setVisible(True)
+        # Second pass: ensure no two visible separators are adjacent.
+        prev = None
+        for action in toolbar_actions:
+            if action.isVisible() and action.isSeparator():
+                if prev and prev.isSeparator():
+                    action.setVisible(False)
+                else:
+                    prev = action
+            else:
+                if action.isVisible():
+                    prev = action
 
 
 class MainWindow(QMainWindow):  # pragma: no cover
     def __init__(self):
         super().__init__()
         self.setWindowTitle("Toolbar / ToolbarBundle Demo")
-
         self.central_widget = QWidget()
         self.setCentralWidget(self.central_widget)
+        self.test_label = QLabel(text="This is a test label.")
+        self.central_widget.layout = QVBoxLayout(self.central_widget)
+        self.central_widget.layout.addWidget(self.test_label)
 
-        # Create a modular toolbar
         self.toolbar = ModularToolBar(parent=self, target_widget=self)
         self.addToolBar(self.toolbar)
 
-        # Example: Add a single bundle
+        self.add_switchable_button_checkable()
+        self.add_switchable_button_non_checkable()
+        self.add_widget_actions()
+        self.add_bundles()
+        self.add_menus()
+
+        # For theme testing
+
+        self.dark_button = DarkModeButton(toolbar=True)
+        dark_mode_action = WidgetAction(label=None, widget=self.dark_button)
+        self.toolbar.add_action("dark_mode", dark_mode_action, self)
+
+    def add_bundles(self):
         home_action = MaterialIconAction(
             icon_name="home", tooltip="Home", checkable=True, parent=self
         )
@@ -651,12 +843,11 @@ class MainWindow(QMainWindow):  # pragma: no cover
         )
         self.toolbar.add_bundle(main_actions_bundle, target_widget=self)
 
-        # Another bundle
         search_action = MaterialIconAction(
-            icon_name="search", tooltip="Search", checkable=True, parent=self
+            icon_name="search", tooltip="Search", checkable=False, parent=self
         )
         help_action = MaterialIconAction(
-            icon_name="help", tooltip="Help", checkable=True, parent=self
+            icon_name="help", tooltip="Help", checkable=False, parent=self
         )
         second_bundle = ToolbarBundle(
             bundle_id="secondary_actions",
@@ -664,9 +855,101 @@ class MainWindow(QMainWindow):  # pragma: no cover
         )
         self.toolbar.add_bundle(second_bundle, target_widget=self)
 
+        new_action = MaterialIconAction(
+            icon_name="counter_1", tooltip="New Action", checkable=True, parent=self
+        )
+        self.toolbar.add_action_to_bundle(
+            "main_actions", "new_action", new_action, target_widget=self
+        )
+
+    def add_menus(self):
+        menu_material_actions = {
+            "mat1": MaterialIconAction(
+                icon_name="home", tooltip="Material Home", checkable=True, parent=self
+            ),
+            "mat2": MaterialIconAction(
+                icon_name="settings", tooltip="Material Settings", checkable=True, parent=self
+            ),
+            "mat3": MaterialIconAction(
+                icon_name="info", tooltip="Material Info", checkable=True, parent=self
+            ),
+        }
+        menu_qt_actions = {
+            "qt1": QtIconAction(
+                standard_icon=QStyle.SP_FileIcon, tooltip="Qt File", checkable=True, parent=self
+            ),
+            "qt2": QtIconAction(
+                standard_icon=QStyle.SP_DirIcon, tooltip="Qt Directory", checkable=True, parent=self
+            ),
+            "qt3": QtIconAction(
+                standard_icon=QStyle.SP_TrashIcon, tooltip="Qt Trash", checkable=True, parent=self
+            ),
+        }
+        expandable_menu_material = ExpandableMenuAction(
+            label="Material Menu", actions=menu_material_actions
+        )
+        expandable_menu_qt = ExpandableMenuAction(label="Qt Menu", actions=menu_qt_actions)
+
+        self.toolbar.add_action("material_menu", expandable_menu_material, self)
+        self.toolbar.add_action("qt_menu", expandable_menu_qt, self)
+
+    def add_switchable_button_checkable(self):
+        action1 = MaterialIconAction(
+            icon_name="counter_1", tooltip="Action 1", checkable=True, parent=self
+        )
+        action2 = MaterialIconAction(
+            icon_name="counter_2", tooltip="Action 2", checkable=True, parent=self
+        )
+
+        switchable_action = SwitchableToolBarAction(
+            actions={"action1": action1, "action2": action2},
+            initial_action="action1",
+            tooltip="Switchable Action",
+            checkable=True,
+            parent=self,
+        )
+        self.toolbar.add_action("switchable_action", switchable_action, self)
+
+        action1.action.toggled.connect(
+            lambda checked: self.test_label.setText(f"Action 1 triggered, checked = {checked}")
+        )
+        action2.action.toggled.connect(
+            lambda checked: self.test_label.setText(f"Action 2 triggered, checked = {checked}")
+        )
+
+    def add_switchable_button_non_checkable(self):
+        action1 = MaterialIconAction(
+            icon_name="counter_1", tooltip="Action 1", checkable=False, parent=self
+        )
+        action2 = MaterialIconAction(
+            icon_name="counter_2", tooltip="Action 2", checkable=False, parent=self
+        )
+
+        switchable_action = SwitchableToolBarAction(
+            actions={"action1": action1, "action2": action2},
+            initial_action="action1",
+            tooltip="Switchable Action",
+            checkable=False,
+            parent=self,
+        )
+        self.toolbar.add_action("switchable_action_no_toggle", switchable_action, self)
+
+        action1.action.triggered.connect(
+            lambda checked: self.test_label.setText(f"Action 1 triggered, checked = {checked}")
+        )
+        action2.action.triggered.connect(
+            lambda checked: self.test_label.setText(f"Action 2 triggered, checked = {checked}")
+        )
+
+    def add_widget_actions(self):
+        combo = QComboBox()
+        combo.addItems(["Option 1", "Option 2", "Option 3"])
+        self.toolbar.add_action("device_combo", WidgetAction(label="Device:", widget=combo), self)
+
 
 if __name__ == "__main__":  # pragma: no cover
     app = QApplication(sys.argv)
+    set_theme("light")
     main_window = MainWindow()
     main_window.show()
     sys.exit(app.exec_())

bec_widgets/utils/bec_widget.py

@@ -66,7 +66,7 @@ class BECWidget(BECConnector):
         if hasattr(qapp, "theme_signal"):
             qapp.theme_signal.theme_updated.connect(self._update_theme)
 
-    def _update_theme(self, theme: str):
+    def _update_theme(self, theme: str | None = None):
         """Update the theme."""
         if theme is None:
             qapp = QApplication.instance()

bec_widgets/utils/colors.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import itertools
 import re
 from typing import TYPE_CHECKING, Literal
 
@@ -71,15 +70,64 @@ def apply_theme(theme: Literal["dark", "light"]):
     Apply the theme to all pyqtgraph widgets. Do not use this function directly. Use set_theme instead.
     """
     app = QApplication.instance()
-    # go through all pyqtgraph widgets and set background
-    children = itertools.chain.from_iterable(
-        top.findChildren(pg.GraphicsLayoutWidget) for top in app.topLevelWidgets()
-    )
-    pg.setConfigOptions(
-        foreground="d" if theme == "dark" else "k", background="k" if theme == "dark" else "w"
-    )
-    for pg_widget in children:
-        pg_widget.setBackground("k" if theme == "dark" else "w")
+    graphic_layouts = [
+        child
+        for top in app.topLevelWidgets()
+        for child in top.findChildren(pg.GraphicsLayoutWidget)
+    ]
+
+    plot_items = [
+        item
+        for gl in graphic_layouts
+        for item in gl.ci.items.keys()  # ci is internal pg.GraphicsLayout that hosts all items
+        if isinstance(item, pg.PlotItem)
+    ]
+
+    histograms = [
+        item
+        for gl in graphic_layouts
+        for item in gl.ci.items.keys()  # ci is internal pg.GraphicsLayout that hosts all items
+        if isinstance(item, pg.HistogramLUTItem)
+    ]
+
+    # Update background color based on the theme
+    if theme == "light":
+        background_color = "#e9ecef"  # Subtle contrast for light mode
+        foreground_color = "#141414"
+        label_color = "#000000"
+        axis_color = "#666666"
+    else:
+        background_color = "#141414"  # Dark mode
+        foreground_color = "#e9ecef"
+        label_color = "#FFFFFF"
+        axis_color = "#CCCCCC"
+
+    # update GraphicsLayoutWidget
+    pg.setConfigOptions(foreground=foreground_color, background=background_color)
+    for pg_widget in graphic_layouts:
+        pg_widget.setBackground(background_color)
+
+    # update PlotItems
+    for plot_item in plot_items:
+        for axis in ["left", "right", "top", "bottom"]:
+            plot_item.getAxis(axis).setPen(pg.mkPen(color=axis_color))
+            plot_item.getAxis(axis).setTextPen(pg.mkPen(color=label_color))
+
+        # Change title color
+        plot_item.titleLabel.setText(plot_item.titleLabel.text, color=label_color)
+
+        # Change legend color
+        if hasattr(plot_item, "legend") and plot_item.legend is not None:
+            plot_item.legend.setLabelTextColor(label_color)
+            # if legend is in plot item and theme is changed, has to be like that because of pg opt logic
+            for sample, label in plot_item.legend.items:
+                label_text = label.text
+                label.setText(label_text, color=label_color)
+
+    # update HistogramLUTItem
+    for histogram in histograms:
+        histogram.axis.setPen(pg.mkPen(color=axis_color))
+        histogram.axis.setTextPen(pg.mkPen(color=label_color))
 
     # now define stylesheet according to theme and apply it
     style = bec_qthemes.load_stylesheet(theme)

bec_widgets/widgets/plots_next_gen/plot_base.py

@@ -11,7 +11,6 @@ from bec_widgets.qt_utils.side_panel import SidePanel
 from bec_widgets.qt_utils.toolbar import MaterialIconAction, ModularToolBar, SeparatorAction
 from bec_widgets.utils import ConnectionConfig, Crosshair, EntryValidator
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import set_theme
 from bec_widgets.utils.fps_counter import FPSCounter
 from bec_widgets.utils.widget_state_manager import WidgetStateManager
 from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
@@ -20,7 +19,7 @@ from bec_widgets.widgets.plots_next_gen.toolbar_bundles.mouse_interactions impor
     MouseInteractionToolbarBundle,
 )
 from bec_widgets.widgets.plots_next_gen.toolbar_bundles.plot_export import PlotExportBundle
-from bec_widgets.widgets.plots_next_gen.toolbar_bundles.save_state import SaveStateBundle
+from bec_widgets.widgets.plots_next_gen.toolbar_bundles.roi_bundle import ROIBundle
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
 logger = bec_logger.logger
@@ -83,8 +82,9 @@ class PlotBase(BECWidget, QWidget):
         self.entry_validator = EntryValidator(self.dev)
 
         # Base widgets elements
+        self.plot_widget = pg.GraphicsLayoutWidget(parent=self)
         self.plot_item = pg.PlotItem(viewBox=BECViewBox(enableMenu=True))
-        self.plot_widget = pg.PlotWidget(plotItem=self.plot_item)
+        self.plot_widget.addItem(self.plot_item)
         self.side_panel = SidePanel(self, orientation="left", panel_max_width=280)
         self.toolbar = ModularToolBar(target_widget=self, orientation="horizontal")
         self.init_toolbar()
@@ -94,13 +94,20 @@ class PlotBase(BECWidget, QWidget):
         self.crosshair = None
         self.fps_monitor = None
         self.fps_label = QLabel(alignment=Qt.AlignmentFlag.AlignRight)
+        self._user_x_label = ""
+        self._x_label_suffix = ""
 
         self._init_ui()
 
+        self._connect_to_theme_change()
+        self._update_theme()
+
+    def apply_theme(self, theme: str):
+        self.round_plot_widget.apply_theme(theme)
+
     def _init_ui(self):
         self.layout.addWidget(self.layout_manager)
         self.round_plot_widget = RoundedFrame(content_widget=self.plot_widget, theme_update=True)
-        self.round_plot_widget.apply_theme("dark")
 
         self.layout_manager.add_widget(self.round_plot_widget)
         self.layout_manager.add_widget_relative(self.fps_label, self.round_plot_widget, "top")
@@ -117,19 +124,15 @@ class PlotBase(BECWidget, QWidget):
 
         self.plot_export_bundle = PlotExportBundle("plot_export", target_widget=self)
         self.mouse_bundle = MouseInteractionToolbarBundle("mouse_interaction", target_widget=self)
-        self.state_export_bundle = SaveStateBundle("state_export", target_widget=self)
+        # self.state_export_bundle = SaveStateBundle("state_export", target_widget=self) #TODO ATM disabled, cannot be used in DockArea, which is exposed to the user
+        self.roi_bundle = ROIBundle("roi", target_widget=self)
 
         # Add elements to toolbar
         self.toolbar.add_bundle(self.plot_export_bundle, target_widget=self)
-        self.toolbar.add_bundle(self.state_export_bundle, target_widget=self)
+        # self.toolbar.add_bundle(self.state_export_bundle, target_widget=self) #TODO ATM disabled, cannot be used in DockArea, which is exposed to the user
         self.toolbar.add_bundle(self.mouse_bundle, target_widget=self)
+        self.toolbar.add_bundle(self.roi_bundle, target_widget=self)
 
-        self.toolbar.add_action("separator_0", SeparatorAction(), target_widget=self)
-        self.toolbar.add_action(
-            "crosshair",
-            MaterialIconAction(icon_name="point_scan", tooltip="Show Crosshair", checkable=True),
-            target_widget=self,
-        )
         self.toolbar.add_action("separator_1", SeparatorAction(), target_widget=self)
         self.toolbar.add_action(
             "fps_monitor",
@@ -141,7 +144,6 @@ class PlotBase(BECWidget, QWidget):
         self.toolbar.widgets["fps_monitor"].action.toggled.connect(
             lambda checked: setattr(self, "enable_fps_monitor", checked)
         )
-        self.toolbar.widgets["crosshair"].action.toggled.connect(self.toggle_crosshair)
 
     def add_side_menus(self):
         """Adds multiple menus to the side panel."""
@@ -256,12 +258,45 @@ class PlotBase(BECWidget, QWidget):
 
     @SafeProperty(str, doc="The text of the x label")
     def x_label(self) -> str:
-        return self.plot_item.getAxis("bottom").labelText
+        return self._user_x_label
 
     @x_label.setter
     def x_label(self, value: str):
-        self.plot_item.setLabel("bottom", text=value)
-        self.property_changed.emit("x_label", value)
+        self._user_x_label = value
+        self._apply_x_label()
+        self.property_changed.emit("x_label", self._user_x_label)
+
+    @property
+    def x_label_suffix(self) -> str:
+        """
+        A read-only (or internal) suffix automatically appended to the user label.
+        Not settable by the user directly from the UI.
+        """
+        return self._x_label_suffix
+
+    def set_x_label_suffix(self, suffix: str):
+        """
+        Public or protected method to update the suffix.
+        The user code or subclass (Waveform) can call this
+        when x_mode changes, but the AxisSettings won't show it.
+        """
+        self._x_label_suffix = suffix
+        self._apply_x_label()
+
+    @property
+    def x_label_combined(self) -> str:
+        """
+        The final label shown on the axis = user portion + suffix.
+        """
+        return self._user_x_label + self._x_label_suffix
+
+    def _apply_x_label(self):
+        """
+        Actually updates the pyqtgraph axis label text to
+        the combined label. Called whenever user label or suffix changes.
+        """
+        final_label = self.x_label_combined
+        self.plot_item.setLabel("bottom", text=final_label)
 
     @SafeProperty(str, doc="The text of the y label")
     def y_label(self) -> str:
@@ -545,6 +580,7 @@ class PlotBase(BECWidget, QWidget):
         self.unhook_crosshair()
         self.unhook_fps_monitor(delete_label=True)
         self.cleanup_pyqtgraph()
+        self.rpc_register.remove_rpc(self)
 
     def cleanup_pyqtgraph(self):
         """Cleanup pyqtgraph items."""
@@ -561,7 +597,6 @@ if __name__ == "__main__":  # pragma: no cover:
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
-    set_theme("dark")
     widget = PlotBase()
     widget.show()
     # Just some example data and parameters to test

bec_widgets/widgets/plots_next_gen/toolbar_bundles/mouse_interactions.py

@@ -55,6 +55,27 @@ class MouseInteractionToolbarBundle(ToolbarBundle):
         auto.action.triggered.connect(self.autorange_plot)
         aspect_ratio.action.toggled.connect(self.lock_aspect_ratio)
 
+        mode = self.get_viewbox_mode()
+        if mode == "PanMode":
+            drag.action.setChecked(True)
+        elif mode == "RectMode":
+            rect.action.setChecked(True)
+
+    def get_viewbox_mode(self) -> str:
+        """
+        Returns the current interaction mode of a PyQtGraph ViewBox.
+
+        Returns:
+            str: "PanMode" if pan is enabled, "RectMode" if zoom is enabled, "Unknown" otherwise.
+        """
+        if self.target_widget:
+            viewbox = self.target_widget.plot_item.getViewBox()
+            if viewbox.getState()["mouseMode"] == 3:
+                return "PanMode"
+            elif viewbox.getState()["mouseMode"] == 1:
+                return "RectMode"
+        return "Unknown"
+
     @SafeSlot(bool)
     def enable_mouse_rectangle_mode(self, checked: bool):
         """

bec_widgets/widgets/plots_next_gen/toolbar_bundles/roi_bundle.py

@@ -0,0 +1,26 @@
+from bec_widgets.qt_utils.toolbar import MaterialIconAction, ToolbarBundle
+
+
+class ROIBundle(ToolbarBundle):
+    """
+    A bundle of actions that are hooked in this constructor itself,
+    so that you can immediately connect the signals and toggle states.
+
+    This bundle is for a toolbar that controls crosshair and ROI interaction.
+    """
+
+    def __init__(self, bundle_id="roi", target_widget=None, **kwargs):
+        super().__init__(bundle_id=bundle_id, actions=[], **kwargs)
+        self.target_widget = target_widget
+
+        # Create each MaterialIconAction with a parent
+        # so the signals can fire even if the toolbar isn't added yet.
+        crosshair = MaterialIconAction(
+            icon_name="point_scan", tooltip="Show Crosshair", checkable=True
+        )
+
+        # Add them to the bundle
+        self.add_action("crosshair", crosshair)
+
+        # Immediately connect signals
+        crosshair.action.toggled.connect(self.target_widget.toggle_crosshair)

{bec_widgets-1.21.3.dist-info → bec_widgets-1.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bec_widgets
-Version: 1.21.3
+Version: 1.22.0
 Summary: BEC Widgets
 Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec_widgets/issues
 Project-URL: Homepage, https://gitlab.psi.ch/bec/bec_widgets

{bec_widgets-1.21.3.dist-info → bec_widgets-1.22.0.dist-info}/RECORD

@@ -2,11 +2,11 @@
 .gitlab-ci.yml,sha256=PuL-FmkTHm7qs467Mh9D8quWcEj4tgEA-UUGDieMuWk,8774
 .pylintrc,sha256=eeY8YwSI74oFfq6IYIbCqnx3Vk8ZncKaatv96n_Y8Rs,18544
 .readthedocs.yaml,sha256=aSOc277LqXcsTI6lgvm_JY80lMlr69GbPKgivua2cS0,603
-CHANGELOG.md,sha256=wa_NuBhhF8FiLGPc83aoatKrjIOevuQGe9cHp8bEXlU,228561
+CHANGELOG.md,sha256=I0VXV76hN6hH8JX7l9F5OXVqbuenWClNEslZF43a6yU,230360
 LICENSE,sha256=YRKe85CBRyP7UpEAWwU8_qSIyuy5-l_9C-HKg5Qm8MQ,1511
-PKG-INFO,sha256=HQ3U74E2VE4lMPxWO5PJv-MeMP9fqpzYZHlsUBxa9Ms,1173
+PKG-INFO,sha256=AoFfQtO1XAwk8aXaYDJs2ZBxHxPbxVKUbwOVXpQAkJw,1173
 README.md,sha256=KgdKusjlvEvFtdNZCeDMO91y77MWK2iDcYMDziksOr4,2553
-pyproject.toml,sha256=uh7Ew520igoYuhlY3qjUeV7ieYJ0n_Dp2IA6kq1ZvzI,2540
+pyproject.toml,sha256=HVH5bV4UEM4smaSNq_bv0FAjv14NavzQ0xGE3K1r_sk,2540
 .git_hooks/pre-commit,sha256=n3RofIZHJl8zfJJIUomcMyYGFi_rwq4CC19z0snz3FI,286
 .gitlab/issue_templates/bug_report_template.md,sha256=gAuyEwl7XlnebBrkiJ9AqffSNOywmr8vygUFWKTuQeI,386
 .gitlab/issue_templates/documentation_update_template.md,sha256=FHLdb3TS_D9aL4CYZCjyXSulbaW5mrN2CmwTaeLPbNw,860
@@ -52,10 +52,10 @@ bec_widgets/qt_utils/compact_popup.py,sha256=3yeb-GJ1PUla5Q_hT0XDKqvyIEH9yV_eGid
 bec_widgets/qt_utils/error_popups.py,sha256=7bL-Lil1G8reQPaRZo8NfG_7Cq2Y0HkF3KREJUE0ZlQ,11545
 bec_widgets/qt_utils/palette_viewer.py,sha256=--B0x7aE7bniHIeuuLY_pH8yBDrTTXaE0IDrC_AM1mo,6326
 bec_widgets/qt_utils/redis_message_waiter.py,sha256=fvL_QgC0cTDv_FPJdRyp5AKjf401EJU4z3r38p47ydY,1745
-bec_widgets/qt_utils/round_frame.py,sha256=JKVEcPY5TAEQcj2XeCyvlMzE41gUWgLaIEDOSQjTC3Y,5812
+bec_widgets/qt_utils/round_frame.py,sha256=ldLQ4BaWygFRrRv1s0w--5qZ4sj8MAqhdXuzho50xMg,4860
 bec_widgets/qt_utils/settings_dialog.py,sha256=NhtzTer_xzlB2lLLrGklkI1QYLJEWQpJoZbCz4o5daI,3645
 bec_widgets/qt_utils/side_panel.py,sha256=H2Ko7FPYwQ2Nemrud-q-rmqzHGO8vly_pzE_ySEfoGQ,12569
-bec_widgets/qt_utils/toolbar.py,sha256=YY_-UGc7uZhahYn7xnTvBGbalmTkpTa4WLikpsHwnMw,24433
+bec_widgets/qt_utils/toolbar.py,sha256=AizwnTiY2RkRJfouJu4nCiFoWd0wEgS_nDF36EiUQjk,35779
 bec_widgets/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bec_widgets/tests/utils.py,sha256=GbQtN7qf9n-8FoAfNddZ4aAqA7oBo_hGAlnKELd6Xzw,6943
 bec_widgets/utils/__init__.py,sha256=1930ji1Jj6dVuY81Wd2kYBhHYNV-2R0bN_L4o9zBj1U,533
@@ -64,8 +64,8 @@ bec_widgets/utils/bec_designer.py,sha256=XBy38NbNMoRDpvRx5lGP2XnJNG34YKZ7I-ARFkn
 bec_widgets/utils/bec_dispatcher.py,sha256=OFmkx9vOz4pA4Sdc14QreyDZ870QYskJ4B5daVVeYg4,6325
 bec_widgets/utils/bec_signal_proxy.py,sha256=56lgrHmKEDxzvhLw5DJcyBVJJUcrPSqQIU1EFQmwutw,3268
 bec_widgets/utils/bec_table.py,sha256=nA2b8ukSeUfquFMAxGrUVOqdrzMoDYD6O_4EYbOG2zk,717
-bec_widgets/utils/bec_widget.py,sha256=1lrHNuvW6uOuPpr-cJBYJNbFekTsqpnQdfTo3P5tbWI,3330
-bec_widgets/utils/colors.py,sha256=zL9ieD_Bsb2ehd6tPpgfkhu1u5qrQRIE4mvoqM2iqko,16546
+bec_widgets/utils/bec_widget.py,sha256=O3JSaKXL3l62EU9sbpsRL8lgnE-aZHkwccuWTSiP7zk,3344
+bec_widgets/utils/colors.py,sha256=8HKIIwQX4P7ND7ITtGWcN8ozG2xT3IBTeYMkneaPBC8,18288
 bec_widgets/utils/container_utils.py,sha256=0wr3ZfuMiAFKCrQHVjxjw-Vuk8wsHdridqcjy2eY840,1531
 bec_widgets/utils/crosshair.py,sha256=baT68rFZjAOoQDC9V3p7vfYhIy1FIMnPNtbnppvjYiM,18141
 bec_widgets/utils/entry_validator.py,sha256=3skJIsUwTYicT76AMHm_M78RiWtUgyD2zb-Rxo2HdHQ,1313
@@ -276,14 +276,15 @@ bec_widgets/widgets/plots/waveform/waveform_popups/curve_dialog/curve_dialog.py,
 bec_widgets/widgets/plots/waveform/waveform_popups/curve_dialog/curve_dialog.ui,sha256=vaOfrygcQp3-H82AkMUHgV2v0Y_TmRO5KLui-bWoado,11056
 bec_widgets/widgets/plots/waveform/waveform_popups/dap_summary_dialog/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bec_widgets/widgets/plots/waveform/waveform_popups/dap_summary_dialog/dap_summary_dialog.py,sha256=78vAXX_x5vi1XMtncOHvTvfgGnZJNSkRjOAnCOBE26U,1047
-bec_widgets/widgets/plots_next_gen/plot_base.py,sha256=WwRp1bKhnFpMkZNDSxNvn2v5YxOxcFH0ISaxeK3KLTg,20941
+bec_widgets/widgets/plots_next_gen/plot_base.py,sha256=epwxSv6vH_RutDPV8jRlA9kq7tc4qUYOsLoeSS9iKAo,22113
 bec_widgets/widgets/plots_next_gen/setting_menus/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bec_widgets/widgets/plots_next_gen/setting_menus/axis_settings.py,sha256=GpgTIYa7t4q9G8hF0rg_qJW2FgbrkvnsMMuqFKJR1fA,3567
 bec_widgets/widgets/plots_next_gen/setting_menus/axis_settings_horizontal.ui,sha256=ye-guaRU_jhu7sHZS-9AjBjLrCtA1msOD0dszu4o9x8,11785
 bec_widgets/widgets/plots_next_gen/setting_menus/axis_settings_vertical.ui,sha256=VR0BgkNAZWRXZPCvX3kMQwM0GLahgM_k2XYmSNbHM64,11235
 bec_widgets/widgets/plots_next_gen/toolbar_bundles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bec_widgets/widgets/plots_next_gen/toolbar_bundles/mouse_interactions.py,sha256=q8Ree9UA6ZPC_Z197aNQOFhNU6cELUdJn_218VoacmM,3195
+bec_widgets/widgets/plots_next_gen/toolbar_bundles/mouse_interactions.py,sha256=tc7v50yS_BYJ_uBFm5lTYJX7gIOZnAr4DRC0wIWXDSk,3924
 bec_widgets/widgets/plots_next_gen/toolbar_bundles/plot_export.py,sha256=9xbpMtaBuY8kvzTSkEeFF52qJloEexHtPbGzU2f2n3s,2361
+bec_widgets/widgets/plots_next_gen/toolbar_bundles/roi_bundle.py,sha256=kgEPk1MYJ0ighSm5T1ri8Hw1t82J4SKMvJLj_witnoQ,979
 bec_widgets/widgets/plots_next_gen/toolbar_bundles/save_state.py,sha256=a7yCJQ_8HVAYN2dHcbxAjo3nJOSUUQZ7RJuUuGCXDBU,1740
 bec_widgets/widgets/progress/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bec_widgets/widgets/progress/bec_progressbar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -355,8 +356,8 @@ bec_widgets/widgets/utility/visual/dark_mode_button/dark_mode_button.py,sha256=Z
 bec_widgets/widgets/utility/visual/dark_mode_button/dark_mode_button.pyproject,sha256=Lbi9zb6HNlIq14k6hlzR-oz6PIFShBuF7QxE6d87d64,34
 bec_widgets/widgets/utility/visual/dark_mode_button/dark_mode_button_plugin.py,sha256=CzChz2SSETYsR8-36meqWnsXCT-FIy_J_xeU5coWDY8,1350
 bec_widgets/widgets/utility/visual/dark_mode_button/register_dark_mode_button.py,sha256=rMpZ1CaoucwobgPj1FuKTnt07W82bV1GaSYdoqcdMb8,521
-bec_widgets-1.21.3.dist-info/METADATA,sha256=HQ3U74E2VE4lMPxWO5PJv-MeMP9fqpzYZHlsUBxa9Ms,1173
-bec_widgets-1.21.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bec_widgets-1.21.3.dist-info/entry_points.txt,sha256=dItMzmwA1wizJ1Itx15qnfJ0ZzKVYFLVJ1voxT7K7D4,214
-bec_widgets-1.21.3.dist-info/licenses/LICENSE,sha256=YRKe85CBRyP7UpEAWwU8_qSIyuy5-l_9C-HKg5Qm8MQ,1511
-bec_widgets-1.21.3.dist-info/RECORD,,
+bec_widgets-1.22.0.dist-info/METADATA,sha256=AoFfQtO1XAwk8aXaYDJs2ZBxHxPbxVKUbwOVXpQAkJw,1173
+bec_widgets-1.22.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bec_widgets-1.22.0.dist-info/entry_points.txt,sha256=dItMzmwA1wizJ1Itx15qnfJ0ZzKVYFLVJ1voxT7K7D4,214
+bec_widgets-1.22.0.dist-info/licenses/LICENSE,sha256=YRKe85CBRyP7UpEAWwU8_qSIyuy5-l_9C-HKg5Qm8MQ,1511
+bec_widgets-1.22.0.dist-info/RECORD,,

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "1.21.3"
+version = "1.22.0"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [