pymodaq 5.0.18__py3-none-any.whl → 5.1.0__py3-none-any.whl

pymodaq/control_modules/daq_viewer.py

@@ -7,12 +7,8 @@ Created on Wed Jan 10 16:54:14 2018
 from __future__ import annotations
 from importlib import import_module
 
-from collections import OrderedDict
-import copy
-
 import os
 from pathlib import Path
-from random import randint
 import sys
 from typing import List, Tuple, Union, Optional
 import time
@@ -49,16 +45,22 @@ from pymodaq_gui.utils.utils import mkQApp
 
 from pymodaq.utils.gui_utils import get_splash_sc
 from pymodaq.control_modules.daq_viewer_ui import DAQ_Viewer_UI
-from pymodaq.control_modules.utils import DET_TYPES, get_viewer_plugins, DAQTypesEnum, DetectorError
+from pymodaq.control_modules.utils import (DET_TYPES, get_viewer_plugins, DAQTypesEnum,
+                                           DetectorError)
+from pymodaq.control_modules.thread_commands import (ThreadStatus, ThreadStatusViewer, ControlToHardwareViewer,
+                                                     UiToMainViewer)
 from pymodaq_gui.plotting.data_viewers.viewer import ViewerBase
 from pymodaq_gui.plotting.data_viewers import ViewersEnum
 from pymodaq_utils.enums import enum_checker
 from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base
 
-from pymodaq.utils.leco.pymodaq_listener import ViewerActorListener, LECOClientCommands
+from pymodaq.utils.leco.pymodaq_listener import ViewerActorListener, LECOClientCommands, LECOViewerCommands
+from pymodaq.utils.config import Config as ControlModulesConfig
+
 
 logger = set_logger(get_module_name(__file__))
-config = Config()
+config_utils = Config()
+config = ControlModulesConfig()
 
 local_path = get_set_local_dir()
 
@@ -104,11 +106,17 @@ class DAQ_Viewer(ParameterControlModule):
     params = daq_viewer_params
 
     listener_class = ViewerActorListener
-
-    def __init__(self, parent: DockArea=None, title="Testing",
-                 daq_type=config('viewer', 'daq_type'),
-                 dock_settings=None, dock_viewer=None,
-                 **kwargs):
+    ui: Optional[DAQ_Viewer_UI]
+
+    def __init__(
+        self,
+        parent: Optional[DockArea] = None,
+        title: str = "Testing",
+        daq_type=config("viewer", "daq_type"),
+        dock_settings=None,
+        dock_viewer=None,
+        **kwargs,
+    ):
 
         self.logger = set_logger(f'{logger.name}.{title}')
         self.logger.info(f'Initializing DAQ_Viewer: {title}')
@@ -121,6 +129,9 @@ class DAQ_Viewer(ParameterControlModule):
         self._viewer_types: List[ViewersEnum] = []
         self._viewers: List[ViewerBase] = []
 
+        self.override_grab_from_extension = False  # boolean allowing an extension to tell to init a grab or not
+        # (see DataMixer for reasons and use case in ModulesManager and dashboard method add_det_from_extension)
+
         if isinstance(parent, DockArea):
             self.dockarea = parent
         else:
@@ -128,11 +139,11 @@ class DAQ_Viewer(ParameterControlModule):
 
         self.parent = parent
         if parent is not None:
