moninj: decouple DAC logic and display

artiq/dashboard/moninj.py

@@ -26,13 +26,11 @@ class _CancellableLineEdit(QtWidgets.QLineEdit):
 
 
 class _TTLWidget(QtWidgets.QFrame):
-    def __init__(self, dm, channel, force_out, title):
+    override_toggled = QtCore.pyqtSignal(bool)
+    level_toggled = QtCore.pyqtSignal(bool)
+
+    def __init__(self, title):
         QtWidgets.QFrame.__init__(self)
-
-        self.channel = channel
-        self.set_mode = dm.ttl_set_mode
-        self.force_out = force_out
-
         self.setFrameShape(QtWidgets.QFrame.Box)
         self.setFrameShadow(QtWidgets.QFrame.Raised)
 
@@ -79,15 +77,28 @@ class _TTLWidget(QtWidgets.QFrame):
         grid.setRowStretch(3, 0)
         grid.setRowStretch(4, 1)
 
-        self.programmatic_change = False
         self.override.clicked.connect(self.override_toggled)
         self.level.clicked.connect(self.level_toggled)
 
-        self.cur_level = False
+    def setValueText(self, override, level):
-        self.cur_oe = False
+        value_s = "1" if level else "0"
-        self.cur_override = False
+        if override:
-        self.cur_override_level = False
+            value_s = "<b>" + value_s + "</b>"
-        self.refresh_display()
+            color = " color=\"red\""
+        else:
+            color = ""
+        self.value.setText("<font size=\"5\"{}>{}</font>".format(
+                           color, value_s))
+
+    def setDirectionText(self, oe):
+        direction = "OUT" if oe else "IN"
+        self.direction.setText("<font size=\"2\">" + direction + "</font>")
+
+    def setButtonsState(self, override, level):
+        self.override.setChecked(override)
+        if override:
+            self.stack.setCurrentIndex(1)
+            self.level.setChecked(level)
 
     def enterEvent(self, event):
         self.stack.setCurrentIndex(1)
@@ -98,11 +109,24 @@ class _TTLWidget(QtWidgets.QFrame):
             self.stack.setCurrentIndex(0)
         QtWidgets.QFrame.leaveEvent(self, event)
 
+
+class _TTLHandler:
+    def __init__(self, dm, channel, force_out, title):
+        self.channel = channel
+        self.force_out = force_out
+        self.set_mode = dm.ttl_set_mode
+        self.cur_level = False
+        self.cur_oe = False
+        self.cur_override = False
+        self.cur_override_level = False
+        self.widget = _TTLWidget(title)
+        self.widget.override_toggled.connect(self.override_toggled)
+        self.widget.level_toggled.connect(self.level_toggled)
+        self.refresh_display()
+
     def override_toggled(self, override):
-        if self.programmatic_change:
-            return
         if override:
-            if self.level.isChecked():
+            if self.widget.level.isChecked():
                 self.set_mode(self.channel, "1")
             else:
                 self.set_mode(self.channel, "0")
@@ -110,9 +134,7 @@ class _TTLWidget(QtWidgets.QFrame):
             self.set_mode(self.channel, "exp")
 
     def level_toggled(self, level):
-        if self.programmatic_change:
+        if self.widget.override.isChecked():
-            return
-        if self.override.isChecked():
             if level:
                 self.set_mode(self.channel, "1")
             else:
@@ -120,65 +142,16 @@ class _TTLWidget(QtWidgets.QFrame):
 
     def refresh_display(self):
         level = self.cur_override_level if self.cur_override else self.cur_level
-        value_s = "1" if level else "0"
-
-        if self.cur_override:
-            value_s = "<b>" + value_s + "</b>"
-            color = " color=\"red\""
-        else:
-            color = ""
-        self.value.setText("<font size=\"5\"{}>{}</font>".format(
-                           color, value_s))
         oe = self.cur_oe or self.force_out
-        direction = "OUT" if oe else "IN"
+        self.widget.setValueText(self.cur_override, level)
-        self.direction.setText("<font size=\"2\">" + direction + "</font>")
+        self.widget.setDirectionText(oe)
-
+        with QtCore.QSignalBlocker(self.widget):
-        self.programmatic_change = True
+            self.widget.setButtonsState(self.cur_override, self.cur_level)
-        try:
-            self.override.setChecked(self.cur_override)
-            if self.cur_override:
-                self.stack.setCurrentIndex(1)
-                self.level.setChecked(self.cur_level)
-        finally:
-            self.programmatic_change = False
 
     def sort_key(self):
         return self.channel
 
 
