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

pymodaq/control_modules/daq_move_ui/factory.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+from typing import Callable, TYPE_CHECKING
+
+from pymodaq_utils.logger import set_logger, get_module_name
+
+if TYPE_CHECKING:
+    from .ui_base import DAQ_Move_UI_Base
+
+logger = set_logger(get_module_name(__file__))
+
+
+
+class ActuatorUIFactory:
+    _builders: dict[str, type['DAQ_Move_UI_Base']] = {}
+
+    @classmethod
+    def register(cls, identifier: str) -> Callable:
+        """ To be used as a decorator
+
+        Register in the class registry a new scanner class using its 1 identifier
+        """
+
+        def inner_wrapper(wrapped_class: type['DAQ_Move_UI_Base']) -> type['DAQ_Move_UI_Base']:
+            key = identifier
+
+            if key not in cls._builders:
+                cls._builders[key] = wrapped_class
+            else:
+                logger.warning(f'The {key} builder is already registered. Replacing it')
+            return wrapped_class
+
+        return inner_wrapper
+
+
+    @classmethod
+    def get(cls, key : str) -> type['DAQ_Move_UI_Base']:
+        builder = cls._builders.get(key)
+        if not builder:
+            raise ValueError(key)
+        return builder
+
+    @classmethod
+    def create(cls, key: str, **kwargs) -> 'DAQ_Move_UI_Base':
+        return cls._builders[key](**kwargs)
+
+    @classmethod
+    def keys(cls) -> list[str]:
+        return list(cls._builders.keys())

pymodaq/control_modules/{daq_move_ui.py → daq_move_ui/ui_base.py}

@@ -1,35 +1,28 @@
-# -*- coding: utf-8 -*-
-"""
-Created the 28/07/2022
-
-@author: Sebastien Weber
-"""
-
-from typing import List
-import sys
-from pint.errors import DimensionalityError
+from abc import abstractmethod
 
+from qtpy.QtWidgets import QComboBox
+from pint import DimensionalityError
 from qtpy import QtWidgets
-from qtpy.QtCore import Signal, Qt
-from qtpy.QtWidgets import QHBoxLayout, QVBoxLayout, QGridLayout, QWidget, QToolBar, QComboBox
+from typing import Union, List
 
-from pymodaq_utils.utils import ThreadCommand
 from pymodaq_utils.config import Config
-
+from pymodaq.control_modules.thread_commands import UiToMainMove
+from pymodaq.control_modules.ui_utils import ControlModuleUI
+from pymodaq.utils.data import DataActuator
 from pymodaq_data import Q_
+from pymodaq_data import DataToExport
+from pymodaq_gui.plotting.data_viewers import ViewerDispatcher
+from pymodaq_gui.utils import DockArea, QSpinBoxWithShortcut, PushButtonIcon, QLED, QSpinBox_ro
+from pymodaq_gui.parameter import ParameterTree
+from pymodaq_gui.utils.widgets import LabelWithFont
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq.utils.config import Config as ControlModulesConfig
 
-from pymodaq_gui.utils.widgets import PushButtonIcon, LabelWithFont, SpinBox, QSpinBox_ro, QLED, QSpinBoxWithShortcut
-from pymodaq_gui.utils import DockArea
-from pymodaq_gui.plotting.data_viewers.viewer import ViewerDispatcher
-
-from pymodaq.control_modules.utils import ControlModuleUI
-from pymodaq.utils.data import DataToExport, DataActuator
-
-
-config = Config()
+config_utils = Config()
+config = ControlModulesConfig()
 
 
-class DAQ_Move_UI(ControlModuleUI):
+class DAQ_Move_UI_Base(ControlModuleUI):
     """DAQ_Move user interface.
 
     This class manages the UI and emit dedicated signals depending on actions from the user
@@ -65,15 +58,44 @@ class DAQ_Move_UI(ControlModuleUI):
     pymodaq.utils.daq_utils.ThreadCommand
     """
 
-    def __init__(self, parent, title="DAQ_Move"):
+    is_compact = False
 
+    def __init__(self, parent: Union[DockArea, QtWidgets.QWidget], title="DAQ_Move"):
         super().__init__(parent)
         self.title = title
         self._unit = ''
