bec-widgets 1.25.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

bec_widgets/widgets/{plots_next_gen → plots}/plot_base.py

@@ -8,22 +8,23 @@ from bec_lib import bec_logger
 from qtpy.QtCore import QPoint, QPointF, Qt, Signal
 from qtpy.QtWidgets import QHBoxLayout, QLabel, QMainWindow, QVBoxLayout, QWidget
 
-from bec_widgets.qt_utils.error_popups import SafeProperty, SafeSlot
-from bec_widgets.qt_utils.round_frame import RoundedFrame
-from bec_widgets.qt_utils.settings_dialog import SettingsDialog
-from bec_widgets.qt_utils.side_panel import SidePanel
-from bec_widgets.qt_utils.toolbar import MaterialIconAction, ModularToolBar, ToolbarBundle
 from bec_widgets.utils import ConnectionConfig, Crosshair, EntryValidator
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.fps_counter import FPSCounter
+from bec_widgets.utils.plot_indicator_items import BECArrowItem, BECTickItem
+from bec_widgets.utils.round_frame import RoundedFrame
+from bec_widgets.utils.settings_dialog import SettingsDialog
+from bec_widgets.utils.side_panel import SidePanel
+from bec_widgets.utils.toolbar import MaterialIconAction, ModularToolBar, ToolbarBundle
 from bec_widgets.utils.widget_state_manager import WidgetStateManager
 from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
-from bec_widgets.widgets.plots_next_gen.setting_menus.axis_settings import AxisSettings
-from bec_widgets.widgets.plots_next_gen.toolbar_bundles.mouse_interactions import (
+from bec_widgets.widgets.plots.setting_menus.axis_settings import AxisSettings
+from bec_widgets.widgets.plots.toolbar_bundles.mouse_interactions import (
     MouseInteractionToolbarBundle,
 )
-from bec_widgets.widgets.plots_next_gen.toolbar_bundles.plot_export import PlotExportBundle
-from bec_widgets.widgets.plots_next_gen.toolbar_bundles.roi_bundle import ROIBundle
+from bec_widgets.widgets.plots.toolbar_bundles.plot_export import PlotExportBundle
+from bec_widgets.widgets.plots.toolbar_bundles.roi_bundle import ROIBundle
 
 logger = bec_logger.logger
 
@@ -68,16 +69,14 @@ class PlotBase(BECWidget, QWidget):
         config: ConnectionConfig | None = None,
         client=None,
         gui_id: str | None = None,
-        popups: bool = False,
+        popups: bool = True,
         **kwargs,
     ) -> None:
         if config is None:
             config = ConnectionConfig(widget_class=self.__class__.__name__)
-        super().__init__(client=client, gui_id=gui_id, config=config, **kwargs)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
 
         # For PropertyManager identification
-        self.setObjectName("PlotBase")
         self.get_bec_shortcuts()
 
         # Layout Management
@@ -95,13 +94,14 @@ class PlotBase(BECWidget, QWidget):
         self.entry_validator = EntryValidator(self.dev)
 
         # Base widgets elements
+        self._popups = popups
         self._ui_mode = UIMode.POPUP if popups else UIMode.SIDE
         self.axis_settings_dialog = None
         self.plot_widget = pg.GraphicsLayoutWidget(parent=self)
         self.plot_item = pg.PlotItem(viewBox=BECViewBox(enableMenu=True))
         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.toolbar = ModularToolBar(parent=self, target_widget=self, orientation="horizontal")
         self._init_toolbar()
 
         # PlotItem Addons
@@ -111,6 +111,12 @@ class PlotBase(BECWidget, QWidget):
         self.fps_label = QLabel(alignment=Qt.AlignmentFlag.AlignRight)
         self._user_x_label = ""
         self._x_label_suffix = ""
+        self._user_y_label = ""
+        self._y_label_suffix = ""
+
+        # Plot Indicator Items
+        self.tick_item = BECTickItem(parent=self, plot_item=self.plot_item)
+        self.arrow_item = BECArrowItem(parent=self, plot_item=self.plot_item)
 
         self._init_ui()
 
@@ -122,7 +128,7 @@ class PlotBase(BECWidget, QWidget):
 
     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 = RoundedFrame(parent=self, content_widget=self.plot_widget)
 
         self.layout_manager.add_widget(self.round_plot_widget)
         self.layout_manager.add_widget_relative(self.fps_label, self.round_plot_widget, "top")
@@ -164,11 +170,14 @@ class PlotBase(BECWidget, QWidget):
         # hide some options by default
         self.toolbar.toggle_action_visibility("fps_monitor", False)
 