-class _SimpleDisplayWidget(QtWidgets.QFrame):
-    def __init__(self, title):
-        QtWidgets.QFrame.__init__(self)
-
-        self.setFrameShape(QtWidgets.QFrame.Box)
-        self.setFrameShadow(QtWidgets.QFrame.Raised)
-
-        grid = QtWidgets.QGridLayout()
-        grid.setContentsMargins(0, 0, 0, 0)
-        grid.setHorizontalSpacing(0)
-        grid.setVerticalSpacing(0)
-        self.setLayout(grid)
-        label = QtWidgets.QLabel(title)
-        label.setAlignment(QtCore.Qt.AlignCenter)
-        grid.addWidget(label, 1, 1)
-
-        self.value = QtWidgets.QLabel()
-        self.value.setAlignment(QtCore.Qt.AlignCenter)
-        grid.addWidget(self.value, 2, 1, 6, 1)
-
-        grid.setRowStretch(1, 1)
-        grid.setRowStretch(2, 0)
-        grid.setRowStretch(3, 1)
-
-        self.refresh_display()
-
-    def refresh_display(self):
-        raise NotImplementedError
-
-    def sort_key(self):
-        raise NotImplementedError
-
-
 class _DDSModel:
     def __init__(self, dds_type, ref_clk, cpld=None, pll=1, clk_div=0):
         self.cpld = cpld
@@ -211,14 +184,11 @@ class _DDSModel:
 
 
 class _DDSWidget(QtWidgets.QFrame):
-    def __init__(self, dm, title, bus_channel=0, channel=0, dds_model=None):
+    apply_changes = QtCore.pyqtSignal()
-        self.dm = dm
+    off_clicked = QtCore.pyqtSignal()
-        self.bus_channel = bus_channel
+    set_clicked = QtCore.pyqtSignal()
-        self.channel = channel
-        self.dds_name = title
-        self.cur_frequency = 0
-        self.dds_model = dds_model
 
+    def __init__(self, title, is_urukul):
         QtWidgets.QFrame.__init__(self)
 
         self.setFrameShape(QtWidgets.QFrame.Box)
@@ -280,7 +250,7 @@ class _DDSWidget(QtWidgets.QFrame):
         set_grid.addWidget(set_btn, 0, 1, 1, 1)
 
         # for urukuls also allow switching off RF
-        if self.dds_model.is_urukul:
+        if is_urukul:
             off_btn = QtWidgets.QToolButton()
             off_btn.setText("Off")
             off_btn.setToolTip("Switch off the output")
@@ -307,63 +277,118 @@ class _DDSWidget(QtWidgets.QFrame):
 
         set_btn.clicked.connect(self.set_clicked)
         apply.clicked.connect(self.apply_changes)
-        if self.dds_model.is_urukul:
+        if is_urukul:
             off_btn.clicked.connect(self.off_clicked)
             off_btn.setToolTip(textwrap.dedent(
                 """Note: If TTL RTIO sw for the channel is switched high,
                 this button will not disable the channel.
                 Use the TTL override instead."""))
-        self.value_edit.returnPressed.connect(lambda: self.apply_changes(None))
+        self.value_edit.returnPressed.connect(self.apply_changes)
-        self.value_edit.escapePressedConnect(self.cancel_changes)
-        cancel.clicked.connect(self.cancel_changes)
 
-        self.refresh_display()
+        def cancel_changes(cancel):
+            self.set_page(0)
+        self.value_edit.escapePressedConnect(cancel_changes)
+        cancel.clicked.connect(cancel_changes)
 
-    def set_clicked(self, set):
+    def set_page(self, page):
-        self.data_stack.setCurrentIndex(1)
+        self.data_stack.setCurrentIndex(page)
-        self.button_stack.setCurrentIndex(1)
+        self.button_stack.setCurrentIndex(page)
-        self.value_edit.setText("{:.7f}".format(self.cur_frequency / 1e6))
+
+    def get_value(self):
+        return float(self.value_edit.text())
+
+    def set_edit_value(self, value):
+        self.value_edit.setText("{:.7f}".format(value))
+
+    def set_value(self, value):
+        self.value_label.setText("<font size=\"4\">{:.7f}</font>".format(value))
+        self.set_edit_value(value)
+
+    def start_edit(self):
         self.value_edit.setFocus()
         self.value_edit.selectAll()
 