+
+        self.actuators_combo: QComboBox = None
+        self.abs_value_sb: QSpinBoxWithShortcut = None
+        self.abs_value_sb_2: QSpinBoxWithShortcut = None
+        self.abs_value_sb_bis: QSpinBoxWithShortcut = None
+        self.ini_actuator_pb: PushButtonIcon = None
+        self.ini_state_led: QLED = None
+        self.move_done_led: QLED = None
+        self.current_value_sb: QSpinBox_ro = None
+        self.find_home_pb: PushButtonIcon = None
+        self.move_rel_plus_pb: PushButtonIcon = None
+        self.move_abs_pb: PushButtonIcon = None
+        self.rel_value_sb: QSpinBoxWithShortcut = None
+        self.move_rel_minus_pb: PushButtonIcon = None
+        self.stop_pb: PushButtonIcon = None
+        self.get_value_pb: PushButtonIcon = None
+        self.statusbar: QtWidgets.QStatusBar = None
+
+        self.control_widget: QtWidgets.QWidget = None
+        self.graph_widget: QtWidgets.QWidget = None
+        self.viewer: ViewerDispatcher = None
+
+        self._tree: ParameterTree = None
+
+
         self.setup_ui()
 
         self.enable_move_buttons(False)
 
+    def show_data(self, data: DataToExport):
+        self.viewer.show_data(data)
+
     def display_value(self, value: DataActuator):
         try:
             self.current_value_sb.setValue(value.value(self._unit))
@@ -117,16 +139,14 @@ class DAQ_Move_UI(ControlModuleUI):
     def move_done(self, status):
         self.move_done_led.set_as(status)
 
-    def set_settings_tree(self, tree):
-        self.settings_ui.layout().addWidget(tree)
-
     def enable_move_buttons(self, status):
         self.abs_value_sb.setEnabled(status)
         self.abs_value_sb_2.setEnabled(status)
-        self.control_ui.setEnabled(status)
+        for action_name in ('move_abs', 'move_abs_2', 'move_rel'):
+            if action_name in self.actions_names:
+                self.get_action(action_name).setEnabled(status)
 
