pymodaq 4.4.7__py3-none-any.whl → 5.0.1__py3-none-any.whl

pymodaq/dashboard.py

@@ -8,66 +8,162 @@ import logging
 from pathlib import Path
 from importlib import import_module
 from packaging import version as version_mod
-from typing import Tuple, List
+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
 
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.gui_utils import DockArea, Dock, select_file
-import pymodaq.utils.gui_utils.layout as layout_mod
-from pymodaq.utils.gui_utils.utils import start_qapplication
-from pymodaq.utils.messenger import messagebox
-from pymodaq.utils.parameter import utils as putils
-from pymodaq.utils import daq_utils as utils
+from pymodaq_plugin_manager.manager import PluginManager
+from pymodaq_plugin_manager.validate import get_pypi_pymodaq
+
+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
+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.daq_utils import get_version, find_dict_in_list_from_key_val
 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.managers.roi_manager import ROISaver
-from pymodaq.utils.exceptions import DetectorError, ActuatorError, PIDError, MasterSlaveError
-from pymodaq.utils import config as configmod
-from pymodaq.utils.parameter import ParameterTree, Parameter
+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.extensions.pid.actuator_controller import PIDController
-from pymodaq import extensions as extmod
-
-from pymodaq_plugin_manager.manager import PluginManager
-from pymodaq_plugin_manager.validate import get_pypi_pymodaq
-from pymodaq.utils.daq_utils import get_instrument_plugins
+from pymodaq.utils.gui_utils import get_splash_sc
 
-get_instrument_plugins()
+from pymodaq import extensions as extmod
 
 logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
 
+get_instrument_plugins()
+extensions = extmod.get_extensions()
 
-config = configmod.Config()
 
 local_path = configmod.get_set_local_dir()
 now = datetime.datetime.now()
-preset_path = configmod.get_set_preset_path()
+preset_path = config_mod_pymodaq.get_set_preset_path()
 log_path = configmod.get_set_log_path()
-layout_path = configmod.get_set_layout_path()
-overshoot_path = configmod.get_set_overshoot_path()
-roi_path = configmod.get_set_roi_path()
-remote_path = configmod.get_set_remote_path()
+layout_path = config_mod_pymodaq.get_set_layout_path()
+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()
+
+
+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__()
 
-extensions = extmod.get_extensions()
+        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):
         """
 
@@ -76,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
@@ -90,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
@@ -114,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
@@ -128,11 +232,13 @@ class DashBoard(QObject):
 
     def set_extra_preset_params(self, params, param_options=[]):
         self.extra_params = params
-        self.preset_manager = PresetManager(path=self.preset_path, extra_params=params, param_options=param_options)
+        self.preset_manager = PresetManager(path=self.preset_path, extra_params=params,
+                                            param_options=param_options)
 
     def add_status(self, txt):
         """
-            Add the QListWisgetItem initialized with txt informations to the User Interface logger_list and to the save_parameters.logger array.
+            Add the QListWisgetItem initialized with txt informations to the User Interface
+             logger_list and to the save_parameters.logger array.
 
             =============== =========== ======================
             **Parameters**    **Type**   **Description**
@@ -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
 
@@ -239,7 +346,8 @@ class DashBoard(QObject):
         """ Init and load an extension from a plugin package
 
         ext: dict
-            dictionary containing info on the extension plugin package and class to be loaded, it contains four
+            dictionary containing info on the extension plugin package and class to be loaded,
+             it contains four
             keys:
 
             * pkg: the name of the plugin package
@@ -263,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_action('load_preset', 'LOAD', 'Open',
+                        tip='Load the selected Preset: ')
+        self.add_widget('preset_list', QtWidgets.QComboBox, toolbar=self.toolbar,
+                        signal_str='currentTextChanged', slot=self.update_preset_action)
+
+        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 :
         """
@@ -271,126 +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(configmod.get_set_overshoot_path().iterdir()):
+        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(configmod.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(configmod.get_set_roi_path().iterdir()):
+        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(configmod.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(configmod.get_set_remote_path().iterdir()):
+        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(configmod.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()
@@ -421,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))
@@ -430,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))
@@ -439,21 +674,31 @@ 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=configmod.get_set_remote_path(), save=False, ext='xml')
+            path = select_file(start_path=config_mod_pymodaq.get_set_remote_path(), save=False,
+                               ext='xml')
             if path != '':
                 self.remote_manager.set_file_remote(path)
 