-            self.ui: DAQ_Viewer_UI = DAQ_Viewer_UI(parent, title, daq_type=daq_type,
+            self.ui = DAQ_Viewer_UI(parent, title, daq_type=daq_type,
                                                    dock_settings=dock_settings,
                                                    dock_viewer=dock_viewer)
         else:
-            self.ui: Optional[DAQ_Viewer_UI] = None
+            self.ui = None
 
         if self.ui is not None:
             QtWidgets.QApplication.processEvents()
@@ -145,9 +156,9 @@ class DAQ_Viewer(ParameterControlModule):
 
         self._title = title
 
-        self.module_and_data_saver: Union[None,
+        self._module_and_data_saver: Union[None,
                                           module_saving.DetectorSaver,
-                                          module_saving.DetectorEnlargeableSaver,
+                                          module_saving.DetectorTimeSaver,
                                           module_saving.DetectorExtendedSaver] = None
         self._h5saver_continuous: Optional[H5Saver] = None
         self._ind_continuous_grab = 0
@@ -200,6 +211,8 @@ class DAQ_Viewer(ParameterControlModule):
     def process_ui_cmds(self, cmd: utils.ThreadCommand):
         """Process commands sent by actions done in the ui
 
+        See pymodaq.control_modules.thread_commands.UiToMainViewer
+
         Parameters
         ----------
         cmd: ThreadCommand
@@ -220,38 +233,38 @@ class DAQ_Viewer(ParameterControlModule):
                 * show_config
         """
 
-        if cmd.command == 'init':
+        if cmd.command == UiToMainViewer.INIT:
             self.init_hardware(cmd.attribute[0])
-        elif cmd.command == 'quit':
+        elif cmd.command == UiToMainViewer.QUIT:
             self.quit_fun()
-        elif cmd.command == 'stop':
+        elif cmd.command == UiToMainViewer.STOP:
             self.stop()
-        elif cmd.command == 'show_log':
+        elif cmd.command == UiToMainViewer.SHOW_LOG:
             self.show_log()
-        elif cmd.command == 'grab':
+        elif cmd.command == UiToMainViewer.GRAB:
             self.grab_data(cmd.attribute, snap_state=False)
-        elif cmd.command == 'snap':
+        elif cmd.command == UiToMainViewer.SNAP:
             self.grab_data(False, snap_state=True)
-        elif cmd.command == 'save_new':
+        elif cmd.command == UiToMainViewer.SAVE_NEW:
             self.save_new()
-        elif cmd.command == 'save_current':
+        elif cmd.command == UiToMainViewer.SAVE_CURRENT:
             self.save_current()
-        elif cmd.command == 'open':
+        elif cmd.command == UiToMainViewer.OPEN:
             self.load_data()
-        elif cmd.command == 'detector_changed':
+        elif cmd.command == UiToMainViewer.DETECTOR_CHANGED:
             if cmd.attribute != '':
                 self.detector_changed_from_ui(cmd.attribute)
-        elif cmd.command == 'daq_type_changed':
+        elif cmd.command == UiToMainViewer.DAQ_TYPE_CHANGED:
             if cmd.attribute != '':
                 self.daq_type_changed_from_ui(cmd.attribute)
-        elif cmd.command == 'take_bkg':
+        elif cmd.command == UiToMainViewer.TAKE_BKG:
             self.take_bkg()
-        elif cmd.command == 'do_bkg':
+        elif cmd.command == UiToMainViewer.DO_BKG:
             self.do_bkg = cmd.attribute
-        elif cmd.command == 'viewers_changed':
+        elif cmd.command == UiToMainViewer.VIEWERS_CHANGED:
             self._viewer_types: List[ViewersEnum] = cmd.attribute['viewer_types']
             self.viewers = cmd.attribute['viewers']
-        elif cmd.command == 'show_config':
+        elif cmd.command == UiToMainViewer.SHOW_CONFIG:
             self.config = self.show_config(self.config)
             self.ui.config = self.config
 
@@ -401,18 +414,17 @@ class DAQ_Viewer(ParameterControlModule):
                 pass
         for ind_viewer, viewer in enumerate(viewers):
             viewer.data_to_export_signal.connect(self._get_data_from_viewer)
-            #deprecated:
-            viewer.ROI_select_signal.connect(
-                lambda roi_info: self.command_hardware.emit(ThreadCommand('ROISelect', roi_info)))
-            #use that now
+
             viewer.roi_select_signal.connect(
                 lambda roi_info: self.command_hardware.emit(
-                    ThreadCommand('roi_select',
-                                  dict(roi_info=roi_info, ind_viewer=ind_viewer))))
+                    ThreadCommand(ControlToHardwareViewer.ROI_SELECT,
+                                  dict(roi_info=roi_info,
+                                       ind_viewer=ind_viewer))))
             viewer.crosshair_dragged.connect(
                 lambda crosshair_info: self.command_hardware.emit(
-                    ThreadCommand('crosshair',
-                                  dict(crosshair_info=crosshair_info, ind_viewer=ind_viewer))))
+                    ThreadCommand(ControlToHardwareViewer.CROSSHAIR,
+                                  dict(crosshair_info=crosshair_info,
+                                       ind_viewer=ind_viewer))))
 
 
         self._viewers = viewers