-        self.get_action('move_abs').setEnabled(status)
-        self.get_action('move_abs_2').setEnabled(status)
+        self.control_widget.setEnabled(status)
 
     def set_abs_spinbox_properties(self, **properties):
         """ Change the Spinbox properties
@@ -159,185 +179,96 @@ class DAQ_Move_UI(ControlModuleUI):
             self.abs_value_sb_2.setSingleStep(properties['step'])
             self.abs_value_sb_bis.setSingleStep(properties['step'])
 
-    def show_data(self, data: DataToExport):
-        self.viewer.show_data(data)
+    def set_abs_value_red(self, value: Q_):
+        self.abs_value_sb_2.setValue(value.m_as(self._unit))
+
+    def set_abs_value_green(self, value: Q_):
+        self.abs_value_sb.setValue(value.m_as(self._unit))
+
+    def set_abs_value(self, value: Q_):
+        self.abs_value_sb_bis.setValue(value.m_as(self._unit))
+
+    def set_rel_value(self, value: Q_):
+        self.rel_value_sb.setValue(value.m_as(self._unit))
+
+    def set_unit_as_suffix(self, unit: str):
+        """Will append the actuator units in the value display"""
+        self._unit = unit
+        self.current_value_sb.setOpts(suffix=unit)
+        self.abs_value_sb_bis.setOpts(suffix=unit)
+        self.abs_value_sb.setOpts(suffix=unit)
+        self.abs_value_sb_2.setOpts(suffix=unit)
+        self.rel_value_sb.setOpts(suffix=unit)
+
+    def set_unit_prefix(self, show=True):
+        """ Change the display status of the spinbox SI prefix"""
+        self.current_value_sb.setOpts(siPrefix=show)
+        self.abs_value_sb_bis.setOpts(siPrefix=show)
+        self.abs_value_sb.setOpts(siPrefix=show)
+        self.abs_value_sb_2.setOpts(siPrefix=show)
+        self.rel_value_sb.setOpts(siPrefix=show)
 
     def setup_docks(self):
-        self.parent.setLayout(QVBoxLayout())
-        #self.parent.layout().setSizeConstraint(QHBoxLayout.SetFixedSize)
-        self.parent.layout().setContentsMargins(2, 2, 2, 2)
-
-        widget = QWidget()
-        widget.setLayout(QHBoxLayout())
-        splitter_hor = QtWidgets.QSplitter(Qt.Orientation.Horizontal)
-        widget.layout().addWidget(splitter_hor)
-        self.parent.layout().addWidget(widget)
-
-        self.main_ui = QWidget()
-        self.control_ui = QWidget()
-        self.settings_ui = QWidget()
-        self.graph_ui = QWidget()
-        self.graph_ui.setLayout(QtWidgets.QHBoxLayout())
-        self.graph_ui.layout().setContentsMargins(0, 0, 0, 0)
-        dockarea = DockArea()
-        self.graph_ui.layout().addWidget(dockarea)
-        self.viewer = ViewerDispatcher(dockarea)
 
-        left_widget = QWidget()
-        left_widget.setLayout(QVBoxLayout())
-        left_widget.layout().addWidget(self.main_ui)
-        left_widget.layout().addWidget(self.control_ui)
-        left_widget.layout().setContentsMargins(0, 0, 0, 0)
-        left_widget.layout().addStretch()
-        splitter_hor.addWidget(left_widget)
-        splitter_hor.addWidget(self.settings_ui)
-        #widget.layout().addStretch()
-
-        # populate the main ui
-        self.move_toolbar = QToolBar()
-        self.main_ui.setLayout(QGridLayout())
-        self.main_ui.layout().setSpacing(0)
-        self.main_ui.layout().setContentsMargins(0, 0, 0, 0)
-
-        self.main_ui.layout().addWidget(self.toolbar, 0, 0, 1, 2)
-        self.main_ui.layout().addWidget(self.move_toolbar, 1, 0, 1, 2)
+        self.control_widget = QtWidgets.QWidget()
 
+        self.actuators_combo = QComboBox()
         self.abs_value_sb = QSpinBoxWithShortcut(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
         self.abs_value_sb.setStyleSheet("background-color : lightgreen; color: black")
+
         self.abs_value_sb_2 = QSpinBoxWithShortcut(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
         self.abs_value_sb_2.setStyleSheet("background-color : lightcoral; color: black")
-        self.move_toolbar.addWidget(self.abs_value_sb)
-        self.move_toolbar.addWidget(self.abs_value_sb_2)
 
-        self.main_ui.layout().addWidget(LabelWithFont('Actuator:'), 2, 0)
-        self.actuators_combo = QComboBox()
-        self.main_ui.layout().addWidget(self.actuators_combo, 2, 1)
+        self.abs_value_sb_bis = QSpinBoxWithShortcut(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
         self.ini_actuator_pb = PushButtonIcon('ini', 'Initialization', checkable=True,
-                                           tip='Start This actuator initialization')
-        self.main_ui.layout().addWidget(self.ini_actuator_pb, 3, 0)
+                                              tip='Start This actuator initialization')
         self.ini_state_led = QLED(readonly=True)
-        self.main_ui.layout().addWidget(self.ini_state_led, 3, 1)
-        self.main_ui.layout().addWidget(LabelWithFont('Current value:'), 4, 0)
         self.move_done_led = QLED(readonly=True)
-        self.main_ui.layout().addWidget(self.move_done_led, 4, 1)
         self.current_value_sb = QSpinBox_ro(font_size=20, min_height=27,
                                             siPrefix=config('actuator', 'siprefix'),
                                             )
-        self.main_ui.layout().addWidget(self.current_value_sb, 5, 0, 1, 2)
-
-        # populate the control ui
-        self.control_ui.setLayout(QGridLayout())
-        self.control_ui.layout().addWidget(LabelWithFont('Abs. Value'), 0, 0)
         self.find_home_pb = PushButtonIcon('home2', 'Find Home')
-        self.control_ui.layout().addWidget(self.find_home_pb, 0, 1)
-        self.abs_value_sb_bis = QSpinBoxWithShortcut(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
-        self.control_ui.layout().addWidget(self.abs_value_sb_bis, 1, 0)
+        self.move_rel_plus_pb = PushButtonIcon('MoveUp', 'Set Rel. (+)')
         self.move_abs_pb = PushButtonIcon('Move', 'Set Abs.',
                                           tip='Set the value of the actuator to the set absolute value')
-        self.control_ui.layout().addWidget(self.move_abs_pb, 1, 1)
-        self.control_ui.layout().addWidget(LabelWithFont('Rel. Increment'), 2, 0)
-        self.move_rel_plus_pb = PushButtonIcon('MoveUp', 'Set Rel. (+)')
-        self.control_ui.layout().addWidget(self.move_rel_plus_pb, 2, 1)
-
         self.rel_value_sb = QSpinBoxWithShortcut(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'),
                                                  key_sequences=("Ctrl+E","Ctrl+Shift+E"),)
-        self.control_ui.layout().addWidget(self.rel_value_sb, 3, 0)
         self.move_rel_minus_pb = PushButtonIcon('MoveDown', 'Set Rel. (-)')
-        self.control_ui.layout().addWidget(self.move_rel_minus_pb, 3, 1)
         self.stop_pb = PushButtonIcon('stop', 'Stop')
-        self.control_ui.layout().addWidget(self.stop_pb, 4, 0)
         self.get_value_pb = PushButtonIcon('Help_32', 'Update Value')
-        self.control_ui.layout().addWidget(self.get_value_pb, 4, 1)
-        self.control_ui.layout().setContentsMargins(0, 0, 0, 0)
-
-        self.settings_ui.setLayout(QHBoxLayout())
-        self.settings_ui.layout().setContentsMargins(0, 0, 0, 0)
-
-        self.control_ui.setVisible(False)
-        self.settings_ui.setVisible(False)
-
         self.statusbar = QtWidgets.QStatusBar()
         self.statusbar.setMaximumHeight(30)
-        self.parent.layout().addWidget(self.statusbar)
-
-    def set_abs_value_red(self, value: Q_):
-        self.abs_value_sb_2.setValue(value.m_as(self._unit))
-
-    def set_abs_value_green(self, value: Q_):
-        self.abs_value_sb.setValue(value.m_as(self._unit))
-
-    def set_abs_value(self, value: Q_):
-        self.abs_value_sb_bis.setValue(value.m_as(self._unit))
-
-    def set_rel_value(self, value: Q_):
-        self.rel_value_sb.setValue(value.m_as(self._unit))
 
-    def set_unit_as_suffix(self, unit: str):
-        """Will append the actuator units in the value display"""
-        self._unit = unit
-        self.current_value_sb.setOpts(suffix=unit)
-        self.abs_value_sb_bis.setOpts(suffix=unit)
-        self.abs_value_sb.setOpts(suffix=unit)
-        self.abs_value_sb_2.setOpts(suffix=unit)
-        self.rel_value_sb.setOpts(suffix=unit)
-
-    def setup_actions(self):
-        self.add_action('move_abs', 'Move Abs', 'go_to_1', "Move to the set absolute value",
-                        toolbar=self.move_toolbar)
-        self.add_action('move_abs_2', 'Move Abs', 'go_to_2', "Move to the other set absolute value",
-                        toolbar=self.move_toolbar)
-        self.add_action('show_controls', 'Show Controls', 'Add_Step', "Show more controls", checkable=True,
-                        toolbar=self.toolbar)
-        self.add_action('show_settings', 'Show Settings', 'tree', "Show Settings", checkable=True,
-                        toolbar=self.toolbar)
-        self.add_action('show_config', 'Show Config', 'Settings', "Show PyMoDAQ Config", checkable=False,
-                        toolbar=self.toolbar)
-        self.add_action('show_graph', 'Show Graph', 'graph', "Show Graph", checkable=True,
-                        toolbar=self.toolbar)
-        self.add_action('refresh_value', 'Refresh', 'Refresh2', "Refresh Value", checkable=True,
-                        toolbar=self.toolbar)
-        self.add_action('stop', 'Stop', 'stop', "Stop Motion", checkable=False,
-                        toolbar=self.toolbar)
-        self.add_action('quit', 'Quit the module', 'close2')
-        self.add_action('log', 'Show Log file', 'information2')
-
-        self.toolbar.addWidget(LabelWithFont(self.title, font_name="Tahoma", font_size=14, isbold=True, isitalic=True))
+        self.graph_widget = QtWidgets.QWidget()
+        self.graph_widget.setLayout(QtWidgets.QHBoxLayout())
+        self.graph_widget.layout().setContentsMargins(0, 0, 0, 0)
+        dockarea = DockArea()
+        self.graph_widget.layout().addWidget(dockarea)
+        self.viewer = ViewerDispatcher(dockarea)
 
-    def connect_things(self):
-        self.connect_action('show_controls', lambda show: self.control_ui.setVisible(show))
-        self.connect_action('show_settings', lambda show: self.settings_ui.setVisible(show))
-        self.connect_action('show_graph', lambda show: self.graph_ui.setVisible(show))
-
-        self.connect_action('quit', lambda: self.command_sig.emit(ThreadCommand('quit', )))
-        self.connect_action('refresh_value',
-                            lambda do_refresh: self.command_sig.emit(ThreadCommand('loop_get_value', do_refresh)))
-        self.connect_action('move_abs', lambda: self.emit_move_abs(self.abs_value_sb))
-        self.connect_action('move_abs_2', lambda: self.emit_move_abs(self.abs_value_sb_2))
-        self.connect_action('log', lambda: self.command_sig.emit(ThreadCommand('show_log', )))
-        self.connect_action('stop', lambda: self.command_sig.emit(ThreadCommand('stop', )))
-        self.connect_action('show_config', lambda: self.command_sig.emit(ThreadCommand('show_config', )))
+    def populate_control_ui(self,  widget: QtWidgets.QWidget):
+        widget.setLayout(QtWidgets.QGridLayout())
+        widget.layout().addWidget(LabelWithFont('Abs. Value'), 0, 0)
 
-        self.move_abs_pb.clicked.connect(lambda: self.emit_move_abs(self.abs_value_sb_bis))
-        self.abs_value_sb.shortcut["Ctrl+E"].activated.connect(lambda: self.emit_move_abs(self.abs_value_sb))
-        self.abs_value_sb_2.shortcut["Ctrl+E"].activated.connect(lambda: self.emit_move_abs(self.abs_value_sb_2))
-        self.abs_value_sb_bis.shortcut["Ctrl+E"].activated.connect(lambda: self.emit_move_abs(self.abs_value_sb_bis))
+        widget.layout().addWidget(self.find_home_pb, 0, 1)
 
+        widget.layout().addWidget(self.abs_value_sb_bis, 1, 0)
+        widget.layout().addWidget(self.move_abs_pb, 1, 1)
+        widget.layout().addWidget(LabelWithFont('Rel. Increment'), 2, 0)
+        widget.layout().addWidget(self.move_rel_plus_pb, 2, 1)
 
-        self.rel_value_sb.valueChanged.connect(lambda: self.command_sig.emit(
-            ThreadCommand('rel_value', self.rel_value_sb.value())))
-        self.move_rel_plus_pb.clicked.connect(lambda: self.emit_move_rel('+'))
-        self.move_rel_minus_pb.clicked.connect(lambda: self.emit_move_rel('-'))
-        self.rel_value_sb.shortcut["Ctrl+E"].activated.connect(lambda: self.emit_move_rel('+'))
-        self.rel_value_sb.shortcut["Ctrl+Shift+E"].activated.connect(lambda: self.emit_move_rel('-'))
+        widget.layout().addWidget(self.rel_value_sb, 3, 0)
 
-        self.find_home_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand('find_home', )))
-        self.stop_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand('stop', )))
-        self.get_value_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand('get_value', )))
+        widget.layout().addWidget(self.move_rel_minus_pb, 3, 1)
+        widget.layout().addWidget(self.stop_pb, 4, 0)
 
-        self.ini_actuator_pb.clicked.connect(self.send_init)
+        widget.layout().addWidget(self.get_value_pb, 4, 1)
+        widget.layout().setContentsMargins(0, 0, 0, 0)
+        widget.setVisible(False)
 
-        self.actuators_combo.currentTextChanged.connect(
-            lambda act: self.command_sig.emit(ThreadCommand('actuator_changed', act)))
+    def close(self):
+        self.parent.close()
+        self.graph_widget.close()
 
     def do_init(self, do_init=True):
         """Programmatically press the Init button