-    def off_clicked(self, set):
-        self.dm.dds_channel_toggle(self.dds_name, self.dds_model, sw=False)
 
-    def apply_changes(self, apply):
+class _DDSHandler:
-        self.data_stack.setCurrentIndex(0)
+    def __init__(self, dm, title, bus_channel=0, channel=0, dds_model=None):
-        self.button_stack.setCurrentIndex(0)
+        self.dm = dm
-        frequency = float(self.value_edit.text()) * 1e6
+        self.bus_channel = bus_channel
-        self.dm.dds_set_frequency(self.dds_name, self.dds_model, frequency)
+        self.channel = channel
-
+        self.cur_frequency = 0
-    def cancel_changes(self, cancel):
+        self.dds_name = title
-        self.data_stack.setCurrentIndex(0)
+        self.dds_model = dds_model
-        self.button_stack.setCurrentIndex(0)
+        self.widget = _DDSWidget(title, dds_model.is_urukul)
+        self.widget.apply_changes.connect(self.apply_changes)
+        self.widget.off_clicked.connect(self.off_clicked)
+        self.widget.set_clicked.connect(self.set_clicked)
+        self.refresh_display()
 
     def refresh_display(self):
         self.cur_frequency = self.dds_model.cur_frequency
-        self.value_label.setText("<font size=\"4\">{:.7f}</font>".format(self.cur_frequency / 1e6))
+        self.widget.set_value(self.cur_frequency / 1e6)
-        self.value_edit.setText("{:.7f}".format(self.cur_frequency / 1e6))
+
+    def apply_changes(self):
+        self.widget.set_page(0)
+        frequency = self.widget.get_value() * 1e6
+        self.dm.dds_set_frequency(self.dds_name, self.dds_model, frequency)
+
+    def set_clicked(self):
+        self.widget.set_page(1)
+        self.widget.set_edit_value(self.cur_frequency / 1e6)
+        self.widget.start_edit()
+
+    def off_clicked(self):
+        self.dm.dds_channel_toggle(self.dds_name, self.dds_model, sw=False)
 
     def sort_key(self):
         return (self.bus_channel, self.channel)
 
 
-class _DACWidget(_SimpleDisplayWidget):
+class _DACWidget(QtWidgets.QFrame):
+    def __init__(self, channel, title):
+        QtWidgets.QFrame.__init__(self)
+
+        self.setFrameShape(QtWidgets.QFrame.Box)
+        self.setFrameShadow(QtWidgets.QFrame.Raised)
+
+        grid = QtWidgets.QGridLayout()
+        grid.setContentsMargins(0, 0, 0, 0)
+        grid.setHorizontalSpacing(0)
+        grid.setVerticalSpacing(0)
+        self.setLayout(grid)
+        label = QtWidgets.QLabel("{} ch{}".format(title, channel))
+        label.setAlignment(QtCore.Qt.AlignCenter)
+        grid.addWidget(label, 1, 1)
+
+        self.value = QtWidgets.QLabel()
+        self.value.setAlignment(QtCore.Qt.AlignCenter)
+        grid.addWidget(self.value, 2, 1, 6, 1)
+
+        grid.setRowStretch(1, 1)
+        grid.setRowStretch(2, 0)
+        grid.setRowStretch(3, 1)
+
+    def set_value(self, value):
+        self.value.setText("<font size=\"4\">{:.3f}</font><font size=\"2\"> %</font>"
+                           .format(value))
+
+
+class _DACHandler:
     def __init__(self, dm, spi_channel, channel, title):
+        self.widget = _DACWidget(channel, title)
+        self.cur_value = 0
         self.spi_channel = spi_channel
         self.channel = channel
-        self.cur_value = 0
+        self.refresh_display()
-        _SimpleDisplayWidget.__init__(self, "{} ch{}".format(title, channel))
 
     def refresh_display(self):
-        self.value.setText("<font size=\"4\">{:.3f}</font><font size=\"2\"> %</font>"
+        self.widget.set_value(self.cur_value * 100 / 2**16)
-                           .format(self.cur_value * 100 / 2**16))
 
     def sort_key(self):
         return (self.spi_channel, self.channel)
 
 
-_WidgetDesc = namedtuple("_WidgetDesc", "uid comment cls arguments")
+_HandlerDesc = namedtuple("_HandlerDesc", "uid comment cls arguments")
 
 
 def setup_from_ddb(ddb):