@@ -464,7 +709,8 @@ class DashBoard(QObject):
 
     def modify_overshoot(self):
         try:
-            path = select_file(start_path=configmod.get_set_overshoot_path(), save=False, ext='xml')
+            path = select_file(start_path=config_mod_pymodaq.get_set_overshoot_path(),
+                               save=False, ext='xml')
             if path != '':
                 self.overshoot_manager.set_file_overshoot(path)
 
@@ -475,7 +721,8 @@ class DashBoard(QObject):
 
     def modify_roi(self):
         try:
-            path = select_file(start_path=configmod.get_set_roi_path(), save=False, ext='xml')
+            path = select_file(start_path=config_mod_pymodaq.get_set_roi_path(),
+                               save=False, ext='xml')
             if path != '':
                 self.roi_saver.set_file_roi(path)
 
@@ -494,9 +741,10 @@ class DashBoard(QObject):
                     self.remove_preset_related_files(path.name)
                     if self.detector_modules:
                         mssg = QtWidgets.QMessageBox()
-                        mssg.setText('You have to restart the application to take the modifications into account!\n\n'
-                                     'The related files: ROI, Layout, Overshoot and Remote will be deleted'
-                                     ' if existing!\n\n'
+                        mssg.setText('You have to restart the application to take the modifications'
+                                     ' into account!\n\n'
+                                     'The related files: ROI, Layout, Overshoot and Remote will be'
+                                     ' deleted if existing!\n\n'
                                      'Quitting the application...')
                         mssg.exec()
                         self.restart_fun()
@@ -507,10 +755,10 @@ class DashBoard(QObject):
             logger.exception(str(e))
 
     def remove_preset_related_files(self, name):
-        configmod.get_set_roi_path().joinpath(name).unlink(missing_ok=True)
-        configmod.get_set_layout_path().joinpath(name).unlink(missing_ok=True)
-        configmod.get_set_overshoot_path().joinpath(name).unlink(missing_ok=True)
-        configmod.get_set_remote_path().joinpath(name).unlink(missing_ok=True)
+        config_mod_pymodaq.get_set_roi_path().joinpath(name).unlink(missing_ok=True)
+        config_mod_pymodaq.get_set_layout_path().joinpath(name).unlink(missing_ok=True)
+        config_mod_pymodaq.get_set_overshoot_path().joinpath(name).unlink(missing_ok=True)
+        config_mod_pymodaq.get_set_remote_path().joinpath(name).unlink(missing_ok=True)
 
     def quit_fun(self):
         """
@@ -568,7 +816,8 @@ class DashBoard(QObject):
         ret = False
         mssg = QtWidgets.QMessageBox()
         if ask:
-            mssg.setText('You have to restart the application to take the modifications into account!')
+            mssg.setText('You have to restart the application to take the'
+                         ' modifications into account!')
             mssg.setInformativeText("Do you want to restart?")
             mssg.setStandardButtons(mssg.Ok | mssg.Cancel)
             ret = mssg.exec()
@@ -610,7 +859,8 @@ class DashBoard(QObject):
             path = layout_path.joinpath(self.preset_file.stem + '.dock')
             self.save_layout_state(path)
 
-    def add_move(self, plug_name, plug_settings, plug_type, move_docks, move_forms, actuators_modules):
+    def add_move(self, plug_name, plug_settings, plug_type, move_docks, move_forms,
+                 actuators_modules) -> DAQ_Move:
 
         move_docks.append(Dock(plug_name, size=(150, 250)))
         if len(move_docks) == 1:
@@ -631,21 +881,56 @@ 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_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
+
+        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()
 
-    def add_det(self, plug_name, plug_settings, det_docks_settings, det_docks_viewer, detector_modules):
+        # Update actuators modules and module manager
+        self.actuators_modules.append(actuator)
+        self.update_module_manager()
 
-        plug_type = plug_settings.child('main_settings', 'DAQ_type').value()
-        plug_subtype = plug_settings.child('main_settings', 'detector_type').value()
+    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:
-            self.logger_dock.area.addDock(det_docks_settings[-1], 'bottom')  # dockarea of the logger dock
+            self.logger_dock.area.addDock(det_docks_settings[-1], 'bottom')
+            # dockarea of the logger dock
         else:
             self.dockarea.addDock(det_docks_settings[-1], 'right',
                                   detector_modules[-1].viewer_docks[-1])
@@ -665,9 +950,52 @@ 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 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]]:
         """
@@ -707,16 +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]))
             # %%