@@ -352,50 +283,77 @@ class DAQ_Move_UI(ControlModuleUI):
 
     def send_init(self, checked):
         self.actuators_combo.setEnabled(not checked)
-        self.command_sig.emit(ThreadCommand('init', [self.ini_actuator_pb.isChecked(),
-                                                     self.actuators_combo.currentText()]))
+        self.command_sig.emit(ThreadCommand(UiToMainMove.INIT, [self.ini_actuator_pb.isChecked(),
+                                                                self.actuators_combo.currentText()]))
 
     def emit_move_abs(self, spinbox):
         spinbox.editingFinished.emit()
-        self.command_sig.emit(ThreadCommand('move_abs', DataActuator(data=spinbox.value(),
-                                                                     units=self._unit)))
+        self.command_sig.emit(ThreadCommand(UiToMainMove.MOVE_ABS, DataActuator(data=spinbox.value(),
+                                                                                units=self._unit)))
 
     def emit_move_rel(self, sign):
         self.command_sig.emit(ThreadCommand(
-            'move_rel',
+            UiToMainMove.MOVE_REL,
             DataActuator(data=self.rel_value_sb.value() * (1 if sign == '+' else -1),
                          units=self._unit)))
 
-    def close(self):
-        self.graph_ui.close()
-        self.parent.close()
-
-
-def main(init_qt=True):
-    from pymodaq_gui.utils.dock import DockArea
-    if init_qt:  # used for the test suite
-        app = QtWidgets.QApplication(sys.argv)
-
-    actuators = [f'act{ind}' for ind in range(5)]
+    def set_settings_tree(self, tree):
+        self._tree = tree
 