@@ -382,16 +407,16 @@ def setup_from_ddb(ddb):
                             continue
                         channel = v["arguments"]["channel"]
                         force_out = v["class"] == "TTLOut"
-                        widget = _WidgetDesc(k, comment, _TTLWidget, (channel, force_out, k))
+                        handler = _HandlerDesc(k, comment, _TTLHandler, (channel, force_out, k))
-                        description.add(widget)
+                        description.add(handler)
                     elif (v["module"] == "artiq.coredevice.ad9914" and v["class"] == "AD9914"):
                         bus_channel = v["arguments"]["bus_channel"]
                         channel = v["arguments"]["channel"]
                         dds_sysclk = v["arguments"]["sysclk"]
                         model = _DDSModel(v["class"], dds_sysclk)
-                        widget = _WidgetDesc(k, comment, _DDSWidget,
+                        handler = _HandlerDesc(k, comment, _DDSHandler,
-                                             (k, bus_channel, channel, model))
+                                               (k, bus_channel, channel, model))
-                        description.add(widget)
+                        description.add(handler)
                     elif (v["module"] == "artiq.coredevice.ad9910" and v["class"] == "AD9910") or \
                          (v["module"] == "artiq.coredevice.ad9912" and v["class"] == "AD9912"):
                         channel = v["arguments"]["chip_select"] - 4
@@ -404,9 +429,9 @@ def setup_from_ddb(ddb):
                         refclk = ddb[dds_cpld]["arguments"]["refclk"]
                         clk_div = v["arguments"].get("clk_div", 0)
                         model = _DDSModel(v["class"], refclk, dds_cpld, pll, clk_div)
-                        widget = _WidgetDesc(k, comment, _DDSWidget,
+                        handler = _HandlerDesc(k, comment, _DDSHandler,
-                                             (k, bus_channel, channel, model))
+                                               (k, bus_channel, channel, model))
-                        description.add(widget)
+                        description.add(handler)
                     elif (v["module"] == "artiq.coredevice.ad53xx" and v["class"] == "AD53xx") or \
                          (v["module"] == "artiq.coredevice.zotino" and v["class"] == "Zotino"):
                         spi_device = v["arguments"]["spi_device"]
@@ -415,9 +440,9 @@ def setup_from_ddb(ddb):
                             spi_device = ddb[spi_device]
                         spi_channel = spi_device["arguments"]["channel"]
                         for channel in range(32):
-                            widget = _WidgetDesc((k, channel), comment, _DACWidget,
+                            handler = _HandlerDesc((k, channel), comment, _DACHandler,
-                                                 (spi_channel, channel, k))
+                                                   (spi_channel, channel, k))
-                            description.add(widget)
+                            description.add(handler)
                 elif v["type"] == "controller" and k == "core_moninj":
                     mi_addr = v["host"]
                     mi_port = v.get("port_proxy", 1383)
@@ -438,15 +463,15 @@ class _DeviceManager:
 
         self.ddb = dict()
         self.description = set()
-        self.widgets_by_uid = dict()
+        self.handlers_by_uid = dict()
 
         self.dds_sysclk = 0
         self.ttl_cb = lambda: None
-        self.ttl_widgets = dict()
+        self.ttl_handlers = dict()
         self.dds_cb = lambda: None
-        self.dds_widgets = dict()
+        self.dds_handlers = dict()
         self.dac_cb = lambda: None
-        self.dac_widgets = dict()
+        self.dac_handlers = dict()
 
     def init_ddb(self, ddb):
         self.ddb = ddb
@@ -460,45 +485,45 @@ class _DeviceManager:
             self.reconnect_mi.set()
 
         for to_remove in self.description - description:
-            widget = self.widgets_by_uid[to_remove.uid]
+            handler = self.handlers_by_uid[to_remove.uid]
-            del self.widgets_by_uid[to_remove.uid]
+            del self.handlers_by_uid[to_remove.uid]
 
-            if isinstance(widget, _TTLWidget):
+            if isinstance(handler, _TTLHandler):
-                self.setup_ttl_monitoring(False, widget.channel)
+                self.setup_ttl_monitoring(False, handler.channel)
-                widget.deleteLater()
+                handler.widget.deleteLater()
-                del self.ttl_widgets[widget.channel]
+                del self.ttl_handlers[handler.channel]
                 self.ttl_cb()