+        # Get default viewbox state
+        self.mouse_bundle.get_viewbox_mode()
+
     def add_side_menus(self):
         """Adds multiple menus to the side panel."""
         # Setting Axis Widget
         try:
-            axis_setting = AxisSettings(target_widget=self)
+            axis_setting = AxisSettings(parent=self, target_widget=self)
             self.side_panel.add_menu(
                 action_id="axis",
                 icon_name="settings",
@@ -197,7 +206,7 @@ class PlotBase(BECWidget, QWidget):
         """
         settings_action = self.toolbar.widgets["axis"].action
         if self.axis_settings_dialog is None or not self.axis_settings_dialog.isVisible():
-            axis_setting = AxisSettings(target_widget=self, popup=True)
+            axis_setting = AxisSettings(parent=self, target_widget=self, popup=True)
             self.axis_settings_dialog = SettingsDialog(
                 self, settings_widget=axis_setting, window_title="Axis Settings", modal=False
             )
@@ -218,15 +227,28 @@ class PlotBase(BECWidget, QWidget):
         self.axis_settings_dialog = None
         self.toolbar.widgets["axis"].action.setChecked(False)
 
+    def reset_legend(self):
+        """In the case that the legend is not visible, reset it to be visible to top left corner"""
+        self.plot_item.legend.autoAnchor(50)
+
     ################################################################################
     # Toggle UI Elements
     ################################################################################
     @property
     def ui_mode(self) -> UIMode:
+        """
+        Get the UI mode.
+        """
         return self._ui_mode
 
     @ui_mode.setter
     def ui_mode(self, mode: UIMode):
+        """
+        Set the UI mode.
+
+        Args:
+            mode(UIMode): The UI mode to set.
+        """
         if not isinstance(mode, UIMode):
             raise ValueError("ui_mode must be an instance of UIMode")
         self._ui_mode = mode
@@ -252,10 +274,19 @@ class PlotBase(BECWidget, QWidget):
 
     @SafeProperty(bool, doc="Enable popups setting dialogs for the plot widget.")
     def enable_popups(self):
+        """
+        Enable popups setting dialogs for the plot widget.
+        """
         return self.ui_mode == UIMode.POPUP
 
     @enable_popups.setter
     def enable_popups(self, value: bool):
+        """
+        Set the popups setting dialogs for the plot widget.
+
+        Args:
+            value(bool): The value to set.
+        """
         if value:
             self.ui_mode = UIMode.POPUP
         else:
@@ -264,10 +295,19 @@ class PlotBase(BECWidget, QWidget):
 
     @SafeProperty(bool, doc="Show Side Panel")
     def enable_side_panel(self) -> bool:
+        """
+        Show Side Panel
+        """
         return self.ui_mode == UIMode.SIDE
 
     @enable_side_panel.setter
     def enable_side_panel(self, value: bool):
+        """
+        Show Side Panel
+
+        Args:
+            value(bool): The value to set.
+        """
         if value:
             self.ui_mode = UIMode.SIDE
         else:
@@ -276,33 +316,36 @@ class PlotBase(BECWidget, QWidget):
 
     @SafeProperty(bool, doc="Show Toolbar")
     def enable_toolbar(self) -> bool:
+        """
+        Show Toolbar.
+        """
         return self.toolbar.isVisible()
 
     @enable_toolbar.setter
     def enable_toolbar(self, value: bool):
-        if value:
-            # Disable popup mode
-            if self._popups:
-                # Directly update the internal flag to avoid recursion
-                self._popups = False
-            # Hide the popup bundle if it exists and close any open dialogs
-            if self.popup_bundle is not None:
-                for action in self.toolbar.bundles["popup_bundle"].actions:
-                    action.setVisible(False)
-                if self.axis_settings_dialog is not None and self.axis_settings_dialog.isVisible():
-                    self.axis_settings_dialog.close()
-            self.side_panel.show()
-            # Add side menus if not already added
-            self.add_side_menus()
-        else:
-            self.side_panel.hide()
+        """
+        Show Toolbar.
+
+        Args:
+            value(bool): The value to set.
+        """
+        self.toolbar.setVisible(value)
 
     @SafeProperty(bool, doc="Enable the FPS monitor.")
     def enable_fps_monitor(self) -> bool:
+        """
+        Enable the FPS monitor.
+        """
         return self.fps_label.isVisible()
 
     @enable_fps_monitor.setter
     def enable_fps_monitor(self, value: bool):
+        """
+        Enable the FPS monitor.
+
+        Args:
+            value(bool): The value to set.
+        """
         if value and self.fps_monitor is None:
             self.hook_fps_monitor()
         elif not value and self.fps_monitor is not None:
@@ -341,6 +384,14 @@ class PlotBase(BECWidget, QWidget):
             **kwargs: Keyword arguments for the properties to be set.
 
         Possible properties:
+            - title: str
+            - x_label: str
+            - y_label: str
+            - x_scale: Literal["linear", "log"]
+            - y_scale: Literal["linear", "log"]
+            - x_lim: tuple
+            - y_lim: tuple
+            - legend_label_size: int
 
         """
         property_map = {
@@ -369,19 +420,37 @@ class PlotBase(BECWidget, QWidget):
 
     @SafeProperty(str, doc="The title of the axes.")
     def title(self) -> str:
+        """
+        Set title of the plot.
+        """
         return self.plot_item.titleLabel.text
 
     @title.setter
     def title(self, value: str):
+        """
+        Set title of the plot.
+
+        Args:
+            value(str): The title to set.
+        """
         self.plot_item.setTitle(value)
         self.property_changed.emit("title", value)
 
     @SafeProperty(str, doc="The text of the x label")
     def x_label(self) -> str:
+        """
+        The set label for the x-axis.
+        """
         return self._user_x_label
 
     @x_label.setter
     def x_label(self, value: str):
+        """
+        The set label for the x-axis.
+
+        Args:
+            value(str): The label to set.
+        """
         self._user_x_label = value
         self._apply_x_label()
         self.property_changed.emit("x_label", self._user_x_label)
@@ -416,17 +485,57 @@ class PlotBase(BECWidget, QWidget):
         the combined label. Called whenever user label or suffix changes.
         """
         final_label = self.x_label_combined
-        self.plot_item.setLabel("bottom", text=final_label)
+        if self.plot_item.getAxis("bottom").isVisible():
+            self.plot_item.setLabel("bottom", text=final_label)
 
     @SafeProperty(str, doc="The text of the y label")
     def y_label(self) -> str:
-        return self.plot_item.getAxis("left").labelText
+        """
+        The set label for the y-axis.
+        """
+        return self._user_y_label
 
     @y_label.setter
     def y_label(self, value: str):
-        self.plot_item.setLabel("left", text=value)
+        """
+        The set label for the y-axis.
+        Args:
+            value(str): The label to set.
+        """
+        self._user_y_label = value
+        self._apply_y_label()
         self.property_changed.emit("y_label", value)
 
+    @property
+    def y_label_suffix(self) -> str:
+        """
+        A read-only suffix automatically appended to the y label.
+        """
+        return self._y_label_suffix
+
+    def set_y_label_suffix(self, suffix: str):
+        """
+        Public method to update the y label suffix.
+        """
+        self._y_label_suffix = suffix
+        self._apply_y_label()
+
+    @property
+    def y_label_combined(self) -> str:
+        """
+        The final y label shown on the axis = user portion + suffix.
+        """
+        return self._user_y_label + self._y_label_suffix
+
+    def _apply_y_label(self):
+        """
+        Actually updates the pyqtgraph y axis label text to
+        the combined y label. Called whenever y label or suffix changes.
+        """
+        final_label = self.y_label_combined
+        if self.plot_item.getAxis("bottom").isVisible():
+            self.plot_item.setLabel("left", text=final_label)
+
     def _tuple_to_qpointf(self, tuple: tuple | list):
         """
         Helper function to convert a tuple to a QPointF.
@@ -452,37 +561,74 @@ class PlotBase(BECWidget, QWidget):
 
     @SafeProperty("QPointF")
     def x_limits(self) -> QPointF:
+        """
+        Get the x limits of the plot.
+        """
         current_lim = self.plot_item.vb.viewRange()[0]
         return QPointF(current_lim[0], current_lim[1])
 
     @x_limits.setter
     def x_limits(self, value):
+        """
+        Set the x limits of the plot.
+
+        Args:
+            value(QPointF|tuple|list): The x limits to set.
+        """
         if isinstance(value, (tuple, list)):
             value = self._tuple_to_qpointf(value)
         self.plot_item.vb.setXRange(value.x(), value.y(), padding=0)
 
     @property
     def x_lim(self) -> tuple:
+        """
+        Get the x limits of the plot.
+        """
         return (self.x_limits.x(), self.x_limits.y())
 
     @x_lim.setter
     def x_lim(self, value):
+        """
+        Set the x limits of the plot.
+
+        Args:
+            value(tuple): The x limits to set.
+        """
         self.x_limits = value
 
     @property
     def x_min(self) -> float:
+        """
+        Get the minimum x limit of the plot.
+
+        """
         return self.x_limits.x()
 
     @x_min.setter
     def x_min(self, value: float):
+        """
+        Set the minimum x limit of the plot.
+
+        Args:
+            value(float): The minimum x limit to set.
+        """
         self.x_limits = (value, self.x_lim[1])
 
     @property
     def x_max(self) -> float:
+        """
+        Get the maximum x limit of the plot.
+        """
         return self.x_limits.y()
 
     @x_max.setter
     def x_max(self, value: float):
+        """
+        Set the maximum x limit of the plot.
+
+        Args:
+            value(float): The maximum x limit to set.
+        """
         self.x_limits = (self.x_lim[0], value)
 
     ################################################################################
@@ -491,121 +637,243 @@ class PlotBase(BECWidget, QWidget):
 
     @SafeProperty("QPointF")
     def y_limits(self) -> QPointF:
+        """
+        Get the y limits of the plot.
+        """
         current_lim = self.plot_item.vb.viewRange()[1]
         return QPointF(current_lim[0], current_lim[1])
 
     @y_limits.setter
     def y_limits(self, value):
+        """
+        Set the y limits of the plot.
+
+        Args:
+            value(QPointF|tuple|list): The y limits to set.
+        """
         if isinstance(value, (tuple, list)):
             value = self._tuple_to_qpointf(value)
         self.plot_item.vb.setYRange(value.x(), value.y(), padding=0)
 
     @property
     def y_lim(self) -> tuple:
+        """
+        Get the y limits of the plot.
+        """
         return (self.y_limits.x(), self.y_limits.y())
 
     @y_lim.setter
     def y_lim(self, value):
+        """
+        Set the y limits of the plot.
+
+        Args:
+            value(tuple): The y limits to set.
+        """
         self.y_limits = value
 
     @property
     def y_min(self) -> float:
+        """
+        Get the minimum y limit of the plot.
+        """
         return self.y_limits.x()
 
     @y_min.setter
     def y_min(self, value: float):
+        """
+        Set the minimum y limit of the plot.
+
+        Args:
+            value(float): The minimum y limit to set.
+        """
         self.y_limits = (value, self.y_lim[1])
 
     @property
     def y_max(self) -> float:
+        """
+        Get the maximum y limit of the plot.
+        """
         return self.y_limits.y()
 
     @y_max.setter
     def y_max(self, value: float):
+        """
+        Set the maximum y limit of the plot.
+
+        Args:
+            value(float): The maximum y limit to set.
+        """
         self.y_limits = (self.y_lim[0], value)
 
     @SafeProperty(bool, doc="Show grid on the x-axis.")
     def x_grid(self) -> bool:
+        """
+        Show grid on the x-axis.
+        """
         return self.plot_item.ctrl.xGridCheck.isChecked()
 
     @x_grid.setter
     def x_grid(self, value: bool):
+        """
+        Show grid on the x-axis.
+
+        Args:
+            value(bool): The value to set.
+        """
         self.plot_item.showGrid(x=value)
         self.property_changed.emit("x_grid", value)
 
     @SafeProperty(bool, doc="Show grid on the y-axis.")
     def y_grid(self) -> bool:
+        """
+        Show grid on the y-axis.
+        """
         return self.plot_item.ctrl.yGridCheck.isChecked()
 
     @y_grid.setter
     def y_grid(self, value: bool):
+        """
+        Show grid on the y-axis.
+
+        Args:
+            value(bool): The value to set.
+        """
         self.plot_item.showGrid(y=value)
         self.property_changed.emit("y_grid", value)
 
     @SafeProperty(bool, doc="Set X-axis to log scale if True, linear if False.")
     def x_log(self) -> bool:
+        """
+        Set X-axis to log scale if True, linear if False.
+        """
         return bool(self.plot_item.vb.state.get("logMode", [False, False])[0])
 
     @x_log.setter
     def x_log(self, value: bool):
+        """
+        Set X-axis to log scale if True, linear if False.
+
+        Args:
+            value(bool): The value to set.
+        """
         self.plot_item.setLogMode(x=value)
         self.property_changed.emit("x_log", value)
 
     @SafeProperty(bool, doc="Set Y-axis to log scale if True, linear if False.")
     def y_log(self) -> bool:
+        """
+        Set Y-axis to log scale if True, linear if False.
+        """
         return bool(self.plot_item.vb.state.get("logMode", [False, False])[1])
 
     @y_log.setter
     def y_log(self, value: bool):
+        """
+        Set Y-axis to log scale if True, linear if False.
+
+        Args:
+            value(bool): The value to set.
+        """
         self.plot_item.setLogMode(y=value)
         self.property_changed.emit("y_log", value)
 
     @SafeProperty(bool, doc="Show the outer axes of the plot widget.")
     def outer_axes(self) -> bool:
+        """
+        Show the outer axes of the plot widget.
+        """
         return self.plot_item.getAxis("top").isVisible()
 
     @outer_axes.setter
     def outer_axes(self, value: bool):
+        """
+        Show the outer axes of the plot widget.
+
+        Args:
+            value(bool): The value to set.
+        """
         self.plot_item.showAxis("top", value)
         self.plot_item.showAxis("right", value)
         self.property_changed.emit("outer_axes", value)
 
     @SafeProperty(bool, doc="Show inner axes of the plot widget.")
     def inner_axes(self) -> bool:
+        """
+        Show inner axes of the plot widget.
+        """
         return self.plot_item.getAxis("bottom").isVisible()
 
     @inner_axes.setter
     def inner_axes(self, value: bool):
+        """
+        Show inner axes of the plot widget.
+
+        Args:
+            value(bool): The value to set.
+        """
         self.plot_item.showAxis("bottom", value)
         self.plot_item.showAxis("left", value)
+        self._apply_x_label()
+        self._apply_y_label()
         self.property_changed.emit("inner_axes", value)
 
     @SafeProperty(bool, doc="Lock aspect ratio of the plot widget.")
     def lock_aspect_ratio(self) -> bool:
+        """
+        Lock aspect ratio of the plot widget.
+        """
         return bool(self.plot_item.vb.getState()["aspectLocked"])
 
     @lock_aspect_ratio.setter
     def lock_aspect_ratio(self, value: bool):
+        """
+        Lock aspect ratio of the plot widget.
+
+        Args:
+            value(bool): The value to set.
+        """
         self.plot_item.setAspectLocked(value)
 
     @SafeProperty(bool, doc="Set auto range for the x-axis.")
     def auto_range_x(self) -> bool:
+        """
+        Set auto range for the x-axis.
+        """
         return bool(self.plot_item.vb.getState()["autoRange"][0])
 
     @auto_range_x.setter
     def auto_range_x(self, value: bool):
+        """
+        Set auto range for the x-axis.
+
+        Args:
+            value(bool): The value to set.
+        """
         self.plot_item.enableAutoRange(x=value)
 
     @SafeProperty(bool, doc="Set auto range for the y-axis.")
     def auto_range_y(self) -> bool:
+        """
+        Set auto range for the y-axis.
+        """
         return bool(self.plot_item.vb.getState()["autoRange"][1])
 
     @auto_range_y.setter
     def auto_range_y(self, value: bool):
+        """
+        Set auto range for the y-axis.
+
+        Args:
+            value(bool): The value to set.
+        """
         self.plot_item.enableAutoRange(y=value)
 
     @SafeProperty(int, doc="The font size of the legend font.")
     def legend_label_size(self) -> int:
+        """
+        The font size of the legend font.
+        """
         if not self.plot_item.legend:
             return
         scale = self.plot_item.legend.scale() * 9
@@ -613,6 +881,12 @@ class PlotBase(BECWidget, QWidget):
 
     @legend_label_size.setter
     def legend_label_size(self, value: int):
+        """
+        The font size of the legend font.
+
+        Args:
+            value(int): The font size to set.
+        """
         if not self.plot_item.legend:
             return
         scale = (
@@ -699,12 +973,19 @@ class PlotBase(BECWidget, QWidget):
     def cleanup(self):
         self.unhook_crosshair()
         self.unhook_fps_monitor(delete_label=True)
+        self.tick_item.cleanup()
+        self.arrow_item.cleanup()
+        if self.axis_settings_dialog is not None:
+            self.axis_settings_dialog.close()
+            self.axis_settings_dialog = None
         self.cleanup_pyqtgraph()
-        self.rpc_register.remove_rpc(self)
+        self.round_plot_widget.close()
+        super().cleanup()
 
-    def cleanup_pyqtgraph(self):
+    def cleanup_pyqtgraph(self, item: pg.PlotItem | None = None):
         """Cleanup pyqtgraph items."""
-        item = self.plot_item
+        if item is None:
+            item = self.plot_item
         item.vb.menu.close()
         item.vb.menu.deleteLater()
         item.ctrlMenu.close()
@@ -738,7 +1019,7 @@ if __name__ == "__main__":  # pragma: no cover:
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
-    window = DemoPlotBase()
+    window = PlotBase()
     window.show()
 
     sys.exit(app.exec_())