-    widget = QtWidgets.QWidget()
-    prog = DAQ_Move_UI(widget, title="test")
-    widget.show()
-    
-    def print_command_sig(cmd_sig):
-        print(cmd_sig)
-        if cmd_sig.command == 'init':
-            prog.enable_move_buttons(True)
-        
-    prog.command_sig.connect(print_command_sig)
-    prog.actuators = actuators
+    def connect_things(self):
+        if 'show_controls' in self.actions_names:
+            self.connect_action('show_controls', self.show_controls)
+        if 'show_settings' in self.actions_names:
+            self.connect_action('show_settings', self.show_tree)
+        if 'show_graph' in self.actions_names:
+            self.connect_action('show_graph', self.show_graph)
+        if 'move_abs' in self.actions_names:
+            self.connect_action('move_abs', lambda: self.emit_move_abs(self.abs_value_sb))
+        if 'move_abs_2' in self.actions_names:
+            self.connect_action('move_abs_2', lambda: self.emit_move_abs(self.abs_value_sb_2))
+        if 'log' in self.actions_names:
+            self.connect_action('log', lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.SHOW_LOG, )))
+        if 'stop' in self.actions_names:
+            self.connect_action('stop', lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.STOP, )))
+        if 'show_config' in self.actions_names:
+            self.connect_action('show_config', lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.SHOW_CONFIG, )))
+        if 'ini_actuator' in self.actions_names:
+            self.connect_action('ini_actuator', self.ini_actuator_pb.click)
 
