""" ui/windows/config_window.py Unified Configuration window — Devices | Channels | Plot in one tabbed window. Channels tab layout (2 columns): Left — signal table (Device / Signal ID / Dir / On / Name / Unit / Min / Max) ⚙ button per row opens that channel's filter/calibration pipeline dialog Right — derived / virtual channels """ from __future__ import annotations from copy import deepcopy from typing import List, Optional, Set, Tuple from PyQt6.QtWidgets import ( QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QToolButton, QScrollArea, QFrame, QTabWidget, QTableWidget, QTableWidgetItem, QHeaderView, QCheckBox, QMessageBox, QAbstractItemView, QSplitter, QDoubleSpinBox, QDialog, QDialogButtonBox, ) from PyQt6.QtCore import Qt, pyqtSignal, QTimer from PyQt6.QtGui import QCloseEvent, QColor from devices.device_registry import DeviceRegistry from core.acquisition import AcquisitionEngine from core.signal_processor import SignalProcessor from ui.windows.devices_window import DeviceRow, ChannelsTab from ui.windows.channels_window import PipelineTab, ChannelPipelineBlock from ui.windows.plot_window import ( PlotWindow, LayoutConfig, LayoutCanvas, PaneBlock, build_default_layout, ) # ══════════════════════════════════════════════════════════════════════════════ # Pipeline dialog — per-channel filter/calibration popup # ══════════════════════════════════════════════════════════════════════════════ class _PipelineDialog(QDialog): """Shows one ChannelPipelineBlock inside a dialog for a single signal.""" def __init__(self, dev_id: str, ch_id: str, ch_name: str, unit: str, processor: SignalProcessor, parent=None): super().__init__(parent) self.setWindowTitle(f"Pipeline — {dev_id} / {ch_id}") self.setMinimumWidth(460) self.resize(500, 420) lay = QVBoxLayout(self) lay.setContentsMargins(0, 0, 0, 12) self._block = ChannelPipelineBlock(dev_id, ch_id, ch_name, unit, processor) self._block._toggle() # start expanded lay.addWidget(self._block, 1) btns = QDialogButtonBox(QDialogButtonBox.StandardButton.Close) btns.rejected.connect(self.accept) lay.addWidget(btns) # ══════════════════════════════════════════════════════════════════════════════ # Enhanced signals table — adds Dir badge and pipeline ⚙ button # ══════════════════════════════════════════════════════════════════════════════ class _SignalsTab(ChannelsTab): """ChannelsTab with Dir (IN/OUT) badge and per-row ⚙ pipeline button.""" _C_DEVICE = 0 _C_CH_ID = 1 _C_DIR = 2 _C_ENABLED = 3 _C_NAME = 4 _C_UNIT = 5 _C_MIN = 6 _C_MAX = 7 _C_PIPE = 8 # ⚙ pipeline button def __init__(self, registry: DeviceRegistry, processor: SignalProcessor): self._processor = processor super().__init__(registry) def _build(self): lay = QVBoxLayout(self) lay.setContentsMargins(0, 0, 0, 0) self._table = QTableWidget() self._table.setObjectName("channelTable") self._table.setColumnCount(9) self._table.setHorizontalHeaderLabels( ["Device", "Signal ID", "Dir", "On", "Name", "Unit", "Min", "Max", ""] ) hdr = self._table.horizontalHeader() hdr.setSectionResizeMode(self._C_NAME, QHeaderView.ResizeMode.Stretch) hdr.setSectionResizeMode(self._C_DEVICE, QHeaderView.ResizeMode.ResizeToContents) hdr.setSectionResizeMode(self._C_CH_ID, QHeaderView.ResizeMode.ResizeToContents) hdr.setSectionResizeMode(self._C_DIR, QHeaderView.ResizeMode.ResizeToContents) hdr.setSectionResizeMode(self._C_ENABLED, QHeaderView.ResizeMode.ResizeToContents) hdr.setSectionResizeMode(self._C_PIPE, QHeaderView.ResizeMode.ResizeToContents) self._table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows) self._table.setAlternatingRowColors(True) self._table.verticalHeader().setVisible(False) self._table.cellChanged.connect(self._on_cell_changed) lay.addWidget(self._table) def refresh(self): self._table.blockSignals(True) self._table.setRowCount(0) row = 0 for dev in self.registry.all_instances(): for ch in dev.info.channels: self._table.insertRow(row) dev_item = QTableWidgetItem(f"{dev.info.icon} {dev.info.device_id}") dev_item.setFlags(dev_item.flags() & ~Qt.ItemFlag.ItemIsEditable) dev_item.setForeground(QColor("#64748b")) self._table.setItem(row, self._C_DEVICE, dev_item) ch_item = QTableWidgetItem(ch.channel_id) ch_item.setFlags(ch_item.flags() & ~Qt.ItemFlag.ItemIsEditable) ch_item.setForeground(QColor(ch.color)) self._table.setItem(row, self._C_CH_ID, ch_item) is_out = getattr(ch, "is_output", False) dir_item = QTableWidgetItem("OUT" if is_out else "IN") dir_item.setFlags(dir_item.flags() & ~Qt.ItemFlag.ItemIsEditable) dir_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter) dir_item.setForeground(QColor("#f59e0b") if is_out else QColor("#22c55e")) self._table.setItem(row, self._C_DIR, dir_item) # Enable toggle — disabled for output channels chk_w = QWidget() chk_l = QHBoxLayout(chk_w) chk_l.setContentsMargins(0, 0, 0, 0) chk_l.setAlignment(Qt.AlignmentFlag.AlignCenter) chk = QCheckBox() chk.setChecked(True if is_out else ch.enabled) if is_out: chk.setEnabled(False) else: dev_id_cap = dev.info.device_id ch_id_cap = ch.channel_id chk.toggled.connect( lambda checked, d=dev_id_cap, c=ch_id_cap: self._on_enabled(d, c, checked) ) chk_l.addWidget(chk) self._table.setCellWidget(row, self._C_ENABLED, chk_w) name_item = QTableWidgetItem(ch.name) name_item.setData(Qt.ItemDataRole.UserRole, (dev.info.device_id, ch.channel_id)) self._table.setItem(row, self._C_NAME, name_item) self._table.setItem(row, self._C_UNIT, QTableWidgetItem(ch.unit)) self._table.setItem(row, self._C_MIN, QTableWidgetItem(str(ch.min_value))) self._table.setItem(row, self._C_MAX, QTableWidgetItem(str(ch.max_value))) # Pipeline ⚙ button pipe_w = QWidget() pipe_l = QHBoxLayout(pipe_w) pipe_l.setContentsMargins(2, 0, 2, 0) pipe_l.setAlignment(Qt.AlignmentFlag.AlignCenter) pipe_btn = QToolButton() pipe_btn.setText("⚙") pipe_btn.setObjectName("traceRemoveBtn") pipe_btn.setFixedSize(22, 22) pipe_btn.setToolTip("Configure filters / calibration") d_cap, c_cap, n_cap, u_cap = ( dev.info.device_id, ch.channel_id, ch.name, ch.unit ) pipe_btn.clicked.connect( lambda _=False, d=d_cap, c=c_cap, n=n_cap, u=u_cap: self._open_pipeline(d, c, n, u) ) pipe_l.addWidget(pipe_btn) self._table.setCellWidget(row, self._C_PIPE, pipe_w) row += 1 self._table.blockSignals(False) def _open_pipeline(self, dev_id: str, ch_id: str, ch_name: str, unit: str): dlg = _PipelineDialog(dev_id, ch_id, ch_name, unit, self._processor, self) dlg.exec() # ══════════════════════════════════════════════════════════════════════════════ # Plot tab — PlotWindow embedded without floating chrome # ══════════════════════════════════════════════════════════════════════════════ class _PlotTab(PlotWindow): def __init__(self, registry: DeviceRegistry, processor: SignalProcessor, current: Optional[LayoutConfig] = None, parent=None): QWidget.__init__(self, parent) self.registry = registry self.processor = processor self.cfg = deepcopy(current) if current else build_default_layout(registry, processor) self._blocks: List[PaneBlock] = [] self._build() self._populate() def _build(self): root = QVBoxLayout(self); root.setContentsMargins(0, 0, 0, 0); root.setSpacing(0) glob = QWidget(); glob.setObjectName("cfgGlobalBar") gl = QHBoxLayout(glob); gl.setContentsMargins(12, 7, 12, 7); gl.setSpacing(12) gl.addWidget(QLabel("Window:")) self._win = QDoubleSpinBox(); self._win.setRange(1, 3600) self._win.setSuffix(" s"); self._win.setValue(self.cfg.time_window_s) self._win.setObjectName("cfgGlobalSpin") self._win.valueChanged.connect(lambda v: setattr(self.cfg, "time_window_s", v)) gl.addWidget(self._win) self._linkx = QCheckBox("Link X"); self._linkx.setChecked(self.cfg.link_x) self._linkx.setObjectName("cfgLiveChk") self._linkx.toggled.connect(lambda v: setattr(self.cfg, "link_x", v)) gl.addWidget(self._linkx) self._legend = QCheckBox("Legend"); self._legend.setChecked(self.cfg.show_legend) self._legend.setObjectName("cfgLiveChk") self._legend.toggled.connect(lambda v: setattr(self.cfg, "show_legend", v)) gl.addWidget(self._legend) self._live = QCheckBox("Live preview"); self._live.setObjectName("cfgLiveChk") gl.addWidget(self._live) gl.addStretch() add_btn = QPushButton("＋ Add Pane"); add_btn.setObjectName("addDeviceButton") add_btn.clicked.connect(self._add_pane); gl.addWidget(add_btn) root.addWidget(glob) canvas_bar = QWidget(); canvas_bar.setObjectName("layoutCanvasBar") cb_lay = QVBoxLayout(canvas_bar) cb_lay.setContentsMargins(10, 6, 10, 8); cb_lay.setSpacing(4) clbl = QLabel( "LAYOUT — edge: split (blue) | " "edge gap: insert between (amber) | center: move (green)" ) clbl.setObjectName("layoutCanvasLabel") cb_lay.addWidget(clbl) self._canvas = LayoutCanvas(self.cfg.panes, self.cfg.tree, self) self._canvas._cfg_ref = self.cfg self._canvas.arrangement_changed.connect(self._maybe_live) cb_lay.addWidget(self._canvas) root.addWidget(canvas_bar) div = QFrame(); div.setFrameShape(QFrame.Shape.HLine) div.setObjectName("devWindowDivider"); root.addWidget(div) scroll = QScrollArea(); scroll.setWidgetResizable(True) scroll.setObjectName("deviceScroll") self._cont = QWidget() self._blay = QVBoxLayout(self._cont) self._blay.setContentsMargins(10, 10, 10, 10); self._blay.setSpacing(12) self._blay.addStretch() scroll.setWidget(self._cont) root.addWidget(scroll, 1) btm = QWidget(); btm.setObjectName("cfgBottomBar") bl = QHBoxLayout(btm); bl.setContentsMargins(12, 8, 12, 8) for lbl, fn in [("⟳ Rebuild from Channels", self._reset), ("↓ Export JSON", self._export), ("↑ Import JSON", self._import_json)]: b = QPushButton(lbl); b.setObjectName("configButton") b.clicked.connect(fn); bl.addWidget(b) bl.addStretch() ap = QPushButton("✓ Apply"); ap.setObjectName("applyButton") ap.clicked.connect(self._apply); bl.addWidget(ap) root.addWidget(btm) # ══════════════════════════════════════════════════════════════════════════════ # ConfigWindow # ══════════════════════════════════════════════════════════════════════════════ class ConfigWindow(QWidget): device_added = pyqtSignal() device_removed = pyqtSignal(str) device_reconfigured = pyqtSignal(str) channel_visibility_changed = pyqtSignal(str, str, bool) channel_name_changed = pyqtSignal(str, str, str) channel_unit_changed = pyqtSignal(str, str, str) pipeline_changed = pyqtSignal() derived_changed = pyqtSignal() layout_applied = pyqtSignal(object) closed = pyqtSignal() def __init__(self, registry: DeviceRegistry, engine: AcquisitionEngine, processor: SignalProcessor, current_layout: Optional[LayoutConfig] = None, parent=None): super().__init__(parent, Qt.WindowType.Window) self.registry = registry self.engine = engine self.processor = processor self._dev_rows: dict = {} self.setWindowTitle("Configuration") self.setMinimumSize(900, 580) self.resize(1200, 760) self._build(current_layout) # ── Build ──────────────────────────────────────────────────────────────── def _build(self, current_layout: Optional[LayoutConfig]): root = QVBoxLayout(self); root.setContentsMargins(0, 0, 0, 0); root.setSpacing(0) self.tabs = QTabWidget() self.tabs.setObjectName("signalBuilderTabs") root.addWidget(self.tabs, 1) self._build_devices_tab() self._build_channels_tab() self._build_plot_tab(current_layout) self.tabs.currentChanged.connect(self._on_tab_changed) # ── Tab 0: Devices ─────────────────────────────────────────────────────── def _build_devices_tab(self): w = QWidget() lay = QVBoxLayout(w); lay.setContentsMargins(0, 0, 0, 0); lay.setSpacing(0) bar = QWidget(); bar.setObjectName("cfgGlobalBar") bl = QHBoxLayout(bar); bl.setContentsMargins(10, 7, 10, 7); bl.setSpacing(6) lbl = QLabel("Physical Devices"); lbl.setObjectName("devWindowTitle") bl.addWidget(lbl, 1) add_btn = QPushButton("＋ Add Device"); add_btn.setObjectName("addDeviceButton") add_btn.clicked.connect(self._on_add_device) bl.addWidget(add_btn) lay.addWidget(bar) div = QFrame(); div.setFrameShape(QFrame.Shape.HLine) div.setObjectName("devWindowDivider"); lay.addWidget(div) scroll = QScrollArea(); scroll.setWidgetResizable(True) scroll.setObjectName("deviceScroll") scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff) self._dev_container = QWidget() self._dev_inner = QVBoxLayout(self._dev_container) self._dev_inner.setContentsMargins(10, 10, 10, 10); self._dev_inner.setSpacing(6) self._dev_inner.addStretch() scroll.setWidget(self._dev_container) lay.addWidget(scroll, 1) self.tabs.addTab(w, " Devices ") self._dev_poll = QTimer(self) self._dev_poll.setInterval(2000) self._dev_poll.timeout.connect(self._refresh_device_status) self._dev_poll.start() self.refresh_devices() def refresh_devices(self): for row in self._dev_rows.values(): self._dev_inner.removeWidget(row); row.deleteLater() self._dev_rows.clear() for dev in self.registry.all_instances(): row = DeviceRow(dev) row.configure_clicked.connect(self._on_configure_device) row.remove_clicked.connect(self._on_remove_device) self._dev_inner.insertWidget(self._dev_inner.count() - 1, row) self._dev_rows[dev.info.device_id] = row def _refresh_device_status(self): for row in self._dev_rows.values(): row.refresh() def _on_add_device(self): from ui.add_device_dialog import AddDeviceDialog dlg = AddDeviceDialog(self.registry, self) if dlg.exec(): dev = dlg.created_device if dev: dev.connect() self.registry.add_instance(dev) self.engine.add_device(dev) self.refresh_devices() self._signals_tab.refresh() self.device_added.emit() def _on_configure_device(self, device_id: str): from ui.config_dialog import DeviceConfigDialog dev = self.registry.get_instance(device_id) if dev: DeviceConfigDialog(dev, self).exec() self._signals_tab.refresh() self.device_reconfigured.emit(device_id) def _on_remove_device(self, device_id: str): reply = QMessageBox.question( self, "Remove Device", f"Remove '{device_id}'? This cannot be undone.", QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, ) if reply == QMessageBox.StandardButton.Yes: self.engine.remove_device(device_id) self.registry.remove_instance(device_id) self.refresh_devices() self._signals_tab.refresh() self._pipeline_tab.on_device_removed(device_id) self.device_removed.emit(device_id) # ── Tab 1: Channels ────────────────────────────────────────────────────── # Left — signal table (metadata + enable + ⚙ pipeline button per row) # Right — derived / virtual channels (PipelineTab with physical side hidden) def _build_channels_tab(self): w = QWidget() lay = QVBoxLayout(w); lay.setContentsMargins(0, 0, 0, 0); lay.setSpacing(0) splitter = QSplitter(Qt.Orientation.Horizontal) splitter.setObjectName("channelSplitter") lay.addWidget(splitter, 1) # Left: signals table sig_w = QWidget() sig_l = QVBoxLayout(sig_w); sig_l.setContentsMargins(0, 0, 0, 0); sig_l.setSpacing(0) sig_bar = QWidget(); sig_bar.setObjectName("cfgGlobalBar") sb_lay = QHBoxLayout(sig_bar); sb_lay.setContentsMargins(10, 7, 10, 7) sb_lbl = QLabel("Signals"); sb_lbl.setObjectName("devWindowTitle") sb_lay.addWidget(sb_lbl, 1) sig_l.addWidget(sig_bar) sig_div = QFrame(); sig_div.setFrameShape(QFrame.Shape.HLine) sig_div.setObjectName("devWindowDivider"); sig_l.addWidget(sig_div) self._signals_tab = _SignalsTab(self.registry, self.processor) self._signals_tab.channel_visibility_changed.connect(self._on_sig_visibility) self._signals_tab.channel_name_changed.connect(self._on_sig_name) self._signals_tab.channel_unit_changed.connect(self._on_sig_unit) sig_l.addWidget(self._signals_tab, 1) splitter.addWidget(sig_w) # Right: derived channels only self._pipeline_tab = PipelineTab(self.registry, self.processor) self._pipeline_tab.changed.connect(self.pipeline_changed) self._pipeline_tab.derived_changed.connect(self.derived_changed) inner_splitters = self._pipeline_tab.findChildren(QSplitter) if inner_splitters: inner_splitters[0].widget(0).setVisible(False) splitter.addWidget(self._pipeline_tab) splitter.setStretchFactor(0, 2) splitter.setStretchFactor(1, 1) self.tabs.addTab(w, " Channels ") def _on_sig_visibility(self, dev_id: str, ch_id: str, enabled: bool): self._pipeline_tab.on_channel_enabled_changed(dev_id, ch_id, enabled) self.channel_visibility_changed.emit(dev_id, ch_id, enabled) def _on_sig_name(self, dev_id: str, ch_id: str, name: str): self._pipeline_tab.on_channel_name_changed(dev_id, ch_id, name) self.channel_name_changed.emit(dev_id, ch_id, name) def _on_sig_unit(self, dev_id: str, ch_id: str, unit: str): self._pipeline_tab.on_channel_unit_changed(dev_id, ch_id, unit) self.channel_unit_changed.emit(dev_id, ch_id, unit) def on_device_added(self): self._signals_tab.refresh() self._pipeline_tab.on_device_added() def on_device_removed(self, dev_id: str): self._pipeline_tab.on_device_removed(dev_id) def on_device_reconfigured(self, dev_id: str): self._signals_tab.refresh() self._pipeline_tab.on_device_reconfigured(dev_id) def on_channel_enabled_changed(self, dev_id: str, ch_id: str, enabled: bool): self._pipeline_tab.on_channel_enabled_changed(dev_id, ch_id, enabled) def on_channel_name_changed(self, dev_id: str, ch_id: str, name: str): self._pipeline_tab.on_channel_name_changed(dev_id, ch_id, name) def on_channel_unit_changed(self, dev_id: str, ch_id: str, unit: str): self._pipeline_tab.on_channel_unit_changed(dev_id, ch_id, unit) def refresh_derived(self): self._pipeline_tab.refresh_derived() # ── Tab 2: Plot ────────────────────────────────────────────────────────── def _build_plot_tab(self, current_layout: Optional[LayoutConfig]): self._plot_tab = _PlotTab(self.registry, self.processor, current_layout, self) self._plot_tab.layout_applied.connect(self.layout_applied) self.tabs.addTab(self._plot_tab, " Plot ") def refresh_plot(self, cfg: Optional[LayoutConfig] = None): if cfg is not None: self._plot_tab.cfg = cfg self._plot_tab.refresh_channels() # ── Tab switch ─────────────────────────────────────────────────────────── def _on_tab_changed(self, idx: int): if idx == 1: self._signals_tab.refresh() elif idx == 2: self._plot_tab.refresh_channels() # ── Close ──────────────────────────────────────────────────────────────── def closeEvent(self, e: QCloseEvent): self._dev_poll.stop() self.closed.emit() e.accept()