@@ -737,8 +1065,8 @@ class DashBoard(QObject):
                     plug_name = plugin['value'].child('name').value()
                     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)
+                    self.splash_sc.showMessage(
+                        'Loading {:s} module: {:s}'.format(plugin['type'], plug_name))
 
                     if plugin['type'] == 'move':
                         plug_type = plug_settings.child('main_settings', 'move_type').value()
@@ -756,10 +1084,11 @@ class DashBoard(QObject):
                                 QtWidgets.QApplication.processEvents()
                                 master_controller = actuators_modules[-1].controller
                             elif plugin['status'] == "Master" and len(plug_IDs) > 1:
-                                raise MasterSlaveError(f'The instrument {plug_name} defined as Master has to be '
-                                                       f'initialized (init checked in the preset) in order to init '
-                                                       f'its associated slave instrument'
-                                                       )
+                                raise MasterSlaveError(
+                                    f'The instrument {plug_name} defined as Master has to be '
+                                    f'initialized (init checked in the preset) in order to init '
+                                    f'its associated slave instrument'
+                                )
                         else:
                             if plugin['status'] != "Slave":
                                 raise MasterSlaveError(f'The instrument {plug_name} should'
@@ -787,10 +1116,11 @@ class DashBoard(QObject):
                                 QtWidgets.QApplication.processEvents()
                                 master_controller = detector_modules[-1].controller
                             elif plugin['status'] == "Master" and len(plug_IDs) > 1:
-                                raise MasterSlaveError(f'The instrument {plug_name} defined as Master has to be '
-                                                       f'initialized (init checked in the preset) in order to init '
-                                                       f'its associated slave instrument'
-                                                       )
+                                raise MasterSlaveError(
+                                    f'The instrument {plug_name} defined as Master has to be '
+                                    f'initialized (init checked in the preset) in order to init '
+                                    f'its associated slave instrument'
+                                )
                         else:
                             if plugin['status'] != "Slave":
                                 raise MasterSlaveError(f'The instrument {plug_name} should'
@@ -879,7 +1209,8 @@ class DashBoard(QObject):
         if remote_action['action_type'] == 'shortcut':
             if remote_action['action_name'] not in self.shortcuts:
                 self.shortcuts[remote_action['action_name']] = \
-                    QtWidgets.QShortcut(QtGui.QKeySequence(remote_action['action_dict']['shortcut']), self.dockarea)
+                    QtWidgets.QShortcut(
+                        QtGui.QKeySequence(remote_action['action_dict']['shortcut']), self.dockarea)
             self.activate_shortcut(self.shortcuts[remote_action['action_name']],
                                    remote_action['action_dict'],
                                    activate=remote_action['action_dict']['activated'])
@@ -922,18 +1253,20 @@ class DashBoard(QObject):
         contained in self.joysticks
         """
 
-        # # Specifi action for axis to get their values even if it doesn't change (in which case it would'nt trigger events)
         for action_dict in self.joysticks.values():
             if action_dict['activated'] and action_dict['actionner_type'].lower() == 'axis':
                 if action_dict['module_type'] == 'act':
-                    joy = utils.find_dict_in_list_from_key_val(self.joysticks_obj, 'id', action_dict['joystickID'])
+                    joy = utils.find_dict_in_list_from_key_val(self.joysticks_obj, 'id',
+                                                               action_dict['joystickID'])
                     val = joy['obj'].get_axis(action_dict['actionnerID'])
                     if abs(val) > 1e-4:
-                        module = self.modules_manager.get_mod_from_name(action_dict['module_name'],
-                                                                        mod=action_dict['module_type'])
+                        module = self.modules_manager.get_mod_from_name(
+                            action_dict['module_name'],
+                            mod=action_dict['module_type'])
                         action = getattr(module, action_dict['action'])
                         if module.move_done_bool:
-                            action(val * 1 * module.settings.child('move_settings', 'epsilon').value())
+                            action(val * 1 * module.settings.child(
+                                'move_settings', 'epsilon').value())
 
         # # For other actions use the event loop
         for event in self.pygame.event.get():  # User did something.
@@ -949,18 +1282,21 @@ class DashBoard(QObject):
             if len(selection) > 1:
                 for action_dict in self.joysticks.values():
                     if action_dict['activated']:
-                        module = self.modules_manager.get_mod_from_name(action_dict['module_name'],
-                                                                        mod=action_dict['module_type'])
+                        module = self.modules_manager.get_mod_from_name(
+                            action_dict['module_name'],
+                            mod=action_dict['module_type'])
                         if action_dict['module_type'] == 'det':
                             action = getattr(module, action_dict['action'])
                         else:
                             action = getattr(module, action_dict['action'])
 
                         if action_dict['joystickID'] == selection['joy']:
-                            if action_dict['actionner_type'].lower() == 'button' and 'button' in selection:
+                            if (action_dict['actionner_type'].lower() == 'button' and
+                                    'button' in selection):
                                 if action_dict['actionnerID'] == selection['button']:
                                     action()
-                            elif action_dict['actionner_type'].lower() == 'hat' and 'hat' in selection:
+                            elif (action_dict['actionner_type'].lower() == 'hat' and
+                                  'hat' in selection):
                                 if action_dict['actionnerID'] == selection['hat']:
                                     action(selection['value'])
 
@@ -968,7 +1304,8 @@ class DashBoard(QObject):
 
     def activate_shortcut(self, shortcut, action=None, activate=True):
         """
-        action = dict(shortcut=action.child(('shortcut')).value(), activated=True, name=f'action{ind:02d}',
+        action = dict(shortcut=action.child(('shortcut')).value(), activated=True,
+         name=f'action{ind:02d}',
                              action=action.child(('action')).value(), module_name=module)
         Parameters
         ----------
@@ -990,7 +1327,8 @@ class DashBoard(QObject):
                 pass
 
     def create_activated_shortcut(self, action):
-        module = self.modules_manager.get_mod_from_name(action['module_name'], mod=action['module_type'])
+        module = self.modules_manager.get_mod_from_name(action['module_name'],
+                                                        mod=action['module_type'])
         if action['module_type'] == 'det':
             return lambda: getattr(module, action['action'])()
         else:
@@ -1007,29 +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.child(('overshoot_value')).value())
-                        for move_param in det_param.child(('params')).children():
-                            if move_param.child(('move_overshoot')).value():
-                                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.child(('position')).value()))
+                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):
@@ -1042,10 +1373,12 @@ class DashBoard(QObject):
         """
             | Set the managers mode from the given filename.
             |
-            | In case of "mock" or "canon" move, set the corresponding managers calling set_(*)_preset procedure.
+            | In case of "mock" or "canon" move, set the corresponding managers calling
+            set_(*)_preset procedure.
             |
             | Else set the managers file using set_file_preset function.
-            | Once done connect the move and detector modules to logger to recipe/transmit informations.
+            | Once done connect the move and detector modules to logger to recipe/transmit
+            informations.
 
             Finally update DAQ_scan_settings tree with :
                 * Detectors
@@ -1064,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)
@@ -1071,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()
@@ -1080,80 +1416,40 @@ 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:
                     area.window().setVisible(True)
-                messagebox(text=f'{str(error)}\nQuitting the application...', title='Incompatibility')
+                messagebox(text=f'{str(error)}\nQuitting the application...',
+                           title='Incompatibility')
                 logger.exception(str(error))
 
                 self.quit_fun()
                 return
 
             if not (not actuators_modules and not detector_modules):
-                self.update_status('Preset mode ({}) has been loaded'.format(filename.name), log_type='log')
+                self.update_status('Preset mode ({}) has been loaded'.format(filename.name),
+                                   log_type='log')
                 self.settings.child('loaded_files', 'preset_file').setValue(filename.name)
                 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 = PIDController(self.pid_module)
-                            actuators_modules[-1].master = False
-                            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(det_modules=[det.title for det in detector_modules],
-                                                          actuators_modules=[move.title for move in actuators_modules])
+                self.overshoot_manager = OvershootManager(
+                    det_modules=[det.title for det in detector_modules],
+                    actuators_modules=[move.title for move in actuators_modules])
                 # load overshoot if present
                 file = filename.name
                 path = overshoot_path.joinpath(file)
                 if path.is_file():
                     self.set_overshoot_configuration(path)
 
-                self.remote_manager = RemoteManager(actuators=[move.title for move in actuators_modules],
-                                                    detectors=[det.title for det in detector_modules])
+                self.remote_manager = RemoteManager(
+                    actuators=[move.title for move in actuators_modules],
+                    detectors=[det.title for det in detector_modules])
                 # load remote file if present
                 file = filename.name
                 path = remote_path.joinpath(file)
@@ -1179,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()
@@ -1198,17 +1496,19 @@ class DashBoard(QObject):
     def update_init_tree(self):
         for act in self.actuators_modules:
             name = ''.join(act.title.split())  # remove empty spaces
-            if act.title not in [ac.title() for ac in putils.iter_children_params(self.settings.child(('actuators')), [])]:
+            if act.title not in [ac.title() for ac in putils.iter_children_params(
+                    self.settings.child('actuators'), [])]:
 
-                self.settings.child(('actuators')).addChild(
+                self.settings.child('actuators').addChild(
                     {'title': act.title, 'name': name, 'type': 'led', 'value': False})
                 QtWidgets.QApplication.processEvents()
             self.settings.child('actuators', name).setValue(act.initialized_state)
 
         for det in self.detector_modules:
             name = ''.join(det.title.split())  # remove empty spaces
-            if det.title not in [de.title() for de in putils.iter_children_params(self.settings.child(('detectors')), [])]:
-                self.settings.child(('detectors')).addChild(
+            if det.title not in [de.title() for de in putils.iter_children_params(
+                    self.settings.child('detectors'), [])]:
+                self.settings.child('detectors').addChild(
                     {'title': det.title, 'name': name, 'type': 'led', 'value': False})
                 QtWidgets.QApplication.processEvents()
             self.settings.child('detectors', name).setValue(det.initialized_state)
@@ -1233,38 +1533,22 @@ class DashBoard(QObject):
         webbrowser.open(logging.getLogger('pymodaq').handlers[0].baseFilename)
 
     def show_config(self):
-        from pymodaq.utils.gui_utils.widgets.tree_toml import TreeFromToml
+        from pymodaq_gui.utils.widgets.tree_toml import TreeFromToml
         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)
@@ -1273,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):
         """