+        self.move_abs_pb.clicked.connect(lambda: self.emit_move_abs(self.abs_value_sb_bis))
+        self.abs_value_sb.shortcut["Ctrl+E"].activated.connect(lambda: self.emit_move_abs(self.abs_value_sb))
+        self.abs_value_sb_2.shortcut["Ctrl+E"].activated.connect(lambda: self.emit_move_abs(self.abs_value_sb_2))
+        self.abs_value_sb_bis.shortcut["Ctrl+E"].activated.connect(lambda: self.emit_move_abs(self.abs_value_sb_bis))
+        self.rel_value_sb.valueChanged.connect(lambda: self.command_sig.emit(
+            ThreadCommand(UiToMainMove.REL_VALUE, self.rel_value_sb.value())))
+        self.move_rel_plus_pb.clicked.connect(lambda: self.emit_move_rel('+'))
+        self.move_rel_minus_pb.clicked.connect(lambda: self.emit_move_rel('-'))
+        self.rel_value_sb.shortcut["Ctrl+E"].activated.connect(lambda: self.emit_move_rel('+'))
+        self.rel_value_sb.shortcut["Ctrl+Shift+E"].activated.connect(lambda: self.emit_move_rel('-'))
 
-            
-    if init_qt:
-        sys.exit(app.exec_())
-    return prog, widget
+        self.find_home_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.FIND_HOME, )))
+        self.stop_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.STOP, )))
+        self.get_value_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.GET_VALUE, )))
 
