bec-widgets 0.103.0__py3-none-any.whl → 0.105.0__py3-none-any.whl

bec_widgets/widgets/device_browser/device_item/device_item.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from bec_lib.logger import bec_logger
 from qtpy.QtCore import QMimeData, Qt
 from qtpy.QtGui import QDrag
 from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget
@@ -9,6 +10,8 @@ from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget
 if TYPE_CHECKING:
     from qtpy.QtGui import QMouseEvent
 
+logger = bec_logger.logger
+
 
 class DeviceItem(QWidget):
     def __init__(self, device: str) -> None:
@@ -37,7 +40,7 @@ class DeviceItem(QWidget):
             drag.exec_(Qt.MoveAction)
 
     def mouseDoubleClickEvent(self, event: QMouseEvent) -> None:
-        print("Double Clicked")
+        logger.debug("Double Clicked")
         # TODO: Implement double click action for opening the device properties dialog
         return super().mouseDoubleClickEvent(event)
 

bec_widgets/widgets/figure/figure.py

@@ -7,6 +7,7 @@ from typing import Literal, Optional
 
 import numpy as np
 import pyqtgraph as pg
+from bec_lib.logger import bec_logger
 from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtWidgets import QWidget
@@ -20,6 +21,8 @@ from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap, Mo
 from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
 from bec_widgets.widgets.figure.plots.waveform.waveform import BECWaveform, Waveform1DConfig
 
+logger = bec_logger.logger
+
 
 class FigureConfig(ConnectionConfig):
     """Configuration for BECFigure. Inheriting from ConnectionConfig widget_class and gui_id"""
@@ -179,7 +182,7 @@ class BECFigure(BECWidget, pg.GraphicsLayoutWidget):
             try:
                 config = FigureConfig(**config)
             except ValidationError as e:
-                print(f"Error in applying config: {e}")
+                logger.error(f"Error in applying config: {e}")
                 return
         self.config = config
 

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

@@ -5,6 +5,7 @@ from typing import Any, Literal, Optional
 
 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.QtWidgets import QWidget
@@ -19,6 +20,8 @@ from bec_widgets.widgets.figure.plots.image.image_processor import (
 )
 from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
 