@@ -457,7 +469,7 @@ class DAQ_Viewer(ParameterControlModule):
         """
         if not do_init:
             try:
-                self.command_hardware.emit(ThreadCommand(command="close"))
+                self.command_hardware.emit(ThreadCommand(ControlToHardwareViewer.CLOSE))
                 QtWidgets.QApplication.processEvents()
                 if self.ui is not None:
                     self.ui.detector_init = False
@@ -481,8 +493,10 @@ class DAQ_Viewer(ParameterControlModule):
                 self._hardware_thread.hardware = hardware
                 if self.config('viewer', 'viewer_in_thread'):
                     self._hardware_thread.start()
-                self.command_hardware.emit(ThreadCommand("ini_detector", attribute=[
-                    self.settings.child('detector_settings').saveState(), self.controller]))
+                self.command_hardware.emit(ThreadCommand(ControlToHardwareViewer.INI_DETECTOR,
+                                                         attribute=[
+                                                             self.settings.child('detector_settings').saveState(),
+                                                             self.controller]))
                 if self.ui is not None:
                     for dock in self.ui.viewer_docks:
                         dock.setEnabled(True)
@@ -490,15 +504,15 @@ class DAQ_Viewer(ParameterControlModule):
             except Exception as e:
                 self.logger.exception(str(e))
 
-    def snap(self):
+    def snap(self, send_to_tcpip=False):
         """ Launch a single grab """
-        self.grab_data(False, snap_state=True)
+        self.grab_data(False, snap_state=True, send_to_tcpip=send_to_tcpip)
 
-    def grab(self):
+    def grab(self, send_to_tcpip=False):
         """ Launch a continuous grab """
         if self.ui is not None:
             self.manage_ui_actions('grab', 'setChecked', not self._grabing)
-            self.grab_data(not self._grabing, snap_state=False)
+            self.grab_data(not self._grabing, snap_state=False, send_to_tcpip=send_to_tcpip)
 
     def snapshot(self, pathname=None, dosave=False, send_to_tcpip=False):
         """Do one single grab (snap) and eventually save the data.
@@ -545,16 +559,18 @@ class DAQ_Viewer(ParameterControlModule):
         if snap_state:
             self.update_status(f'{self._title}: Snap')
             self.command_hardware.emit(
-                ThreadCommand("single", dict(Naverage=self.settings['main_settings', 'Naverage'])))
+                ThreadCommand(ControlToHardwareViewer.SINGLE,
+                              dict(Naverage=self.settings['main_settings', 'Naverage'])))
         else:
             if not grab_state:
                 self.update_status(f'{self._title}: Stop Grab')
-                self.command_hardware.emit(ThreadCommand("stop_grab", ))
+                self.command_hardware.emit(ThreadCommand(ControlToHardwareViewer.STOP_GRAB, ))
             else:
-                self.thread_status(ThreadCommand("update_channels", ))
+                self.thread_status(ThreadCommand(ThreadStatusViewer.UPDATE_CHANNELS, ))
                 self.update_status(f'{self._title}: Continuous Grab')
                 self.command_hardware.emit(
-                    ThreadCommand("grab", dict(Naverage=self.settings['main_settings', 'Naverage'])))
+                    ThreadCommand(ControlToHardwareViewer.GRAB,
+                                  dict(Naverage=self.settings['main_settings', 'Naverage'])))
 
     def take_bkg(self):
         """ Do a snap and store data to be used as background into an attribute: `self._bkg`
@@ -578,14 +594,14 @@ class DAQ_Viewer(ParameterControlModule):
     def stop(self):
         """ Stop the current continuous grabbing """
         self.update_status(f'{self._title}: Stop Grab')
-        self.command_hardware.emit(ThreadCommand("stop_all", ))
+        self.command_hardware.emit(ThreadCommand(ControlToHardwareViewer.STOP_GRAB, ))
         self._grabing = False
 
     @Slot()
     def _raise_timeout(self):
         """  Print the "timeout occurred" error message in the status bar via the update_status method.
         """
-        self.update_status("Timeout occured", log_type="log")
+        self.update_status("Timeout occurred", log_type="log")
 
     @staticmethod
     def load_data():
@@ -612,7 +628,7 @@ class DAQ_Viewer(ParameterControlModule):
     def _init_continuous_save(self):
         """ Initialize the continuous saving H5Saver object
 