+        self.ini_actuator_pb.clicked.connect(self.send_init)
 
-if __name__ == '__main__':
-    main()
+        self.actuators_combo.currentTextChanged.connect(
+            lambda act: self.command_sig.emit(ThreadCommand(UiToMainMove.ACTUATOR_CHANGED, act)))
+        if 'quit' in self.actions_names:
+            self.connect_action('quit', lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.QUIT, )))
+        if 'refresh_value' in self.actions_names:
+            self.connect_action('refresh_value',
+                                lambda do_refresh: self.command_sig.emit(ThreadCommand(UiToMainMove.LOOP_GET_VALUE,
+                                                                                   do_refresh)))
+
+    def show_tree(self, show: bool = True):
+        self._tree.setVisible(show)
+        self._tree.closeEvent = lambda event: self.set_action_checked('show_settings', False)
+
+    def show_controls(self, show: bool = True):
+        self.control_widget.setVisible(show)
+        self.control_widget.closeEvent = lambda event: self.set_action_checked('show_controls', False)
+
+    def show_graph(self, show: bool = True):
+        self.graph_widget.setVisible(show)
+        self.graph_widget.closeEvent = lambda event: self.set_action_checked('show_graph', False)

pymodaq/control_modules/daq_move_ui/uis/binary.py