-            elif isinstance(widget, _DDSWidget):
+            elif isinstance(handler, _DDSHandler):
-                self.setup_dds_monitoring(False, widget.bus_channel, widget.channel)
+                self.setup_dds_monitoring(False, handler.bus_channel, handler.channel)
-                widget.deleteLater()
+                handler.widget.deleteLater()
-                del self.dds_widgets[(widget.bus_channel, widget.channel)]
+                del self.dds_handlers[(handler.bus_channel, handler.channel)]
                 self.dds_cb()
-            elif isinstance(widget, _DACWidget):
+            elif isinstance(handler, _DACHandler):
-                self.setup_dac_monitoring(False, widget.spi_channel, widget.channel)
+                self.setup_dac_monitoring(False, handler.spi_channel, handler.channel)
-                widget.deleteLater()
+                handler.widget.deleteLater()
-                del self.dac_widgets[(widget.spi_channel, widget.channel)]
+                del self.dac_handlers[(handler.spi_channel, handler.channel)]
                 self.dac_cb()
             else:
                 raise ValueError
 
         for to_add in description - self.description:
-            widget = to_add.cls(self, *to_add.arguments)
+            handler = to_add.cls(self, *to_add.arguments)
             if to_add.comment is not None:
-                widget.setToolTip(to_add.comment)
+                handler.widget.setToolTip(to_add.comment)
-            self.widgets_by_uid[to_add.uid] = widget
+            self.handlers_by_uid[to_add.uid] = handler
 
-            if isinstance(widget, _TTLWidget):
+            if isinstance(handler, _TTLHandler):
-                self.ttl_widgets[widget.channel] = widget
+                self.ttl_handlers[handler.channel] = handler
                 self.ttl_cb()
-                self.setup_ttl_monitoring(True, widget.channel)
+                self.setup_ttl_monitoring(True, handler.channel)
-            elif isinstance(widget, _DDSWidget):
+            elif isinstance(handler, _DDSHandler):
-                self.dds_widgets[(widget.bus_channel, widget.channel)] = widget
+                self.dds_handlers[(handler.bus_channel, handler.channel)] = handler
                 self.dds_cb()
-                self.setup_dds_monitoring(True, widget.bus_channel, widget.channel)
+                self.setup_dds_monitoring(True, handler.bus_channel, handler.channel)
-            elif isinstance(widget, _DACWidget):
+            elif isinstance(handler, _DACHandler):
-                self.dac_widgets[(widget.spi_channel, widget.channel)] = widget
+                self.dac_handlers[(handler.spi_channel, handler.channel)] = handler
                 self.dac_cb()
-                self.setup_dac_monitoring(True, widget.spi_channel, widget.channel)
+                self.setup_dac_monitoring(True, handler.spi_channel, handler.channel)
             else:
                 raise ValueError
 
@@ -506,26 +531,26 @@ class _DeviceManager:
 
     def ttl_set_mode(self, channel, mode):
         if self.mi_connection is not None:
-            widget = self.ttl_widgets[channel]
+            handler = self.ttl_handlers[channel]
             if mode == "0":
-                widget.cur_override = True
+                handler.cur_override = True
-                widget.cur_level = False
+                handler.cur_level = False
                 self.mi_connection.inject(channel, TTLOverride.level.value, 0)
                 self.mi_connection.inject(channel, TTLOverride.oe.value, 1)
                 self.mi_connection.inject(channel, TTLOverride.en.value, 1)
             elif mode == "1":
-                widget.cur_override = True
+                handler.cur_override = True
-                widget.cur_level = True
+                handler.cur_level = True
                 self.mi_connection.inject(channel, TTLOverride.level.value, 1)
                 self.mi_connection.inject(channel, TTLOverride.oe.value, 1)
                 self.mi_connection.inject(channel, TTLOverride.en.value, 1)
             elif mode == "exp":
-                widget.cur_override = False
+                handler.cur_override = False
                 self.mi_connection.inject(channel, TTLOverride.en.value, 0)
             else:
                 raise ValueError
             # override state may have changed