-        Update the module_and_data_saver attribute as :class:`DetectorEnlargeableSaver` object
+        Update the module_and_data_saver attribute as :class:`DetectorTimeSaver` object
         """
         if self._h5saver_continuous.settings.child('do_save').value():
 
@@ -622,7 +638,7 @@ class DAQ_Viewer(ParameterControlModule):
             self.module_and_data_saver.h5saver = self._h5saver_continuous
             self._h5saver_continuous.init_file(update_h5=True)
 
-            self.module_and_data_saver = module_saving.DetectorEnlargeableSaver(self)
+            self.module_and_data_saver = module_saving.DetectorTimeSaver(self)
             self.module_and_data_saver.h5saver = self._h5saver_continuous
             self.module_and_data_saver.get_set_node()
 
@@ -637,8 +653,10 @@ class DAQ_Viewer(ParameterControlModule):
             except Exception as e:
                 self.logger.exception(str(e))
 
-    def append_data(self, dte: DataToExport = None, where: Union[Node, str] = None):
-        """Appends current DataToExport to a DetectorEnlargeableSaver
+    def append_data(self, dte: DataToExport = None,
+                    where: Union[Node, str] = None,
+                    **kwargs):
+        """Appends current DataToExport to a DetectorTimeSaver
 
         Method to be used when performing continuous saving into a h5file (continuous mode or DAQ_Logger)
 
@@ -647,14 +665,21 @@ class DAQ_Viewer(ParameterControlModule):
         dte: DataToExport
             not really used
         where: Node or str
+        kwargs: dict
         See Also
         --------
-        :class:`DetectorEnlargeableSaver`
+        :class:`DetectorTimeSaver`
         """
         if dte is None:
             dte = self._data_to_save_export