@@ -0,0 +1,139 @@
+import sys
+from typing import Union
+
+from qtpy.QtWidgets import QVBoxLayout, QToolBar
+from qtpy import QtWidgets
+
+from pymodaq.control_modules.daq_move_ui.ui_base import DAQ_Move_UI_Base
+from pymodaq.control_modules.thread_commands import UiToMainMove
+from pymodaq_gui.utils.widgets import LabelWithFont
+
+from pymodaq.utils.data import DataActuator
+
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_utils.config import Config
+
+from pymodaq.control_modules.daq_move_ui.factory import ActuatorUIFactory
+from pymodaq.control_modules.daq_move_ui.uis.simple import DAQ_Move_UI_Simple
+from pymodaq.utils.config import Config as ControlModulesConfig
+from enum import Enum
+
+config = ControlModulesConfig()
+
+
+class BinaryValue(Enum):
+    VALUE_ONE = config('actuator', 'binary', 'value_1')
+    VALUE_TWO = config('actuator', 'binary', 'value_2')
+
+
+@ActuatorUIFactory.register('Binary')
+class DAQ_Move_UI_Binary(DAQ_Move_UI_Simple):
+    """ UI for Actuators where only two values are encoded: 0 or 1 for instance
+
+    Some other numerical values can be set in the config: 'actuator', 'binary', 'value_1'
+    The green arrow button will fire the 'value_1'
+    The red arrow button will fire the 'value_2'
+
+    Could be used for 2 positions only actuators such as a Flip
+    """
+
+
+    is_compact = True
+
+    def setup_actions(self):
+        self.add_widget('name', LabelWithFont(f'{self.title}: ', font_name="Tahoma",
+                                              font_size=14, isbold=True, isitalic=True),
+                        toolbar=self.move_toolbar)
+
+        self.add_widget('actuators_combo', self.actuators_combo, toolbar=self.move_toolbar)
+        self.add_action('ini_actuator', 'Ini. Actuator', 'ini', toolbar=self.move_toolbar)
+        self.add_widget('ini_led', self.ini_state_led, toolbar=self.move_toolbar)
+        self.add_widget('current', self.current_value_sb, toolbar=self.move_toolbar)
+        self.add_widget('move_done', self.move_done_led, toolbar=self.move_toolbar)
+        self.add_action('move_abs', 'Move Abs', 'go_to_1', "Move to the set absolute value",
+                        toolbar=self.move_toolbar)
+        self.add_action('move_abs_2', 'Move Abs', 'go_to_2', "Move to the other set absolute"
+                                                             " value",
+                        toolbar=self.move_toolbar)
+
+
+        self.add_action('stop', 'Stop', 'stop', "Stop Motion", toolbar=self.move_toolbar)
+
+        self.add_action('show_settings', 'Show Settings', 'tree', "Show Settings", checkable=True,
+                        toolbar=self.move_toolbar)
+        self.add_action('show_controls', 'Show Controls', 'Add_Step', "Show more controls", checkable=True,
+                        toolbar=self.move_toolbar)
+        self.add_action('show_graph', 'Show Graph', 'graph', "Show Graph", checkable=True,
+                        toolbar=self.move_toolbar)
+        self.add_action('refresh_value', 'Refresh', 'Refresh2', "Refresh Value", checkable=True,
+                        toolbar=self.move_toolbar)
+        self.move_toolbar.addSeparator()
+        self.add_action('show_config', 'Show Config', 'Settings', "Show PyMoDAQ Config", checkable=False,
+                        toolbar=self.move_toolbar)
+        self.add_action('quit', 'Quit the module', 'close2', toolbar=self.move_toolbar)
+        self.add_action('log', 'Show Log file', 'information2', toolbar=self.move_toolbar)
+        self.add_widget('status', self.statusbar, toolbar=self.move_toolbar)
+
+    def connect_things(self):
+        super().connect_things()
+        # first disconnect actions from  the base class
+        self.connect_action('move_abs', None, connect=False)
+        self.connect_action('move_abs_2', None, connect=False)
+
+        #then connect to the ones reimplemented here
+        self.connect_action('move_abs', lambda: self.emit_move_abs(BinaryValue.VALUE_ONE.value))
+        self.connect_action('move_abs_2', lambda: self.emit_move_abs(BinaryValue.VALUE_TWO.value))
+
+    def emit_move_abs(self, abs_value: Union[float, int]):
+        self.command_sig.emit(ThreadCommand(UiToMainMove.MOVE_ABS, DataActuator(data=abs_value,
+                                                                                units=self._unit)))
+
+def main(init_qt=True):
+    from pymodaq_gui.utils.dock import DockArea, Dock
+    if init_qt:  # used for the test suite
+        app = QtWidgets.QApplication(sys.argv)
+
+    actuators = [f'act{ind}' for ind in range(5)]
+
+    win = QtWidgets.QMainWindow()
+    area = DockArea()
+    win.setCentralWidget(area)
+    win.resize(1000, 500)
+    win.setWindowTitle('extension_name')
+
+
+    dock = Dock('Test')
+    dock.layout.setSpacing(0)
+    dock.layout.setContentsMargins(0,0,0,0)
+    area.addDock(dock)
+    widget = QtWidgets.QWidget()
+    widget.setMaximumHeight(60)
+    prog = DAQ_Move_UI_Simple(widget, title="test")
+    widget.show()
+
+    for ind in range(10):
+        widget = QtWidgets.QWidget()
+        widget.setMaximumHeight(60)
+        dock.addWidget(widget)
+        prog = DAQ_Move_UI_Binary(widget, title="test")
+
+
+        def print_command_sig(cmd_sig):
+            print(cmd_sig)
+            if cmd_sig.command == UiToMainMove.INIT:
+                prog.enable_move_buttons(True)
+            elif cmd_sig.command == UiToMainMove.MOVE_ABS:
+                prog.display_value(cmd_sig.attribute)
+
+        prog.command_sig.connect(print_command_sig)
+        prog.actuators = actuators
+
+    win.show()
+    if init_qt:
+        sys.exit(app.exec_())
+    return prog, widget
+
+
+if __name__ == '__main__':
+    main()
+