@@ -1299,11 +1571,6 @@ class DashBoard(QObject):
 
             Once done emit the update settings signal to link the commit.
 
-            =============== =================================== ================================================================
-            **Parameters**    **Type**                           **Description**
-            *param*           instance of ppyqtgraph parameter   the parameter to be checked
-            *changes*         tuple list                         Contain the (param,changes,info) list listing the changes made
-            =============== =================================== ================================================================
 
         """
 
@@ -1324,34 +1591,78 @@ class DashBoard(QObject):
     def show_about(self):
         self.splash_sc.setVisible(True)
         self.splash_sc.showMessage(
-            "PyMoDAQ version {:}\nModular Acquisition with Python\nWritten by Sébastien Weber".format(get_version()),
-            QtCore.Qt.AlignRight, QtCore.Qt.white)
+            f"PyMoDAQ version {get_version('pymodaq')}\n"
+            f"Modular Acquisition with Python\n"
+            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, {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.
@@ -1359,9 +1670,12 @@ class DashBoard(QObject):
             In case of :
                 * *scan* : Set parameters showing top false
                 * *dataset* : Set parameters showing top false
-                * *managers* : Set parameters showing top false. Add the save/cancel buttons to the accept/reject dialog (to save managers parameters in a xml file).
+                * *managers* : Set parameters showing top false.
+                Add the save/cancel buttons to the accept/reject dialog
+                (to save managers parameters in a xml file).
 
-            Finally, in case of accepted managers type info, save the managers parameters in a xml file.
+            Finally, in case of accepted managers type info,
+            save the managers parameters in a xml file.
 
             =============== =========== ====================================
             **Parameters**    **Type**    **Description**
@@ -1417,7 +1731,8 @@ class DashBoard(QObject):
 
 
 def main():
-    from pymodaq.utils.gui_utils.utils import mkQApp
+    from pymodaq_gui.utils.utils import mkQApp
+
     app = mkQApp('Dashboard')
 
     win = QtWidgets.QMainWindow()
@@ -1426,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__':