-            widget.refresh_display()
+            handler.refresh_display()
 
     async def _submit_by_content(self, content, class_name, title):
         expid = {
@@ -673,30 +698,30 @@ class _DeviceManager:
             self.mi_connection.monitor_probe(enable, spi_channel, channel)
 
     def monitor_cb(self, channel, probe, value):
-        if channel in self.ttl_widgets:
+        if channel in self.ttl_handlers:
-            widget = self.ttl_widgets[channel]
+            handler = self.ttl_handlers[channel]
             if probe == TTLProbe.level.value:
-                widget.cur_level = bool(value)
+                handler.cur_level = bool(value)
             elif probe == TTLProbe.oe.value:
-                widget.cur_oe = bool(value)
+                handler.cur_oe = bool(value)
-            widget.refresh_display()
+            handler.refresh_display()
-        elif (channel, probe) in self.dds_widgets:
+        elif (channel, probe) in self.dds_handlers:
-            widget = self.dds_widgets[(channel, probe)]
+            handler = self.dds_handlers[(channel, probe)]
-            widget.dds_model.monitor_update(probe, value)
+            handler.dds_model.monitor_update(probe, value)
-            widget.refresh_display()
+            handler.refresh_display()
-        elif (channel, probe) in self.dac_widgets:
+        elif (channel, probe) in self.dac_handlers:
-            widget = self.dac_widgets[(channel, probe)]
+            handler = self.dac_handlers[(channel, probe)]
-            widget.cur_value = value
+            handler.cur_value = value
-            widget.refresh_display()
+            handler.refresh_display()
 
     def injection_status_cb(self, channel, override, value):
-        if channel in self.ttl_widgets:
+        if channel in self.ttl_handlers:
-            widget = self.ttl_widgets[channel]
+            handler = self.ttl_handlers[channel]
             if override == TTLOverride.en.value:
-                widget.cur_override = bool(value)
+                handler.cur_override = bool(value)
             if override == TTLOverride.level.value:
-                widget.cur_override_level = bool(value)
+                handler.cur_override_level = bool(value)
-            widget.refresh_display()
+            handler.refresh_display()
 
     def disconnect_cb(self):
         logger.error("lost connection to moninj")
@@ -722,11 +747,11 @@ class _DeviceManager:
                 logger.info("ARTIQ dashboard connected to moninj (%s)",
                             self.mi_addr)
                 self.mi_connection = new_mi_connection
-                for ttl_channel in self.ttl_widgets.keys():
+                for ttl_channel in self.ttl_handlers.keys():
                     self.setup_ttl_monitoring(True, ttl_channel)
-                for bus_channel, channel in self.dds_widgets.keys():
+                for bus_channel, channel in self.dds_handlers.keys():
                     self.setup_dds_monitoring(True, bus_channel, channel)
-                for spi_channel, channel in self.dac_widgets.keys():
+                for spi_channel, channel in self.dac_handlers.keys():
                     self.setup_dac_monitoring(True, spi_channel, channel)
 
     async def close(self):
@@ -746,7 +771,7 @@ class _MonInjDock(QtWidgets.QDockWidget):
         self.setFeatures(QtWidgets.QDockWidget.DockWidgetMovable |
                          QtWidgets.QDockWidget.DockWidgetFloatable)
 
-    def layout_widgets(self, widgets):
+    def layout_widgets(self, handlers):
         scroll_area = QtWidgets.QScrollArea()
         self.setWidget(scroll_area)
 
@@ -754,8 +779,8 @@ class _MonInjDock(QtWidgets.QDockWidget):
         grid_widget = QtWidgets.QWidget()
         grid_widget.setLayout(grid)
 
-        for widget in sorted(widgets, key=lambda w: w.sort_key()):
+        for handler in sorted(handlers, key=lambda h: h.sort_key()):
-            grid.addWidget(widget)
+            grid.addWidget(handler.widget)
 
         scroll_area.setWidgetResizable(True)
         scroll_area.setWidget(grid_widget)
@@ -768,9 +793,9 @@ class MonInj:
         self.dac_dock = _MonInjDock("DAC")
 
         self.dm = _DeviceManager(schedule_ctl)
-        self.dm.ttl_cb = lambda: self.ttl_dock.layout_widgets(self.dm.ttl_widgets.values())
+        self.dm.ttl_cb = lambda: self.ttl_dock.layout_widgets(self.dm.ttl_handlers.values())
-        self.dm.dds_cb = lambda: self.dds_dock.layout_widgets(self.dm.dds_widgets.values())
+        self.dm.dds_cb = lambda: self.dds_dock.layout_widgets(self.dm.dds_handlers.values())
-        self.dm.dac_cb = lambda: self.dac_dock.layout_widgets(self.dm.dac_widgets.values())
+        self.dm.dac_cb = lambda: self.dac_dock.layout_widgets(self.dm.dac_handlers.values())
 
     async def stop(self):
         if self.dm is not None: