pymodaq 5.0.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

pymodaq/dashboard.py

@@ -8,8 +8,12 @@ import logging
 from pathlib import Path
 from importlib import import_module
 from packaging import version as version_mod
+from typing import Tuple, List, Any, TYPE_CHECKING
+
+
 from qtpy import QtGui, QtWidgets, QtCore
-from qtpy.QtCore import Qt, QObject, Slot, QThread, Signal
+from qtpy.QtCore import Qt, QObject, Slot, QThread, Signal, QSize
+from qtpy.QtWidgets import QTableWidget, QTableWidgetItem, QCheckBox, QWidget, QLabel, QDialogButtonBox, QDialog
 from time import perf_counter
 import numpy as np
 
@@ -20,6 +24,7 @@ from pymodaq_utils.logger import set_logger, get_module_name
 from pymodaq_utils import utils
 from pymodaq_utils.utils import get_version, find_dict_in_list_from_key_val
 from pymodaq_utils import config as configmod
+from pymodaq_utils.enums import BaseEnum
 
 from pymodaq_gui.parameter import ParameterTree, Parameter
 from pymodaq_gui.utils import DockArea, Dock, select_file
@@ -27,25 +32,29 @@ import pymodaq_gui.utils.layout as layout_mod
 from pymodaq_gui.messenger import messagebox
 from pymodaq_gui.parameter import utils as putils
 from pymodaq_gui.managers.roi_manager import ROISaver
+from pymodaq_gui.utils.custom_app import CustomApp
 
 from pymodaq.utils.managers.modules_manager import ModulesManager
 from pymodaq.utils.managers.preset_manager import PresetManager
 from pymodaq.utils.managers.overshoot_manager import OvershootManager
 from pymodaq.utils.managers.remote_manager import RemoteManager
-from pymodaq.utils.exceptions import DetectorError, ActuatorError, PIDError, MasterSlaveError
+from pymodaq.utils.exceptions import DetectorError, ActuatorError, MasterSlaveError
 from pymodaq.utils.daq_utils import get_instrument_plugins
 from pymodaq.utils.leco.utils import start_coordinator
 from pymodaq.utils import config as config_mod_pymodaq
+
 from pymodaq.control_modules.daq_move import DAQ_Move
 from pymodaq.control_modules.daq_viewer import DAQ_Viewer
+from pymodaq_gui.utils.splash import get_splash_sc
+
 from pymodaq import extensions as extmod
 
+logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
 
 get_instrument_plugins()
+extensions = extmod.get_extensions()
 
-logger = set_logger(get_module_name(__file__))
-
-config = configmod.Config()
 
 local_path = configmod.get_set_local_dir()
 now = datetime.datetime.now()
@@ -56,16 +65,105 @@ overshoot_path = config_mod_pymodaq.get_set_overshoot_path()
 roi_path = config_mod_pymodaq.get_set_roi_path()
 remote_path = config_mod_pymodaq.get_set_remote_path()
 