-        self._add_data_to_saver(dte, init_step=self._h5saver_continuous.settings['N_saved'] == 0,
-                                where=where)
+        init_step = kwargs.pop('init_step', None)
+        if init_step is None:
+            init_step = self._h5saver_continuous.settings['N_saved'] == 0
+        self._add_data_to_saver(dte,
+                                init_step=init_step,
+                                where=where,
+                                **kwargs)
+
         self._h5saver_continuous.settings.child('N_saved').setValue(self._h5saver_continuous.settings['N_saved'] + 1)
 
     def insert_data(self, indexes: Tuple[int], where: Union[Node, str] = None,
@@ -693,7 +718,7 @@ class DAQ_Viewer(ParameterControlModule):
 
         See Also
         --------
-        DetectorSaver, DetectorEnlargeableSaver, DetectorExtendedSaver
+        DetectorSaver, DetectorTimeSaver, DetectorExtendedSaver
 
         """
         if dte is not None:
@@ -970,7 +995,8 @@ class DAQ_Viewer(ParameterControlModule):
             self._h5saver_continuous.show_settings(param.value())
 
         elif param.name() == 'wait_time':
-            self.command_hardware.emit(ThreadCommand('update_wait_time', [param.value()]))
+            self.command_hardware.emit(ThreadCommand(ControlToHardwareViewer.UPDATE_WAIT_TIME,
+                                                     [param.value()]))
 
         self._update_settings(param=param)
 
@@ -1047,6 +1073,7 @@ class DAQ_Viewer(ParameterControlModule):
                             scaling=self.settings['main_settings', 'axes', 'yaxis', 'yscaling'])
         return scaled_xaxis, scaled_yaxis
 
+
     def thread_status(self, status: ThreadCommand):
         """Get back info (using the ThreadCommand object) from the hardware
 
@@ -1068,7 +1095,7 @@ class DAQ_Viewer(ParameterControlModule):
         """
         super().thread_status(status, 'detector')
 
-        if status.command == "ini_detector":
+        if status.command == ThreadStatusViewer.INI_DETECTOR:
             self.update_status("detector initialized: " + str(status.attribute['initialized']))
             if self.ui is not None:
                 self.ui.detector_init = status.attribute['initialized']
@@ -1080,13 +1107,13 @@ class DAQ_Viewer(ParameterControlModule):
 
             self.init_signal.emit(self._initialized_state)
 
-        elif status.command == "grab":
+        elif status.command == ThreadStatusViewer.GRAB:
             self.grab_status.emit(True)
 
-        elif status.command == 'grab_stopped':
+        elif status.command == ThreadStatusViewer.GRAB_STOPPED:
             self.grab_status.emit(False)
 
-        elif status.command == 'init_lcd':
+        elif status.command == ThreadStatusViewer.INI_LCD:
             if self._lcd is not None:
                 try:
                     self._lcd.parent.close()
@@ -1098,11 +1125,11 @@ class DAQ_Viewer(ParameterControlModule):
             lcd.setVisible(True)
             QtWidgets.QApplication.processEvents()
 
-        elif status.command == 'lcd':
+        elif status.command == ThreadStatusViewer.LCD:
             """status.attribute should be a list of numpy arrays of shape (1,)"""
             self._lcd.setvalues(status.attribute)
 
-        elif status.command == 'stop':
+        elif status.command == ThreadStatusViewer.STOP:
             self.stop_grab()
 
     def connect_tcp_ip(self):
@@ -1132,6 +1159,13 @@ class DAQ_Viewer(ParameterControlModule):
             return
         if 'Send Data' in status.command:
             self.snapshot('', send_to_tcpip=True)
+        elif status.command == LECOViewerCommands.GRAB:
+            self.grab(send_to_tcpip=True)
+        elif status.command ==LECOViewerCommands.SNAP:
+            self.snap( send_to_tcpip=True)
+
+        elif status.command == LECOViewerCommands.STOP:
+            self.stop()
 
         elif status.command == LECOClientCommands.LECO_CONNECTED:
             self.settings.child('main_settings', 'leco', 'leco_connected').setValue(True)
@@ -1139,18 +1173,6 @@ class DAQ_Viewer(ParameterControlModule):
         elif status.command == LECOClientCommands.LECO_DISCONNECTED:
             self.settings.child('main_settings', 'leco', 'leco_connected').setValue(False)
 
-        elif status.command == 'set_info':
-            path_in_settings = status.attribute[0]
-            param_as_xml = status.attribute[1]
-            param_dict = ioxml.XML_string_to_parameter(param_as_xml)[0]
-            param_tmp = Parameter.create(**param_dict)
-            param = self.settings.child('detector_settings', *path_in_settings[1:])
-            param.restoreState(param_tmp.saveState())
-
-        elif status.command == 'get_axis':
-            raise DeprecationWarning('Do not use this, the axis are in the data objects')
-            self.command_hardware.emit(
-                ThreadCommand('get_axis', ))  # tells the plugin to emit its axes so that the server will receive them
 
 
 class DAQ_Detector(QObject):
@@ -1235,46 +1257,37 @@ class DAQ_Detector(QObject):
             * get_axis
             * any string that the hardware is able to understand
         """
-        if command.command == "ini_detector":
+        if command.command == ControlToHardwareViewer.INI_DETECTOR:
             status = self.ini_detector(*command.attribute)
-            self.status_sig.emit(ThreadCommand(command.command, status))
+            self.status_sig.emit(ThreadCommand(ThreadStatusViewer.INI_DETECTOR, status))
 
-        elif command.command == "close":
+        elif command.command == ControlToHardwareViewer.CLOSE:
             status = self.close()
-            self.status_sig.emit(ThreadCommand(command.command, [status, 'log']))
+            self.status_sig.emit(ThreadCommand(ThreadStatus.CLOSE, [status, 'log']))
 
-        elif command.command == "grab":
+        elif command.command == ControlToHardwareViewer.GRAB:
             self.single_grab = False
             self.grab_state = True
             self.grab_data(**command.attribute)
 
-        elif command.command == "single":
+        elif command.command == ControlToHardwareViewer.SINGLE:
             self.single_grab = True
             self.grab_state = True
             self.single(**command.attribute)
 
-        elif command.command == "stop_grab":
-            self.grab_state = False
-            self.status_sig.emit(ThreadCommand("Update_Status", ['Stoping grab']))
-
-        elif command.command == "stop_all":
+        elif command.command == ControlToHardwareViewer.STOP_GRAB:
             self.grab_state = False
             self.detector.stop()
             QtWidgets.QApplication.processEvents()
-            self.status_sig.emit(ThreadCommand("Update_Status", ['Stoping grab']))
+            self.status_sig.emit(ThreadCommand(ThreadStatus.UPDATE_STATUS, 'Stopping grab'))
 
-        elif command.command == 'update_scanner':
-            self.detector.update_scanner(command.attribute[0])
 
-        elif command.command == 'move_at_navigator':
-            self.detector.move_at_navigator(*command.attribute)
+        elif command.command == ControlToHardwareViewer.UPDATE_SCANNER:  # may be deprecated
+            self.detector.update_scanner(command.attribute[0])
 
-        elif command.command == 'update_wait_time':
+        elif command.command == ControlToHardwareViewer.UPDATE_WAIT_TIME:
             self.wait_time = command.attribute[0]
 
-        elif command.command == 'get_axis':
-            self.detector.get_axis()
-
         else:  # custom commands for particular plugins
             if hasattr(self.detector, command.command):
                 cmd = getattr(self.detector, command.command)
@@ -1365,8 +1378,7 @@ class DAQ_Detector(QObject):
             self.average_done = True  # expected to make sure the single_grab stop by itself
             self.data_detector_sig.emit(data)
         self.waiting_for_data = False
-        if not self.grab_state:
-            self.detector.stop()
+
 
     def single(self, Naverage=1, *args, **kwargs):
         """ Convenience function to grab a single set of data

pymodaq/control_modules/daq_viewer_ui.py

@@ -13,19 +13,22 @@ from qtpy import QtWidgets
 from qtpy.QtCore import Signal
 from qtpy.QtWidgets import QVBoxLayout,  QWidget, QComboBox
 from pymodaq.utils.daq_utils import ThreadCommand
-from pymodaq.control_modules.utils import ControlModuleUI
+from pymodaq.control_modules.ui_utils import ControlModuleUI
 
 from pymodaq_gui.utils.widgets import PushButtonIcon, LabelWithFont, QLED
 from pymodaq_gui.utils import Dock
-from pymodaq_utils.config import Config
+from pymodaq_utils.config import Config as ConfigUtils
 from pymodaq.control_modules.utils import DET_TYPES, DAQTypesEnum
 from pymodaq_gui.plotting.data_viewers.viewer import ViewerFactory, ViewerDispatcher
 from pymodaq_gui.plotting.data_viewers import ViewersEnum
 from pymodaq_utils.enums import enum_checker
+from pymodaq.utils.config import Config
+from pymodaq.control_modules.thread_commands import UiToMainViewer
 
 
 viewer_factory = ViewerFactory()
 config = Config()
+config_utils = ConfigUtils()
 
 
 class DAQ_Viewer_UI(ControlModuleUI, ViewerDispatcher):
@@ -107,12 +110,8 @@ class DAQ_Viewer_UI(ControlModuleUI, ViewerDispatcher):
 
     @detectors.setter
     def detectors(self, detectors: List[str]):
-        #self._detectors_combo.currentTextChanged.disconnect()
         self._detectors_combo.clear()
         self._detectors_combo.addItems(detectors)
-        #self._detectors_combo.currentTextChanged.connect(
-        #    lambda mod: self.command_sig.emit(ThreadCommand('detector_changed', mod)))
-        #self.detector = detectors[0]
 
     @property
     def daq_type(self):
@@ -153,13 +152,15 @@ class DAQ_Viewer_UI(ControlModuleUI, ViewerDispatcher):
         self._detector_widget = QWidget()
         self._settings_widget = QWidget()
         self._settings_widget.setLayout(QtWidgets.QVBoxLayout())
+
         bkg_widget = QWidget()
         bkg_widget.setLayout(QtWidgets.QHBoxLayout())
 
         widget.layout().addWidget(info_ui)
         widget.layout().addWidget(self.toolbar)
         widget.layout().addWidget(self._detector_widget)
-        widget.layout().addWidget(self._settings_widget)
+        if not config('viewer', 'settings_as_popup'):
+            widget.layout().addWidget(self._settings_widget)
         widget.layout().addStretch(0)
 
         info_ui.setLayout(QtWidgets.QHBoxLayout())
@@ -219,37 +220,38 @@ class DAQ_Viewer_UI(ControlModuleUI, ViewerDispatcher):
 
     def connect_things(self):
         self.connect_action('show_controls', lambda show: self._detector_widget.setVisible(show))
-        self.connect_action('show_settings', lambda show: self._settings_widget.setVisible(show))
-        self.connect_action('quit', lambda: self.command_sig.emit(ThreadCommand('quit', )))
-        self.connect_action('show_config', lambda: self.command_sig.emit(ThreadCommand('show_config', )))
-
-        self.connect_action('log', lambda: self.command_sig.emit(ThreadCommand('show_log', )))
-        self.connect_action('stop', lambda: self.command_sig.emit(ThreadCommand('stop', )))
-        self.connect_action('stop', lambda: self.get_action('grab').setChecked(False))
-        self.connect_action('stop', lambda: self._enable_ini_buttons(True))
-        self.connect_action('stop', lambda: self._settings_widget.setEnabled(True))
+        self.connect_action('show_settings', self._show_settings)
+        self.connect_action('quit', lambda: self.command_sig.emit(ThreadCommand(UiToMainViewer.QUIT, )))
+        self.connect_action('show_config', lambda: self.command_sig.emit(ThreadCommand(UiToMainViewer.SHOW_CONFIG, )))
 
+        self.connect_action('log', lambda: self.command_sig.emit(ThreadCommand(UiToMainViewer.SHOW_LOG, )))
+        self.connect_action('stop', self._stop)
         self.connect_action('grab', self._grab)
-        self.connect_action('snap', lambda: self.command_sig.emit(ThreadCommand('snap', )))
+        self.connect_action('snap', lambda: self.command_sig.emit(ThreadCommand(UiToMainViewer.SNAP, )))
 
-        self.connect_action('save_current', lambda: self.command_sig.emit(ThreadCommand('save_current', )))
-        self.connect_action('save_new', lambda: self.command_sig.emit(ThreadCommand('save_new', )))
-        self.connect_action('open', lambda: self.command_sig.emit(ThreadCommand('open', )))
+        self.connect_action('save_current', lambda: self.command_sig.emit(ThreadCommand(UiToMainViewer.SAVE_CURRENT, )))
+        self.connect_action('save_new', lambda: self.command_sig.emit(ThreadCommand(UiToMainViewer.SAVE_NEW, )))
+        self.connect_action('open', lambda: self.command_sig.emit(ThreadCommand(UiToMainViewer.OPEN, )))
 
         self._ini_det_pb.clicked.connect(self.send_init)
 
         self._detectors_combo.currentTextChanged.connect(
-            lambda mod: self.command_sig.emit(ThreadCommand('detector_changed', mod)))
+            lambda mod: self.command_sig.emit(ThreadCommand(UiToMainViewer.DETECTOR_CHANGED, mod)))
         self._daq_types_combo.currentTextChanged.connect(self._daq_type_changed)
 
 
-        self._do_bkg_cb.clicked.connect(lambda checked: self.command_sig.emit(ThreadCommand('do_bkg', checked)))
-        self._take_bkg_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand('take_bkg')))
+        self._do_bkg_cb.clicked.connect(lambda checked: self.command_sig.emit(ThreadCommand(UiToMainViewer.DO_BKG, checked)))
+        self._take_bkg_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand(UiToMainViewer.TAKE_BKG)))
+
+    def _show_settings(self, show: bool = True):
+        self._settings_widget.setVisible(show)
+        self._settings_widget.closeEvent = lambda event: self.set_action_checked('show_settings', False)
 
     def update_viewers(self, viewers_type: List[ViewersEnum]):
         super().update_viewers(viewers_type)
-        self.command_sig.emit(ThreadCommand('viewers_changed', attribute=dict(viewer_types=self.viewer_types,
-                                                                              viewers=self.viewers)))
+        self.command_sig.emit(ThreadCommand(UiToMainViewer.VIEWERS_CHANGED,
+                                            attribute=dict(viewer_types=self.viewer_types,
+                                                           viewers=self.viewers)))
 
     @property
     def data_ready(self):
@@ -263,7 +265,7 @@ class DAQ_Viewer_UI(ControlModuleUI, ViewerDispatcher):
         try:
             daq_type = enum_checker(DAQTypesEnum, daq_type)
 
-            self.command_sig.emit(ThreadCommand('daq_type_changed', daq_type))
+            self.command_sig.emit(ThreadCommand(UiToMainViewer.DAQ_TYPE_CHANGED, daq_type))
             if self.viewer_types != [daq_type.to_viewer_type()]:
                 self.update_viewers([daq_type.to_viewer_type()])
         except ValueError as e:
@@ -281,11 +283,18 @@ class DAQ_Viewer_UI(ControlModuleUI, ViewerDispatcher):
 
     def _grab(self):
         """Slot from the *grab* action"""
-        self.command_sig.emit(ThreadCommand('grab', attribute=self.is_action_checked('grab')))
+        self.command_sig.emit(ThreadCommand(UiToMainViewer.GRAB, attribute=self.is_action_checked('grab')))
         self._enable_ini_buttons(not self.is_action_checked('grab'))
         if not self.config('viewer', 'allow_settings_edition'):
             self._settings_widget.setEnabled(not self.is_action_checked('grab'))
 
+    def _stop(self):
+        """Slot from the *stop* action"""
+        self.command_sig.emit(ThreadCommand(UiToMainViewer.STOP, ))
+        self.get_action('grab').setChecked(False)
+        self._enable_ini_buttons(True)
+        self._settings_widget.setEnabled(True)
+
     def do_init(self, do_init=True):
         """Programmatically press the Init button
         API entry
@@ -324,9 +333,10 @@ class DAQ_Viewer_UI(ControlModuleUI, ViewerDispatcher):
 
     def send_init(self, checked: bool):
         self._enable_detchoices(not checked)
-        self.command_sig.emit(ThreadCommand('init', [checked,
-                                                     self._daq_types_combo.currentText(),
-                                                     self._detectors_combo.currentText()]))
+        self.command_sig.emit(ThreadCommand(UiToMainViewer.INIT,
+                                            [checked,
+                                             self._daq_types_combo.currentText(),
+                                             self._detectors_combo.currentText()]))
 
     def _enable_detchoices(self, enable=True):
         self._detectors_combo.setEnabled(enable)
@@ -377,7 +387,7 @@ def main(init_qt=True):
     def print_command_sig(cmd_sig):
         print(cmd_sig)
         prog.display_status(str(cmd_sig))
-        if cmd_sig.command == 'init':
+        if cmd_sig.command == UiToMainViewer.INIT:
             prog._enable_grab_buttons(cmd_sig.attribute[0])
             prog.detector_init = cmd_sig.attribute[0]
 

pymodaq/control_modules/mocks.py

@@ -6,7 +6,7 @@ Created the 16/03/2023
 """
 from pymodaq.utils.parameter import Parameter
 from pymodaq_gui.h5modules import saving
-from pymodaq.utils.h5modules.module_saving import DetectorSaver, ActuatorSaver, ScanSaver
+from pymodaq.utils.h5modules.module_saving import DetectorSaver, ActuatorTimeSaver, ScanSaver
 
 
 class MockDAQViewer:
@@ -27,7 +27,7 @@ class MockDAQMove:
         self.settings = Parameter.create(name='settings', type='group', children=self.params)  # create a Parameter
         self.h5saver = h5saver
         self.title = title
-        self.module_and_data_saver = ActuatorSaver(self)
+        self.module_and_data_saver = ActuatorTimeSaver(self)
         self.ui = None