+logger = bec_logger.logger
+
 
 class ImageConfig(SubplotConfig):
     images: dict[str, ImageItemConfig] = Field(
@@ -130,7 +133,7 @@ class BECImageShow(BECPlotBase):
             try:
                 config = ImageConfig(**config)
             except ValidationError as e:
-                print(f"Validation error when applying config to BECImageShow: {e}")
+                logger.error(f"Validation error when applying config to BECImageShow: {e}")
                 return
         self.config = config
         self.plot_item.clear()

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

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Literal, Optional
 
 import numpy as np
 import pyqtgraph as pg
+from bec_lib.logger import bec_logger
 from pydantic import Field
 
 from bec_widgets.utils import BECConnector, ConnectionConfig
@@ -12,6 +13,8 @@ from bec_widgets.widgets.figure.plots.image.image_processor import ImageStats, P
 if TYPE_CHECKING:
     from bec_widgets.widgets.figure.plots.image.image import BECImageShow
 
+logger = bec_logger.logger
+
 
 class ImageItemConfig(ConnectionConfig):
     parent_id: Optional[str] = Field(None, description="The parent plot of the image.")
@@ -133,7 +136,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
             if key in method_map:
                 method_map[key](value)
             else:
-                print(f"Warning: '{key}' is not a recognized property.")
+                logger.warning(f"Warning: '{key}' is not a recognized property.")
 
     def set_fft(self, enable: bool = False):
         """

bec_widgets/widgets/figure/plots/motor_map/motor_map.py

@@ -6,6 +6,7 @@ from typing import Optional, Union
 import numpy as np
 import pyqtgraph as pg
 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
 from pydantic import Field, ValidationError, field_validator
 from pydantic_core import PydanticCustomError
 from qtpy import QtCore, QtGui
@@ -17,6 +18,8 @@ from bec_widgets.utils import Colors, EntryValidator
 from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
 from bec_widgets.widgets.figure.plots.waveform.waveform import Signal, SignalData
 
+logger = bec_logger.logger
+
 
 class MotorMapConfig(SubplotConfig):
     signals: Optional[Signal] = Field(None, description="Signals of the motor map")
@@ -101,7 +104,7 @@ class BECMotorMap(BECPlotBase):
             try:
                 config = MotorMapConfig(**config)
             except ValidationError as e:
-                print(f"Error in applying config: {e}")
+                logger.error(f"Error in applying config: {e}")
                 return
 
         self.config = config
@@ -440,7 +443,7 @@ class BECMotorMap(BECPlotBase):
             return limits
         except AttributeError:  # TODO maybe not needed, if no limits it returns [0,0]
             # If the motor doesn't have a 'limits' attribute, return a default value or raise a custom exception
-            print(f"The device '{motor}' does not have defined limits.")
+            logger.error(f"The device '{motor}' does not have defined limits.")
             return None
 
     @Slot()

bec_widgets/widgets/figure/plots/plot_base.py

@@ -4,6 +4,7 @@ from typing import Literal, Optional
 
 import bec_qthemes
 import pyqtgraph as pg
+from bec_lib.logger import bec_logger
 from pydantic import BaseModel, Field
 from qtpy.QtCore import Signal, Slot
 from qtpy.QtWidgets import QApplication, QWidget
@@ -11,6 +12,8 @@ from qtpy.QtWidgets import QApplication, QWidget
 from bec_widgets.utils import BECConnector, ConnectionConfig
 from bec_widgets.utils.crosshair import Crosshair
 
+logger = bec_logger.logger
+
 
 class AxisConfig(BaseModel):
     title: Optional[str] = Field(None, description="The title of the axes.")
@@ -164,7 +167,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
             if key in method_map:
                 method_map[key](value)
             else:
-                print(f"Warning: '{key}' is not a recognized property.")
+                logger.warning(f"Warning: '{key}' is not a recognized property.")
 
     def apply_axis_config(self):
         """Apply the axis configuration to the plot widget."""

bec_widgets/widgets/figure/plots/waveform/waveform.py

@@ -8,6 +8,7 @@ import pyqtgraph as pg
 from bec_lib import messages
 from bec_lib.device import ReadoutPriority
 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
 from pydantic import Field, ValidationError, field_validator
 from pyqtgraph.exporters import MatplotlibExporter
 from qtpy.QtCore import Signal as pyqtSignal
@@ -23,6 +24,8 @@ from bec_widgets.widgets.figure.plots.waveform.waveform_curve import (
     SignalData,
 )
 
+logger = bec_logger.logger
+
 
 class Waveform1DConfig(SubplotConfig):
     color_palette: Optional[str] = Field(
@@ -139,7 +142,7 @@ class BECWaveform(BECPlotBase):
             try:
                 config = Waveform1DConfig(**config)
             except ValidationError as e:
-                print(f"Validation error when applying config to BECWaveform1D: {e}")
+                logger.error(f"Validation error when applying config to BECWaveform1D: {e}")
                 return
 
         self.config = config
@@ -553,7 +556,7 @@ class BECWaveform(BECPlotBase):
                 format="HEX",
             )[len(self.plot_item.curves)]
         )
-        print(f"Color: {color}")
+        logger.info(f"Color: {color}")
 
         # Create curve by config
         curve_config = CurveConfig(
@@ -1291,7 +1294,7 @@ class BECWaveform(BECPlotBase):
             try:
                 self.scan_id = self.queue.scan_storage.storage[scan_index].scan_id
             except IndexError:
-                print(f"Scan index {scan_index} out of range.")
+                logger.error(f"Scan index {scan_index} out of range.")
                 return
         elif scan_id is not None:
             self.scan_id = scan_id
@@ -1317,7 +1320,7 @@ class BECWaveform(BECPlotBase):
         except ImportError:
             pd = None
             if output == "pandas":
-                print(
+                logger.warning(
                     "Pandas is not installed. "
                     "Please install pandas using 'pip install pandas'."
                     "Output will be dictionary instead."

bec_widgets/widgets/figure/plots/waveform/waveform_curve.py

@@ -4,8 +4,8 @@ from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import numpy as np
 import pyqtgraph as pg
+from bec_lib.logger import bec_logger
 from pydantic import BaseModel, Field, field_validator
-from pydantic_core import PydanticCustomError
 from qtpy import QtCore
 
 from bec_widgets.utils import BECConnector, Colors, ConnectionConfig
@@ -13,6 +13,8 @@ from bec_widgets.utils import BECConnector, Colors, ConnectionConfig
 if TYPE_CHECKING:
     from bec_widgets.widgets.figure.plots.waveform import BECWaveform1D
 
+logger = bec_logger.logger
+
 
 class SignalData(BaseModel):
     """The data configuration of a signal in the 1D waveform widget for x and y axis."""
@@ -177,7 +179,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
             if key in method_map:
                 method_map[key](value)
             else:
-                print(f"Warning: '{key}' is not a recognized property.")
+                logger.warning(f"Warning: '{key}' is not a recognized property.")
 
     def set_color(self, color: str, symbol_color: Optional[str] = None):
         """

bec_widgets/widgets/ring_progress_bar/ring_progress_bar.py

@@ -4,6 +4,7 @@ from typing import Literal, Optional
 
 import pyqtgraph as pg
 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
 from pydantic import Field, field_validator
 from pydantic_core import PydanticCustomError
 from qtpy import QtCore, QtGui
@@ -14,6 +15,8 @@ from bec_widgets.utils import Colors, ConnectionConfig, EntryValidator
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.widgets.ring_progress_bar.ring import Ring, RingConfig
 
+logger = bec_logger.logger
+
 
 class RingProgressBarConfig(ConnectionConfig):
     color_map: Optional[str] = Field(
@@ -38,7 +41,7 @@ class RingProgressBarConfig(ConnectionConfig):
         min_number_of_bars = values.data.get("min_number_of_bars", None)
         max_number_of_bars = values.data.get("max_number_of_bars", None)
         if min_number_of_bars is not None and max_number_of_bars is not None:
-            print(
+            logger.info(
                 f"Number of bars adjusted to be between defined min:{min_number_of_bars} and max:{max_number_of_bars} number of bars."
             )
             v = max(min_number_of_bars, min(v, max_number_of_bars))
@@ -318,7 +321,7 @@ class RingProgressBar(BECWidget, QWidget):
             ring = self._find_ring_by_index(ring_index)
             if isinstance(values, list):
                 values = values[0]
-                print(
+                logger.warning(
                     f"Warning: Only a single value can be set for a single progress bar. Using the first value in the list {values}"
                 )
             ring.set_value(values)
@@ -380,7 +383,7 @@ class RingProgressBar(BECWidget, QWidget):
             ring = self._find_ring_by_index(bar_index)
             if isinstance(widths, list):
                 widths = widths[0]
-                print(
+                logger.warning(
                     f"Warning: Only a single line width can be set for a single progress bar. Using the first value in the list {widths}"
                 )
             ring.set_line_width(widths)
@@ -487,7 +490,7 @@ class RingProgressBar(BECWidget, QWidget):
                         for index, device in enumerate(devices):
                             self._hook_readback(index, device, start[index], end[index])
                     else:
-                        print(f"{instruction_type} not supported yet.")
+                        logger.error(f"{instruction_type} not supported yet.")
 
                     # elif instruction_type == "device_progress":
                     #     print("hook device_progress")
@@ -609,7 +612,7 @@ class RingProgressBar(BECWidget, QWidget):
         Calculate the minimum size of the widget.
         """
         if not self.config.rings:
-            print("no rings to get size from setting size to 10x10")
+            logger.warning("no rings to get size from setting size to 10x10")
             return QSize(10, 10)
         ring_widths = [self.config.rings[i].line_width for i in range(self.config.num_bars)]
         total_width = sum(ring_widths) + self.config.gap * (self.config.num_bars - 1)

bec_widgets/widgets/scan_control/scan_control.py

@@ -1,21 +1,39 @@
+from collections import defaultdict
+from typing import Optional
+
 from bec_lib.endpoints import MessageEndpoints
+from pydantic import BaseModel, Field
 from qtpy.QtCore import Property, Signal, Slot
 from qtpy.QtWidgets import (
     QApplication,
     QComboBox,
-    QGridLayout,
     QGroupBox,
     QHBoxLayout,
+    QLabel,
     QPushButton,
     QSizePolicy,
     QVBoxLayout,
     QWidget,
 )
 
+from bec_widgets.qt_utils.error_popups import SafeSlot
+from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import apply_theme
 from bec_widgets.widgets.scan_control.scan_group_box import ScanGroupBox
 from bec_widgets.widgets.stop_button.stop_button import StopButton
+from bec_widgets.widgets.toggle.toggle import ToggleSwitch
+
+
+class ScanParameterConfig(BaseModel):
+    name: str
+    args: Optional[list] = Field(None)
+    kwargs: Optional[dict] = Field(None)
+
+
+class ScanControlConfig(ConnectionConfig):
+    default_scan: Optional[str] = Field(None)
+    allowed_scans: Optional[list] = Field(None)
+    scans: Optional[dict[str, ScanParameterConfig]] = defaultdict(dict)
 
 
 class ScanControl(BECWidget, QWidget):
@@ -26,9 +44,20 @@ class ScanControl(BECWidget, QWidget):
     scan_selected = Signal(str)
 
     def __init__(
-        self, parent=None, client=None, gui_id: str | None = None, allowed_scans: list | None = None
+        self,
+        parent=None,
+        client=None,
+        config: ScanControlConfig | dict | None = None,
+        gui_id: str | None = None,
+        allowed_scans: list | None = None,
+        default_scan: str | None = None,
     ):
-        super().__init__(client=client, gui_id=gui_id)
+
+        if config is None:
+            config = ScanControlConfig(
+                widget_class=self.__class__.__name__, allowed_scans=allowed_scans
+            )
+        super().__init__(client=client, gui_id=gui_id, config=config)
         QWidget.__init__(self, parent=parent)
 
         # Client from BEC + shortcuts to device manager and scans
@@ -36,12 +65,16 @@ class ScanControl(BECWidget, QWidget):
 
         # Main layout
         self.layout = QVBoxLayout(self)
+        self.layout.setContentsMargins(5, 5, 5, 5)
         self.arg_box = None
         self.kwarg_boxes = []
         self.expert_mode = False  # TODO implement in the future versions
+        self.previous_scan = None
+        self.last_scan_found = None
 
-        # Scan list - allowed scans for the GUI
-        self.allowed_scans = allowed_scans
+        # Widget Default Parameters
+        self.config.default_scan = default_scan
+        self.config.allowed_scans = allowed_scans
 
         # Create and set main layout
         self._init_UI()
@@ -56,7 +89,12 @@ class ScanControl(BECWidget, QWidget):
         self.scan_selection_group.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
         self.layout.addWidget(self.scan_selection_group)
 
+        # Default scan from config
+        if self.config.default_scan is not None:
+            self.comboBox_scan_selection.setCurrentText(self.config.default_scan)
+
         # Connect signals
+        self.comboBox_scan_selection.view().pressed.connect(self.save_current_scan_parameters)
         self.comboBox_scan_selection.currentIndexChanged.connect(self.on_scan_selection_changed)
         self.button_run_scan.clicked.connect(self.run_scan)
 
@@ -89,18 +127,35 @@ class ScanControl(BECWidget, QWidget):
         """
 
         scan_selection_group = QGroupBox("Scan Selection", self)
-        self.scan_selection_layout = QGridLayout(scan_selection_group)
+        self.scan_selection_layout = QVBoxLayout(scan_selection_group)
         self.comboBox_scan_selection = QComboBox(scan_selection_group)
 
-        # Run button
+        # Buttons
+        self.button_layout = QHBoxLayout()
+        ## Run button
         self.button_run_scan = QPushButton("Start", scan_selection_group)
         self.button_run_scan.setStyleSheet("background-color:  #559900; color: white")
-        # Stop button
+        ## Stop button
         self.button_stop_scan = StopButton(parent=scan_selection_group)
-
-        self.scan_selection_layout.addWidget(self.comboBox_scan_selection, 0, 0, 1, 2)
-        self.scan_selection_layout.addWidget(self.button_run_scan, 1, 0)
-        self.scan_selection_layout.addWidget(self.button_stop_scan, 1, 1)
+        ## Add buttons to layout
+        self.button_layout.addWidget(self.button_run_scan)
+        self.button_layout.addWidget(self.button_stop_scan)
+
+        # Label to reload the last scan parameters
+        self.toggle_layout = QHBoxLayout()
+        ## Label
+        self.last_scan_label = QLabel("Restore last scan parameters", scan_selection_group)
+        ## Switch toggle button
+        self.toggle = ToggleSwitch(parent=scan_selection_group, checked=False)
+        self.toggle.enabled.connect(self.request_last_executed_scan_parameters)
+        ## Add label and switch to layout
+        self.toggle_layout.addWidget(self.last_scan_label)
+        self.toggle_layout.addWidget(self.toggle)
+
+        # Add widgets to layout
+        self.scan_selection_layout.addWidget(self.comboBox_scan_selection)
+        self.scan_selection_layout.addLayout(self.button_layout)
+        self.scan_selection_layout.addLayout(self.toggle_layout)
 
         return scan_selection_group
 
@@ -109,7 +164,7 @@ class ScanControl(BECWidget, QWidget):
         self.available_scans = self.client.connector.get(
             MessageEndpoints.available_scans()
         ).resource
-        if self.allowed_scans is None:
+        if self.config.allowed_scans is None:
             supported_scans = ["ScanBase", "SyncFlyScanBase", "AsyncFlyScanBase"]
             allowed_scans = [
                 scan_name
@@ -118,13 +173,50 @@ class ScanControl(BECWidget, QWidget):
             ]
 
         else:
-            allowed_scans = self.allowed_scans
+            allowed_scans = self.config.allowed_scans
         self.comboBox_scan_selection.addItems(allowed_scans)
 
     def on_scan_selection_changed(self, index: int):
         """Callback for scan selection combo box"""
         selected_scan_name = self.comboBox_scan_selection.currentText()
         self.scan_selected.emit(selected_scan_name)
+        self.request_last_executed_scan_parameters()
+        self.restore_scan_parameters(selected_scan_name)
+
+    @Slot()
+    def request_last_executed_scan_parameters(self):
+        """
+        Requests the last executed scan parameters from BEC and restores them to the scan control widget.
+        """
+        enabled = self.toggle.checked
+        current_scan = self.comboBox_scan_selection.currentText()
+        if enabled:
+            history = self.client.connector.lrange(MessageEndpoints.scan_queue_history(), 0, -1)
+
+            for scan in history:
+                scan_name = scan.content["info"]["request_blocks"][-1]["msg"].content["scan_type"]
+                if scan_name == current_scan:
+                    args_dict = scan.content["info"]["request_blocks"][-1]["msg"].content[
+                        "parameter"
+                    ]["args"]
+                    args_list = []
+                    for key, value in args_dict.items():
+                        args_list.append(key)
+                        args_list.extend(value)
+                    if len(args_list) > 1 and self.arg_box is not None:
+                        self.arg_box.set_parameters(args_list)
+                    kwargs = scan.content["info"]["request_blocks"][-1]["msg"].content["parameter"][
+                        "kwargs"
+                    ]
+                    if kwargs and self.kwarg_boxes:
+                        for box in self.kwarg_boxes:
+                            box.set_parameters(kwargs)
+                    self.last_scan_found = True
+                    break
+                else:
+                    self.last_scan_found = False
+        else:
+            self.last_scan_found = False
 
     @Property(str)
     def current_scan(self):
@@ -151,6 +243,29 @@ class ScanControl(BECWidget, QWidget):
         """
         self.current_scan = scan_name
 
+    @Property(bool)
+    def hide_scan_remember_toggle(self):
+        """Property to hide the scan remember toggle."""
+        return not self.toggle.isVisible()
+
+    @hide_scan_remember_toggle.setter
+    def hide_scan_remember_toggle(self, hide: bool):
+        """Setter for the hide_scan_remember_toggle property.
+
+        Args:
+            hide(bool): Hide or show the scan remember toggle.
+        """
+        self.show_scan_remember_toggle(not hide)
+
+    @Slot(bool)
+    def show_scan_remember_toggle(self, show: bool):
+        """Shows or hides the scan control buttons."""
+        self.toggle.setVisible(show)
+        self.last_scan_label.setVisible(show)
+
+        show_group = show or self.button_run_scan.isVisible()
+        self.scan_selection_group.setVisible(show_group)
+
     @Property(bool)
     def hide_scan_control_buttons(self):
         """Property to hide the scan control buttons."""
@@ -294,17 +409,64 @@ class ScanControl(BECWidget, QWidget):
             box.deleteLater()
         self.kwarg_boxes = []
 
-    @Slot()
-    def run_scan(self):
-        """Starts the selected scan with the given parameters."""
-        self.scan_started.emit()
+    def get_scan_parameters(self, bec_object: bool = True):
+        """
+        Returns the scan parameters for the selected scan.
+
+        Args:
+            bec_object(bool): If True, returns the BEC object for the scan parameters such as device objects.
+        """
         args = []
         kwargs = {}
         if self.arg_box is not None:
-            args = self.arg_box.get_parameters()
+            args = self.arg_box.get_parameters(bec_object)
         for box in self.kwarg_boxes:
-            box_kwargs = box.get_parameters()
+            box_kwargs = box.get_parameters(bec_object)
             kwargs.update(box_kwargs)
+        return args, kwargs
+
+    def restore_scan_parameters(self, scan_name: str):
+        """
+        Restores the scan parameters for the given scan name
+
+        Args:
+            scan_name(str): Name of the scan to restore the parameters for.
+        """
+        if self.last_scan_found is True:
+            return
+        scan_params = self.config.scans.get(scan_name, None)
+        if scan_params is None and self.previous_scan is None:
+            return
+
+        if scan_params is None and self.previous_scan is not None:
+            previous_scan_params = self.config.scans.get(self.previous_scan, None)
+            self._restore_kwargs(previous_scan_params.kwargs)
+            return
+
+        if scan_params.args is not None and self.arg_box is not None:
+            self.arg_box.set_parameters(scan_params.args)
+
+        self._restore_kwargs(scan_params.kwargs)
+
+    def _restore_kwargs(self, scan_kwargs: dict):
+        """Restores the kwargs for the given scan parameters."""
+        if scan_kwargs is not None and self.kwarg_boxes is not None:
+            for box in self.kwarg_boxes:
+                box.set_parameters(scan_kwargs)
+
+    def save_current_scan_parameters(self):
+        """Saves the current scan parameters to the scan control config for further use."""
+        scan_name = self.comboBox_scan_selection.currentText()
+        self.previous_scan = scan_name
+        args, kwargs = self.get_scan_parameters(False)
+        scan_params = ScanParameterConfig(name=scan_name, args=args, kwargs=kwargs)
+        self.config.scans[scan_name] = scan_params
+
+    @SafeSlot(popup_error=True)
+    def run_scan(self):
+        """Starts the selected scan with the given parameters."""
+        self.scan_started.emit()
+        args, kwargs = self.get_scan_parameters()
         scan_function = getattr(self.scans, self.comboBox_scan_selection.currentText())
         if callable(scan_function):
             scan_function(*args, **kwargs)