-extensions = extmod.get_extensions()
+
+class ManagerEnums(BaseEnum):
+    preset = 0
+    remote = 1
+    overshoot = 2
+    roi = 3
+
+class PymodaqUpdateTableWidget(QTableWidget):
+    '''
+        A class to represent PyMoDAQ and its subpackages'
+        available updates as a table.
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self._checkboxes = []
+        self._package_versions = []
+
+    def setHorizontalHeaderLabels(self, labels):
+        super().setHorizontalHeaderLabels(labels)
+        self.setColumnCount(len(labels))
+        
+    def append_row(self, checkbox, package, current_version, available_version):  
+        row = len(self._checkboxes)
+
+        self._checkboxes.append(checkbox)
+        self._package_versions.append(f'{package}=={available_version}')
+
+        checkbox_widget = QWidget()
+                        
+        checkbox.setChecked(True)
+        checkbox.setToolTip("Check to install update")
+
+        checkbox_layout = QtWidgets.QHBoxLayout()                
+        checkbox_layout.addWidget(checkbox)
+        checkbox_layout.setAlignment(Qt.AlignCenter)
+        checkbox_layout.setContentsMargins(0, 0, 0, 0)
+
+        checkbox_widget.setLayout(checkbox_layout)
+
+        # Add the checkbox widget to the table
+        self.setCellWidget(row, 0, checkbox_widget)
+
+        # Add labels in the other columns
+        self.setItem(row, 1, QTableWidgetItem(str(package)))
+        self.setItem(row, 2, QTableWidgetItem(str(current_version)))
+        self.setItem(row, 3, QTableWidgetItem(str(available_version)))
 
 
-class DashBoard(QObject):
+    def get_checked_data(self):
+    	checked = list(map(lambda c : c.isChecked(), self._checkboxes))
+    	return list(np.array(self._package_versions)[checked])
+
+    def sizeHint(self):
+        self.resizeColumnsToContents()
+        self.resizeRowsToContents()
+                
+        # Compute the size to adapt the window (header + borders + sum of all the elements)
+        width  = self.verticalHeader().width()  \
+        	   + self.frameWidth() * 2 \
+        	   + sum([self.columnWidth(i) for i in range(self.columnCount())])
+        
+        height = self.horizontalHeader().height() \
+        	   + self.frameWidth() * 2 \
+        	   + sum([self.rowHeight(i) for i in range(self.rowCount())])
+
+        return QSize(width, height)
+
+class DashBoard(CustomApp):
     """
     Main class initializing a DashBoard interface to display det and move modules and logger """
     status_signal = Signal(str)
     preset_loaded_signal = Signal(bool)
     new_preset_created = Signal()
 
+    settings_name = 'dashboard_settings'
+    _splash_sc = None
+
+    params = [
+            {'title': 'Log level', 'name': 'log_level', 'type': 'list',
+             'value': config('general', 'debug_level'),
+             'limits': config('general', 'debug_levels')},
+
+            {'title': 'Loaded presets', 'name': 'loaded_files', 'type': 'group', 'children': [
+                {'title': 'Preset file', 'name': 'preset_file', 'type': 'str', 'value': '',
+                 'readonly': True},
+                {'title': 'Overshoot file', 'name': 'overshoot_file', 'type': 'str', 'value': '',
+                 'readonly': True},
+                {'title': 'Layout file', 'name': 'layout_file', 'type': 'str', 'value': '',
+                 'readonly': True},
+                {'title': 'ROI file', 'name': 'roi_file', 'type': 'str', 'value': '',
+                 'readonly': True},
+                {'title': 'Remote file', 'name': 'remote_file', 'type': 'str', 'value': '',
+                 'readonly': True},
+            ]},
+            {'title': 'Actuators Init.', 'name': 'actuators', 'type': 'group', 'children': []},
+            {'title': 'Detectors Init.', 'name': 'detectors', 'type': 'group', 'children': []},
+        ]
+
     def __init__(self, dockarea):
         """
 
@@ -74,7 +172,8 @@ class DashBoard(QObject):
         parent: (dockarea) instance of the modified pyqtgraph Dockarea (see daq_utils)
         """
         
-        super().__init__()
+        super().__init__(dockarea)
+
         logger.info('Initializing Dashboard')
         self.extra_params = []
         self.preset_path = preset_path
@@ -88,14 +187,10 @@ class DashBoard(QObject):
         self.extensions = dict([])
         self.extension_windows = []
 
-        self.dockarea = dockarea
         self.dockarea.dock_signal.connect(self.save_layout_state_auto)
-        self.mainwindow = dockarea.parent()
+
         self.title = ''
-        splash_path = Path(__file__).parent.joinpath('splash.png')
 
-        splash = QtGui.QPixmap(str(splash_path))
-        self.splash_sc = QtWidgets.QSplashScreen(splash, Qt.WindowStaysOnTopHint)
         self.overshoot_manager = None
         self.preset_manager = None
         self.roi_saver: ROISaver = None
@@ -112,12 +207,23 @@ class DashBoard(QObject):
         self.preset_file = None
         self.actuators_modules = []
         self.detector_modules = []
-        self.setupUI()
+
+        self.setup_ui()
+
+        self.mainwindow.setVisible(True)
 
         logger.info('Dashboard Initialized')
 
         if config('general', 'check_version'):
-            self.check_version(show=False)
+            if self.check_update(show=False):
+                sys.exit(0)
+
+    @classmethod
+    @property
+    def splash_sc(cls) -> QtWidgets.QSplashScreen:
+        if cls._splash_sc is None:
+            cls._splash_sc = get_splash_sc()
+        return cls._splash_sc
 
     def set_preset_path(self, path):
         self.preset_path = path
@@ -179,6 +285,7 @@ class DashBoard(QObject):
         self.scan_module = extmod.DAQScan(dockarea=area, dashboard=self)
         self.extensions['DAQScan'] = self.scan_module
         self.scan_module.status_signal.connect(self.add_status)
+        #win.setWindowTitle("DAQScan")
         win.show()
         return self.scan_module
 
@@ -264,7 +371,159 @@ class DashBoard(QObject):
         self.extension_windows[-1].show()
         return self.extensions[ext['class_name']]
 
-    def create_menu(self, menubar):
+    def setup_actions(self):
+        self.add_action('log', 'Log File', '', "Show Log File in default editor",
+                        auto_toolbar=False)
+        self.add_action('quit', 'Quit', 'close2', "Quit program")
+        self.toolbar.addSeparator()
+        self.add_action('config', 'Configuration file', 'tree', "General Settings")
+        self.add_action('restart', 'Restart', '', "Restart the Dashboard",
+                        auto_toolbar=False)
+        self.add_action('leco', 'Run Leco Coordinator', '', 'Run a Coordinator on this localhost',
+                        auto_toolbar=False)
+        self.add_action('load_layout', 'Load Layout', '',
+                        'Load the Saved Docks layout corresponding to the current preset',
+                        auto_toolbar=False)
+        self.add_action('save_layout', 'Save Layout', '',
+                        'Save the Saved Docks layout corresponding to the current preset',
+                        auto_toolbar=False)
+        self.add_action('log_window', 'Show/hide log window', '', checkable=True,
+                        auto_toolbar=False)
+        self.add_action('new_preset', 'New Preset', '',
+                        'Create a new experimental setup configuration file: a "preset"',
+                        auto_toolbar=False)
+        self.add_action('modify_preset', 'Modify Preset', '',
+                        'Modify an existing experimental setup configuration file: a "preset"',
+                        auto_toolbar=False)
+
+        self.add_widget('preset_list', QtWidgets.QComboBox, toolbar=self.toolbar,
+                        signal_str='currentTextChanged', slot=self.update_preset_action)
+        self.add_action('load_preset', 'LOAD', 'Open',
+                        tip='Load the selected Preset: ')
+        self.update_preset_action_list()
+
+        self.add_action('new_overshoot', 'New Overshoot', '',
+                        'Create a new experimental setup overshoot configuration file',
+                        auto_toolbar=False)
+        self.add_action('modify_overshoot', 'Modify Overshoot', '',
+                        'Modify an existing experimental setup overshoot configuration file',
+                        auto_toolbar=False)
+
+        for ind_file, file in enumerate(config_mod_pymodaq.get_set_overshoot_path().iterdir()):
+            if file.suffix == '.xml':
+                self.add_action(self.get_action_from_file(file, ManagerEnums.overshoot), file.stem,
+                                auto_toolbar=False)
+
+        self.add_action('save_roi', 'Save ROIs as a file', '', auto_toolbar=False)
+        self.add_action('modify_roi', 'Modify ROI file', '', auto_toolbar=False)
+
+        for ind_file, file in enumerate(config_mod_pymodaq.get_set_roi_path().iterdir()):
+            if file.suffix == '.xml':
+                self.add_action(self.get_action_from_file(file, ManagerEnums.roi), file.stem,
+                                '', auto_toolbar=False)
+
+        self.add_action('new_remote', 'Create New Remote', '', auto_toolbar=False)
+        self.add_action('modify_remote', 'Modify Remote file', '', auto_toolbar=False)
+        for ind_file, file in enumerate(config_mod_pymodaq.get_set_remote_path().iterdir()):
+            if file.suffix == '.xml':
+                self.add_action(self.get_action_from_file(file, ManagerEnums.remote),
+                                file.stem, '', auto_toolbar=False)
+        self.add_action('activate_overshoot', 'Activate overshoot', 'Error',
+                        tip='if activated, apply an overshoot if one is configured',
+                        checkable=True, enabled=False)
+        self.toolbar.addSeparator()
+        self.add_action('do_scan', 'Do Scans', 'surfacePlot',
+                        tip='Open the DAQ Scan extension to acquire data as a function of '
+                            'one or more parameter')
+        self.toolbar.addSeparator()
+        self.add_action('do_log', 'Log data', '', auto_toolbar=False)
+        self.add_action('do_pid', 'PID module', auto_toolbar=False)
+        self.add_action('console', 'IPython Console', auto_toolbar=False)
+        self.add_action('bayesian', 'Bayesian Optimisation', auto_toolbar=False)
+
+        self.add_action('about', 'About', 'information2')
+        self.add_action('help', 'Help', 'help1')
+        self.get_action('help').setShortcut(QtGui.QKeySequence('F1'))
+        self.add_action('check_update', 'Check Updates', '', auto_toolbar=False)
+        self.toolbar.addSeparator()
+        self.add_action('plugin_manager', 'Plugin Manager', '')
+
+    def update_preset_action_list(self):
+        presets = []
+        self.get_action('preset_list').clear()
+        for ind_file, file in enumerate(self.preset_path.iterdir()):
+            if file.suffix == '.xml':
+                filestem = file.stem
+                if not self.has_action(self.get_action_from_file(file, ManagerEnums.preset)):
+                    self.add_action(self.get_action_from_file(file, ManagerEnums.preset),
+                                    filestem, '', f'Load the {filestem}.xml preset',
+                                    auto_toolbar=False)
+                presets.append(filestem)
+
+        self.get_action('preset_list').addItems(presets)
+
+    def update_preset_action(self, preset_name: str):
+        self.get_action('load_preset').setToolTip(f'Load the {preset_name}.xml preset file!')
+
+    def connect_things(self):
+        self.status_signal[str].connect(self.add_status)
+        self.connect_action('log', self.show_log)
+        self.connect_action('config', self.show_config)
+        self.connect_action('quit', self.quit_fun)
+        self.connect_action('restart', self.restart_fun)
+        self.connect_action('leco', start_coordinator)
+        self.connect_action('load_layout', self.load_layout_state)
+        self.connect_action('save_layout', self.save_layout_state)
+        self.connect_action('log_window', self.logger_dock.setVisible)
+        self.connect_action('new_preset', self.create_preset)
+        self.connect_action('modify_preset', self.modify_preset)
+
+        for ind_file, file in enumerate(self.preset_path.iterdir()):
+            if file.suffix == '.xml':
+                self.connect_action(self.get_action_from_file(file, ManagerEnums.preset),
+                                    self.create_menu_slot(self.preset_path.joinpath(file)))
+        self.connect_action('load_preset',
+                            lambda: self.set_preset_mode(
+                                self.preset_path.joinpath(
+                                    f"{self.get_action('preset_list').currentText()}.xml")))
+        self.connect_action('new_overshoot', self.create_overshoot)
+        self.connect_action('modify_overshoot', self.modify_overshoot)
+        self.connect_action('activate_overshoot', self.activate_overshoot)
+
+        for ind_file, file in enumerate(config_mod_pymodaq.get_set_overshoot_path().iterdir()):
+            if file.suffix == '.xml':
+                self.connect_action(self.get_action_from_file(file, ManagerEnums.overshoot),
+                    self.create_menu_slot_over(
+                        config_mod_pymodaq.get_set_overshoot_path().joinpath(file)))
+
+        self.connect_action('save_roi', self.create_roi_file)
+        self.connect_action('modify_roi', self.modify_roi)
+
+        for ind_file, file in enumerate(config_mod_pymodaq.get_set_roi_path().iterdir()):
+            if file.suffix == '.xml':
+                self.connect_action(self.get_action_from_file(file, ManagerEnums.roi),
+                    self.create_menu_slot_roi(config_mod_pymodaq.get_set_roi_path().joinpath(file)))
+
+        self.connect_action('new_remote', self.create_remote)
+        self.connect_action('modify_remote', self.modify_remote)
+        for ind_file, file in enumerate(config_mod_pymodaq.get_set_remote_path().iterdir()):
+            if file.suffix == '.xml':
+                self.connect_action(self.get_action_from_file(file, ManagerEnums.remote),
+                    self.create_menu_slot_remote(
+                        config_mod_pymodaq.get_set_remote_path().joinpath(file)))
+
+        self.connect_action('do_scan', lambda: self.load_scan_module())
+        self.connect_action('do_log', lambda: self.load_log_module())
+        self.connect_action('do_pid', lambda: self.load_pid_module())
+        self.connect_action('console', lambda: self.load_console())
+        self.connect_action('bayesian', lambda: self.load_bayesian())
+
+        self.connect_action('about', self.show_about)
+        self.connect_action('help', self.show_help)
+        self.connect_action('check_update', lambda: self.check_update(True))
+        self.connect_action('plugin_manager', self.start_plugin_manager)
+
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
         """
             Create the menubar object looking like :
         """
@@ -272,128 +531,95 @@ class DashBoard(QObject):
 
         # %% create Settings menu
         self.file_menu = menubar.addMenu('File')
-        self.file_menu.addAction('Show log file', self.show_log)
-        self.file_menu.addAction('Show configuration file', self.show_config)
+        self.file_menu.addAction(self.get_action('log'))
+        self.file_menu.addAction(self.get_action('config'))
         self.file_menu.addSeparator()
-        quit_action = self.file_menu.addAction('Quit')
-        restart_action = self.file_menu.addAction('Restart')
-        quit_action.triggered.connect(self.quit_fun)
-        restart_action.triggered.connect(self.restart_fun)
+        self.file_menu.addAction(self.get_action('quit'))
+        self.file_menu.addAction(self.get_action('restart'))
 
         self.settings_menu = menubar.addMenu('Settings')
-        action_leco = self.settings_menu.addAction('Run Leco Coordinator')
-        action_leco.triggered.connect(start_coordinator)
+        self.settings_menu.addAction(self.get_action('leco'))
         docked_menu = self.settings_menu.addMenu('Docked windows')
-        action_load = docked_menu.addAction('Load Layout')
-        action_save = docked_menu.addAction('Save Layout')
-
-        action_load.triggered.connect(self.load_layout_state)
-        action_save.triggered.connect(self.save_layout_state)
+        docked_menu.addAction(self.get_action('load_layout'))
+        docked_menu.addAction(self.get_action('save_layout'))
 
         docked_menu.addSeparator()
-        action_show_log = docked_menu.addAction('Show/hide log window')
-        action_show_log.setCheckable(True)
-        action_show_log.toggled.connect(self.logger_dock.setVisible)
+        docked_menu.addAction(self.get_action('log_window'))
 
         self.preset_menu = menubar.addMenu('Preset Modes')
-        action_new_preset = self.preset_menu.addAction('New Preset')
-        # action.triggered.connect(lambda: self.show_file_attributes(type_info='managers'))
-        action_new_preset.triggered.connect(self.create_preset)
-        action_modify_preset = self.preset_menu.addAction('Modify Preset')
-        action_modify_preset.triggered.connect(self.modify_preset)
+        self.preset_menu.addAction(self.get_action('new_preset'))
+        self.preset_menu.addAction(self.get_action('modify_preset'))
         self.preset_menu.addSeparator()
-        self.load_preset = self.preset_menu.addMenu('Load presets')
+        self.load_preset_menu = self.preset_menu.addMenu('Load presets')
 
-        slots = dict([])
         for ind_file, file in enumerate(self.preset_path.iterdir()):
             if file.suffix == '.xml':
-                filestem = file.stem
-                slots[filestem] = self.load_preset.addAction(filestem)
-                slots[filestem].triggered.connect(
-                    self.create_menu_slot(self.preset_path.joinpath(file)))
+                self.load_preset_menu.addAction(
+                    self.get_action(self.get_action_from_file(file, ManagerEnums.preset)))
 
         self.overshoot_menu = menubar.addMenu('Overshoot Modes')
-        action_new_overshoot = self.overshoot_menu.addAction('New Overshoot')
-        # action.triggered.connect(lambda: self.show_file_attributes(type_info='managers'))
-        action_new_overshoot.triggered.connect(self.create_overshoot)
-        action_modify_overshoot = self.overshoot_menu.addAction('Modify Overshoot')
-        action_modify_overshoot.triggered.connect(self.modify_overshoot)
+        self.overshoot_menu.addAction(self.get_action('new_overshoot'))
+        self.overshoot_menu.addAction(self.get_action('modify_overshoot'))
+        self.overshoot_menu.addAction(self.get_action('activate_overshoot'))
         self.overshoot_menu.addSeparator()
-        load_overshoot = self.overshoot_menu.addMenu('Load Overshoots')
+        load_overshoot_menu = self.overshoot_menu.addMenu('Load Overshoots')
 
-        slots_over = dict([])
         for ind_file, file in enumerate(config_mod_pymodaq.get_set_overshoot_path().iterdir()):
             if file.suffix == '.xml':
-                filestem = file.stem
-                slots_over[filestem] = load_overshoot.addAction(filestem)
-                slots_over[filestem].triggered.connect(
-                    self.create_menu_slot_over(
-                        config_mod_pymodaq.get_set_overshoot_path().joinpath(file)))
+                load_overshoot_menu.addAction(
+                    self.get_action(self.get_action_from_file(file, ManagerEnums.overshoot)))
 
         self.roi_menu = menubar.addMenu('ROI Modes')
-        action_new_roi = self.roi_menu.addAction('Save Current ROIs as a file')
-        action_new_roi.triggered.connect(self.create_roi_file)
-        action_modify_roi = self.roi_menu.addAction('Modify roi config')
-        action_modify_roi.triggered.connect(self.modify_roi)
+        self.roi_menu.addAction(self.get_action('save_roi'))
+        self.roi_menu.addAction(self.get_action('modify_roi'))
         self.roi_menu.addSeparator()
-        load_roi = self.roi_menu.addMenu('Load roi configs')
+        load_roi_menu = self.roi_menu.addMenu('Load roi configs')
 
-        slots = dict([])
         for ind_file, file in enumerate(config_mod_pymodaq.get_set_roi_path().iterdir()):
             if file.suffix == '.xml':
-                filestem = file.stem
-                slots[filestem] = load_roi.addAction(filestem)
-                slots[filestem].triggered.connect(
-                    self.create_menu_slot_roi(config_mod_pymodaq.get_set_roi_path().joinpath(file)))
+                load_roi_menu.addAction(
+                    self.get_action(self.get_action_from_file(file, ManagerEnums.roi)))
 
         self.remote_menu = menubar.addMenu('Remote/Shortcuts Control')
         self.remote_menu.addAction('New remote config.', self.create_remote)
         self.remote_menu.addAction('Modify remote config.', self.modify_remote)
         self.remote_menu.addSeparator()
-        load_remote = self.remote_menu.addMenu('Load remote config.')
+        load_remote_menu = self.remote_menu.addMenu('Load remote config.')
 
-        slots = dict([])
         for ind_file, file in enumerate(config_mod_pymodaq.get_set_remote_path().iterdir()):
             if file.suffix == '.xml':
-                filestem = file.stem
-                slots[filestem] = load_remote.addAction(filestem)
-                slots[filestem].triggered.connect(
-                    self.create_menu_slot_remote(
-                        config_mod_pymodaq.get_set_remote_path().joinpath(file)))
-
-        # actions menu
-        self.actions_menu = menubar.addMenu('Extensions')
-        action_scan = self.actions_menu.addAction('Do Scans')
-        action_scan.triggered.connect(lambda: self.load_scan_module())
-        action_log = self.actions_menu.addAction('Log data')
-        action_log.triggered.connect(lambda: self.load_log_module())
-        action_pid = self.actions_menu.addAction('PID module')
-        action_pid.triggered.connect(lambda: self.load_pid_module())
-        action_console = self.actions_menu.addAction('IPython Console')
-        action_console.triggered.connect(lambda: self.load_console())
-        action_bayesian = self.actions_menu.addAction('Bayesian Optimisation')
-        action_bayesian.triggered.connect(lambda: self.load_bayesian())
-
+                load_remote_menu.addAction(
+                    self.get_action(self.get_action_from_file(file, ManagerEnums.remote)))
+
+        # extensions menu
+        self.extensions_menu = menubar.addMenu('Extensions')
+        self.extensions_menu.addAction(self.get_action('do_scan'))
+        self.extensions_menu.addAction(self.get_action('do_log'))
+        self.extensions_menu.addAction(self.get_action('do_pid'))
+        self.extensions_menu.addAction(self.get_action('console'))
+        self.extensions_menu.addAction(self.get_action('bayesian'))
+
+        # extensions from plugins
         extensions_actions = []
         for ext in extensions:
-            extensions_actions.append(self.actions_menu.addAction(ext['name']))
+            extensions_actions.append(self.extensions_menu.addAction(ext['name']))
             extensions_actions[-1].triggered.connect(self.create_menu_slot_ext(ext))
 
-
         # help menu
         help_menu = menubar.addMenu('?')
-        action_about = help_menu.addAction('About')
-        action_about.triggered.connect(self.show_about)
-        action_help = help_menu.addAction('Help')
-        action_help.triggered.connect(self.show_help)
-        action_help.setShortcut(QtGui.QKeySequence('F1'))
-
+        help_menu.addAction(self.get_action('about'))
+        help_menu.addAction(self.get_action('help'))
         help_menu.addSeparator()
-        action_update = help_menu.addAction('Check Version')
-        action_update.triggered.connect(lambda: self.check_version(True))
+        help_menu.addAction(self.get_action('check_update'))
+        help_menu.addAction(self.get_action('plugin_manager'))
 
-        action_plugin_manager = help_menu.addAction('Plugin Manager')
-        action_plugin_manager.triggered.connect(self.start_plugin_manager)
+        self.overshoot_menu.setEnabled(False)
+        self.roi_menu.setEnabled(False)
+        self.remote_menu.setEnabled(False)
+        self.extensions_menu.setEnabled(False)
+        self.file_menu.setEnabled(True)
+        self.settings_menu.setEnabled(True)
+        self.preset_menu.setEnabled(True)
 
     def start_plugin_manager(self):
         self.win_plug_manager = QtWidgets.QMainWindow()
@@ -424,7 +650,10 @@ class DashBoard(QObject):
         try:
             if self.preset_file is not None:
                 self.roi_saver.set_new_roi(self.preset_file.stem)
-                self.create_menu(self.menubar)
+                self.add_action(self.get_action_from_file(self.preset_file,
+                                                          ManagerEnums.roi),
+                                self.preset_file.stem, '')
+                self.setup_menu(self.menubar)
 
         except Exception as e:
             logger.exception(str(e))
@@ -433,7 +662,10 @@ class DashBoard(QObject):
         try:
             if self.preset_file is not None:
                 self.remote_manager.set_new_remote(self.preset_file.stem)
-                self.create_menu(self.menubar)
+                self.add_action(self.get_action_from_file(self.preset_file,
+                                                          ManagerEnums.remote),
+                                self.preset_file.stem, '')
+                self.setup_menu(self.menubar)
 
         except Exception as e:
             logger.exception(str(e))
@@ -442,18 +674,27 @@ class DashBoard(QObject):
         try:
             if self.preset_file is not None:
                 self.overshoot_manager.set_new_overshoot(self.preset_file.stem)
-                self.create_menu(self.menubar)
+                self.add_action(self.get_action_from_file(self.preset_file,
+                                                          ManagerEnums.overshoot),
+                                self.preset_file.stem, '')
+                self.setup_menu(self.menubar)
         except Exception as e:
             logger.exception(str(e))
 
     def create_preset(self):
         try:
-            self.preset_manager.set_new_preset()
-            self.create_menu(self.menubar)
-            self.new_preset_created.emit()
+            status = self.preset_manager.set_new_preset()
+            if status:
+                self.update_preset_action_list()
+                self.setup_menu(self.menubar)
+                self.new_preset_created.emit()
         except Exception as e:
             logger.exception(str(e))
 
+    @staticmethod
+    def get_action_from_file(file: Path, manager: ManagerEnums):
+        return f'{file.stem}_{manager.name}'
+
     def modify_remote(self):
         try:
             path = select_file(start_path=config_mod_pymodaq.get_set_remote_path(), save=False,
@@ -619,7 +860,7 @@ class DashBoard(QObject):
             self.save_layout_state(path)
 
     def add_move(self, plug_name, plug_settings, plug_type, move_docks, move_forms,
-                 actuators_modules):
+                 actuators_modules) -> DAQ_Move:
 
         move_docks.append(Dock(plug_name, size=(150, 250)))
         if len(move_docks) == 1:
@@ -640,18 +881,51 @@ class DashBoard(QObject):
                 mssg = f'Could not set this setting: {str(e)}\n' \
                        f'The Preset is no more compatible with the plugin {plug_type}'
                 logger.warning(mssg)
-                self.splash_sc.showMessage(mssg, color=Qt.white)
+                self.splash_sc.showMessage(mssg)
         QtWidgets.QApplication.processEvents()
 
         mov_mod_tmp.bounds_signal[bool].connect(self.stop_moves)
         move_docks[-1].addWidget(move_forms[-1])
         actuators_modules.append(mov_mod_tmp)
+        return mov_mod_tmp
 
-    def add_det(self, plug_name, plug_settings, det_docks_settings, det_docks_viewer,
-                detector_modules):
+    def add_move_from_extension(self, name: str, instrument_name: str,
+                                instrument_controller: Any):
+        """ Specific method to add a DAQ_Move within the Dashboard. This Particular actuator
+        should be defined in the plugin of the extension and is used to mimic an actuator while
+        move_abs is actually triggering an action on the extension which loaded it
 
-        plug_type = plug_settings.child('main_settings', 'DAQ_type').value()
-        plug_subtype = plug_settings.child('main_settings', 'detector_type').value()
+        For an exemple, see the PyMoDAQ builtin PID extension
+
+        Parameters
+        ----------
+        name: str
+            The name to print on the UI title
+        instrument_name: str
+            The name of the instrument class, for instance PID for the daq_move_PID
+            module and the DAQ_Move_PID instrument class
+        instrument_controller: object
+            whatever object is used to communicate between the instrument module and the extension
+            which created it
+        """
+        actuator = self.add_move(name, None, instrument_name, [], [], [])
+        actuator.controller = instrument_controller
+        actuator.master = False
+        actuator.init_hardware_ui()
+        QtWidgets.QApplication.processEvents()
+        self.poll_init(actuator)
+        QtWidgets.QApplication.processEvents()
+
+        # Update actuators modules and module manager
+        self.actuators_modules.append(actuator)
+        self.update_module_manager()
+
+    def add_det(self, plug_name, plug_settings, det_docks_settings, det_docks_viewer,
+                detector_modules, plug_type: str = None, plug_subtype: str = None) -> DAQ_Viewer:
+        if plug_type is None:
+            plug_type = plug_settings.child('main_settings', 'DAQ_type').value()
+        if plug_subtype is None:
+            plug_subtype = plug_settings.child('main_settings', 'detector_type').value()
         det_docks_settings.append(Dock(plug_name + " settings", size=(150, 250)))
         det_docks_viewer.append(Dock(plug_name + " viewer", size=(350, 350)))
         if len(detector_modules) == 0:
@@ -676,11 +950,54 @@ class DashBoard(QObject):
                 mssg = f'Could not set this setting: {str(e)}\n' \
                        f'The Preset is no more compatible with the plugin {plug_subtype}'
                 logger.warning(mssg)
-                self.splash_sc.showMessage(mssg, color=Qt.white)
+                self.splash_sc.showMessage(mssg)
 
         detector_modules.append(det_mod_tmp)
+        return det_mod_tmp
 
-    def set_file_preset(self, filename):
+    def add_det_from_extension(self, name: str, daq_type: str, instrument_name: str,
+                               instrument_controller: Any):
+        """ Specific method to add a DAQ_Viewer within the Dashboard. This Particular detector
+        should be defined in the plugin of the extension and is used to mimic a grab while data
+        are actually coming from the extension which loaded it
+
+        For an exemple, see the pymodaq_plugins_datamixer plugin and its DataMixer extension
+
+        Parameters
+        ----------
+        name: str
+            The name to print on the UI title
+        daq_type: str
+            either DAQ0D, DAQ1D, DAQ2D or DAQND depending the type of the instrument
+        instrument_name: str
+            The name of the instrument class, for instance DataMixer for the daq_0Dviewer_DataMixer
+            module and the DAQ_0DViewer_DataMixer instrument class
+        instrument_controller: object
+            whatever object is used to communicate between the instrument module and the extension
+            which created it
+        """
+        detector = self.add_det(name, None, [], [], [],
+                                plug_type=daq_type,
+                                plug_subtype=instrument_name)
+        detector.controller = instrument_controller
+        detector.master = False
+        detector.init_hardware_ui()
+        QtWidgets.QApplication.processEvents()
+        self.poll_init(detector)
+        QtWidgets.QApplication.processEvents()
+
+        # Update actuators modules and module manager
+        self.detector_modules.append(detector)
+        self.update_module_manager()
+
+    def update_module_manager(self):
+        if self.modules_manager is None:
+            self.modules_manager = ModulesManager(self.detector_modules, self.actuators_modules)
+        else:
+            self.modules_manager.actuators_all = self.actuators_modules
+            self.modules_manager.detectors_all = self.detector_modules
+
+    def set_file_preset(self, filename) -> Tuple[List[DAQ_Move], List[DAQ_Viewer]]:
         """
             Set a file managers from the converted xml file given by the filename parameter.
 
@@ -718,17 +1035,16 @@ class DashBoard(QObject):
                         self.preset_manager.preset_params.child('Detectors').children()]
 
             for plug in plugins:
-                plug['ID'] = plug['value'].child('params', 'main_settings', 'controller_ID').value()
                 if plug["type"] == 'det':
-                    plug['status'] = plug['value'].child(
-                        'params', 'detector_settings', 'controller_status').value()
+                    plug['ID'] = plug['value']['params', 'detector_settings', 'controller_ID']
+                    plug['status'] = plug['value']['params', 'detector_settings',
+                        'controller_status']
                 else:
-                    if 'multiaxes' in [child.name() for child in plug['value'].child(
-                            'params', 'move_settings').children()]:
-                        plug['status'] = plug['value'].child(
-                            'params', 'move_settings', 'multiaxes', 'multi_status').value()
-                    else:
-                        plug['status'] = 'Master'
+                    plug['ID'] = plug['value']['params', 'move_settings',
+                        'multiaxes', 'controller_ID']
+                    plug['status'] = plug['value'][
+                            'params', 'move_settings', 'multiaxes', 'multi_status']
+
 
             IDs = list(set([plug['ID'] for plug in plugins]))
             # %%
@@ -750,8 +1066,7 @@ class DashBoard(QObject):
                     plug_init = plugin['value'].child('init').value()
                     plug_settings = plugin['value'].child('params')
                     self.splash_sc.showMessage(
-                        'Loading {:s} module: {:s}'.format(plugin['type'], plug_name),
-                        color=Qt.white)
+                        'Loading {:s} module: {:s}'.format(plugin['type'], plug_name))
 
                     if plugin['type'] == 'move':
                         plug_type = plug_settings.child('main_settings', 'move_type').value()
@@ -1030,33 +1345,22 @@ class DashBoard(QObject):
                 self.update_status('Overshoot configuration ({}) has been loaded'.format(file),
                                    log_type='log')
                 self.overshoot_manager.set_file_overshoot(filename, show=False)
-
-                det_titles = [det.title for det in self.detector_modules]
-                move_titles = [move.title for move in self.actuators_modules]
-
-                for det_param in self.overshoot_manager.overshoot_params.child(
-                        'Detectors').children():
-                    if det_param.child(('trig_overshoot')).value():
-                        det_index = det_titles.index(det_param.opts['title'])
-                        det_module = self.detector_modules[det_index]
-                        det_module.settings.child(
-                            'main_settings', 'overshoot', 'stop_overshoot').setValue(True)
-                        det_module.settings.child(
-                            'main_settings', 'overshoot', 'overshoot_value').setValue(
-                            det_param['overshoot_value'])
-                        for move_param in det_param.child(('params')).children():
-                            if move_param['move_overshoot']:
-                                move_index = move_titles.index(move_param.opts['title'])
-                                move_module = self.actuators_modules[move_index]
-                                det_module.overshoot_signal.connect(
-                                    self.create_overshoot_fun(
-                                        move_module, move_param['position']))
+                self.set_action_enabled('activate_overshoot', True)
+                self.set_action_checked('activate_overshoot', False)
+                self.get_action('activate_overshoot').trigger()
 
         except Exception as e:
             logger.exception(str(e))
 
-    def create_overshoot_fun(self, move_module, position):
-        return lambda: move_module.move_abs(position)
+    def activate_overshoot(self, status: bool):
+        try:
+            self.overshoot_manager.activate_overshoot(self.detector_modules,
+                                                      self.actuators_modules,
+                                                      status)
+        except Exception as e:
+            logger.warning(f'Could not load the overshoot file:\n{str(e)}')
+            self.set_action_checked('activate_overshoot', False)
+            self.set_action_enabled('activate_overshoot', False)
 
     @property
     def move_modules(self):
@@ -1093,6 +1397,9 @@ class DashBoard(QObject):
         try:
             if not isinstance(filename, Path):
                 filename = Path(filename)
+
+            self.get_action('preset_list').setCurrentText(filename.stem)
+
             self.mainwindow.setVisible(False)
             for area in self.dockarea.tempAreas:
                 area.window().setVisible(False)
@@ -1100,7 +1407,7 @@ class DashBoard(QObject):
             self.splash_sc.show()
             QtWidgets.QApplication.processEvents()
             self.splash_sc.raise_()
-            self.splash_sc.showMessage('Loading Modules, please wait', color=Qt.white)
+            self.splash_sc.showMessage('Loading Modules, please wait')
             QtWidgets.QApplication.processEvents()
             self.clear_move_det_controllers()
             QtWidgets.QApplication.processEvents()
@@ -1109,7 +1416,7 @@ class DashBoard(QObject):
 
             try:
                 actuators_modules, detector_modules = self.set_file_preset(filename)
-            except (ActuatorError, DetectorError, PIDError, MasterSlaveError) as error:
+            except (ActuatorError, DetectorError, MasterSlaveError) as error:
                 self.splash_sc.close()
                 self.mainwindow.setVisible(True)
                 for area in self.dockarea.tempAreas:
@@ -1128,55 +1435,7 @@ class DashBoard(QObject):
                 self.actuators_modules = actuators_modules
                 self.detector_modules = detector_modules
 
-                self.modules_manager = ModulesManager(self.detector_modules, self.actuators_modules)
-
-                # Now that we have the module manager, load PID if it is checked in managers
-                try:
-                    if self.preset_manager.preset_params.child('use_pid').value():
-                        self.load_pid_module()
-
-                        self.pid_module.settings.child('models', 'model_class').setValue(
-                            self.preset_manager.preset_params.child('pid_models').value())
-                        QtWidgets.QApplication.processEvents()
-                        self.pid_module.set_model()
-
-                        QtWidgets.QApplication.processEvents()
-
-                        for child in putils.iter_children_params(
-                                self.preset_manager.preset_params.child('model_settings'),
-                                []):
-                            preset_path = self.preset_manager.preset_params.child(
-                                'model_settings').childPath(child)
-                            path = ['models', 'model_params']
-                            path.extend(preset_path)
-                            self.pid_module.settings.child(*path).setValue(child.value())
-
-                        model_class = extmod.get_models(
-                            self.preset_manager.preset_params.child('pid_models').value())['class']
-                        for setp in model_class.setpoints_names:
-                            self.add_move(setp, None, 'PID', [], [], actuators_modules)
-                            actuators_modules[-1].controller = dict(
-                                curr_point=self.pid_module.curr_points_signal,
-                                setpoint=self.pid_module.setpoints_signal,
-                                emit_curr_points=self.pid_module.emit_curr_points_sig)
-                            actuators_modules[-1].init_hardware_ui()
-                            QtWidgets.QApplication.processEvents()
-                            self.poll_init(actuators_modules[-1])
-                            QtWidgets.QApplication.processEvents()
-
-                    # Update actuators modules and module manager
-                    self.actuators_modules = actuators_modules
-                    self.modules_manager = ModulesManager(self.detector_modules,
-                                                          self.actuators_modules)
-
-                except Exception as e:
-                    raise PIDError('Could not load the PID extension and create setpoints actuators'
-                                   f'{str(e)}')
-
-                #
-                if self.pid_module is not None:
-                    self.pid_module.get_action('ini_model').trigger()
-                # #
+                self.update_module_manager()
 
                 #####################################################
                 self.overshoot_manager = OvershootManager(
@@ -1216,11 +1475,13 @@ class DashBoard(QObject):
                 if self.pid_window is not None:
                     self.pid_window.show()
 
-                self.load_preset.setEnabled(False)
+                self.load_preset_menu.setEnabled(False)
+                self.set_action_enabled('load_preset', False)
+                self.set_action_enabled('preset_list', False)
                 self.overshoot_menu.setEnabled(True)
                 self.roi_menu.setEnabled(True)
                 self.remote_menu.setEnabled(True)
-                self.actions_menu.setEnabled(True)
+                self.extensions_menu.setEnabled(True)
                 self.file_menu.setEnabled(True)
                 self.settings_menu.setEnabled(True)
                 self.update_init_tree()
@@ -1276,40 +1537,18 @@ class DashBoard(QObject):
         config_tree = TreeFromToml()
         config_tree.show_dialog()
 
-    def setupUI(self):
+    def setup_docks(self):
 
         # %% create logger dock
         self.logger_dock = Dock("Logger")
         self.logger_list = QtWidgets.QListWidget()
         self.logger_list.setMinimumWidth(300)
-        self.init_tree = ParameterTree()
-        self.init_tree.setMinimumWidth(300)
+
         splitter = QtWidgets.QSplitter(Qt.Vertical)
-        splitter.addWidget(self.init_tree)
+        splitter.addWidget(self.settings_tree)
         splitter.addWidget(self.logger_list)
         self.logger_dock.addWidget(splitter)
 
-        self.settings = Parameter.create(name='init_settings', type='group', children=[
-            {'title': 'Log level', 'name': 'log_level', 'type': 'list',
-             'value': config('general', 'debug_level'),
-             'limits': config('general', 'debug_levels')},
-
-            {'title': 'Loaded presets', 'name': 'loaded_files', 'type': 'group', 'children': [
-                {'title': 'Preset file', 'name': 'preset_file', 'type': 'str', 'value': '',
-                 'readonly': True},
-                {'title': 'Overshoot file', 'name': 'overshoot_file', 'type': 'str', 'value': '',
-                 'readonly': True},
-                {'title': 'Layout file', 'name': 'layout_file', 'type': 'str', 'value': '',
-                 'readonly': True},
-                {'title': 'ROI file', 'name': 'roi_file', 'type': 'str', 'value': '',
-                 'readonly': True},
-                {'title': 'Remote file', 'name': 'remote_file', 'type': 'str', 'value': '',
-                 'readonly': True},
-            ]},
-            {'title': 'Actuators Init.', 'name': 'actuators', 'type': 'group', 'children': []},
-            {'title': 'Detectors Init.', 'name': 'detectors', 'type': 'group', 'children': []},
-        ])
-        self.init_tree.setParameters(self.settings, showTop=False)
         self.remote_dock = Dock('Remote controls')
         self.dockarea.addDock(self.remote_dock, 'top')
         self.dockarea.addDock(self.logger_dock, 'above', self.remote_dock)
@@ -1318,21 +1557,9 @@ class DashBoard(QObject):
         self.remote_dock.setVisible(False)
         self.preset_manager = PresetManager(path=self.preset_path, extra_params=self.extra_params)
 
-        # creating the menubar
-        self.menubar = self.mainwindow.menuBar()
-        self.create_menu(self.menubar)
-        self.overshoot_menu.setEnabled(False)
-        self.roi_menu.setEnabled(False)
-        self.remote_menu.setEnabled(False)
-        self.actions_menu.setEnabled(False)
-        #        connecting
-        self.status_signal[str].connect(self.add_status)
-
-        self.file_menu.setEnabled(True)
-        # self.actions_menu.setEnabled(True)
-        self.settings_menu.setEnabled(True)
-        self.preset_menu.setEnabled(True)
-        self.mainwindow.setVisible(True)
+    @property
+    def menubar(self):
+        return self._menubar
 
     def parameter_tree_changed(self, param, changes):
         """
@@ -1366,36 +1593,76 @@ class DashBoard(QObject):
         self.splash_sc.showMessage(
             f"PyMoDAQ version {get_version('pymodaq')}\n"
             f"Modular Acquisition with Python\n"
-            f"Written by Sébastien Weber",
-            QtCore.Qt.AlignRight, QtCore.Qt.white)
+            f"Written by Sébastien Weber")
+
+    def check_update(self, show=True):
 
-    def check_version(self, show=True):
         try:
-            current_version = version_mod.parse(get_version())
-            available_version = version_mod.parse(get_pypi_pymodaq('pymodaq')['version'])
-            msgBox = QtWidgets.QMessageBox()
-            if available_version > current_version:
-                msgBox.setText(f"A new version of PyMoDAQ is available, {str(available_version)}!")
-                msgBox.setInformativeText("Do you want to install it?")
-                msgBox.setStandardButtons(msgBox.Ok | msgBox.Cancel)
-                msgBox.setDefaultButton(msgBox.Ok)
-
-                ret = msgBox.exec()
-
-                if ret == msgBox.Ok:
-                    command = [sys.executable, '-m', 'pip', 'install',
-                               f'pymodaq=={str(available_version)}']
-                    subprocess.Popen(command)
-
-                    self.restart_fun()
+            packages = ['pymodaq_utils', 'pymodaq_data', 'pymodaq_gui', 'pymodaq']
+            current_versions = [version_mod.parse(get_version(p)) for p in packages]
+            available_versions = [version_mod.parse(get_pypi_pymodaq(p)['version']) for p in packages]
+            new_versions = np.greater(available_versions, current_versions)
+            # Combine package and version information and select only the ones with a newer version available
+            
+            
+            packages_data = np.array(list(zip(packages, current_versions, available_versions)))[new_versions]
+
+            #TODO: Remove `or True`
+            if len(packages_data) > 0:
+                #Create a QDialog window and different graphical components
+                dialog = QtWidgets.QDialog()
+                dialog.setWindowTitle("Update check")
+                
+                vlayout = QtWidgets.QVBoxLayout()
+
+                message_label = QLabel("New versions of PyMoDAQ packages available!\nPlease select the ones you want to install:")
+                message_label.setAlignment(Qt.AlignCenter)
+                
+
+                table = PymodaqUpdateTableWidget()
+                table.setRowCount(len(packages_data)) 
+                table.setColumnCount(4) 
+                table.setHorizontalHeaderLabels(["Select", "Package", "Current version", "New version"])
+                     
+                for p in packages_data:
+                    table.append_row(QCheckBox(), p[0], p[1], p[2])
+
+                button = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+                button.accepted.connect(dialog.accept)
+                button.rejected.connect(dialog.reject) 
+
+                # The vlayout contains the message, the table and the buttons                
+                # and is connected to the dialog window
+                vlayout.addWidget(message_label)
+                vlayout.addWidget(table)
+                vlayout.addWidget(button)
+                dialog.setLayout(vlayout)
+
+                ret = dialog.exec()
+
+                if ret == QDialog.Accepted:
+                    # If the update is accepted, the checked packages are extracted from the table
+                    # and send to the updater
+                    packages_to_update = table.get_checked_data()
+                    if len(packages_to_update) > 0:
+                        packages_to_update_str = ', '.join(packages_to_update)
+                        logger.info("Trying to update:")
+                        logger.info(f"\t {packages_to_update_str}")
+                        subprocess.Popen(['pymodaq_updater', '--wait', '--file', __file__] + packages_to_update, stdin=subprocess.PIPE)
+                        self.quit_fun()
+                        return True
+                    logger.info("Update found but no packages checked for update.")
             else:
                 if show:
-                    msgBox.setText(f"Your version of PyMoDAQ,"
-                                   f" {str(current_version)}, is up to date!")
+                    msgBox = QtWidgets.QMessageBox()
+                    msgBox.setWindowTitle("Update check")
+                    msgBox.setText("Everything is up to date!")
                     ret = msgBox.exec()
         except Exception as e:
             logger.exception("Error while checking the available PyMoDAQ version")
 
+        return False
+
     def show_file_attributes(self, type_info='dataset'):
         """
             Switch the type_info value.
@@ -1465,6 +1732,7 @@ class DashBoard(QObject):
 
 def main():
     from pymodaq_gui.utils.utils import mkQApp
+
     app = mkQApp('Dashboard')
 
     win = QtWidgets.QMainWindow()
@@ -1473,10 +1741,11 @@ def main():
     win.resize(1000, 500)
     win.setWindowTitle('PyMoDAQ Dashboard')
 
-    # win.setVisible(False)
     prog = DashBoard(area)
+
+    win.show()
+
     app.exec()
-    return prog, win
 
 
 if __name__ == '__main__':