path: root/ui/windows/plot_window.py

"""
ui/windows/plot_window.py

PLOT window — toolbar section 4.

Lets operators:
  • Arrange subplot panes by dragging tiles on the layout canvas (tiling WM style)
  • Add/remove subplot panes
  • Assign any channel (physical or derived) to any pane
  • Set X-axis: Time (elapsed s) OR any channel (e.g. strain → stress vs strain)
  • Name axes, set Y auto/fixed range, grid, relative size weight
  • Per-trace: color, label, line style, width, visibility
  • Export/Import JSON layout

Emits layout_applied(LayoutConfig) → StripChartWidget.apply_layout()
"""

from __future__ import annotations
import json
from copy import deepcopy
from dataclasses import dataclass, field, asdict
from typing import Dict, List, Optional, Tuple

from PyQt6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton,
    QScrollArea, QFrame, QLineEdit, QDoubleSpinBox, QSpinBox,
    QCheckBox, QComboBox, QColorDialog, QToolButton,
    QFileDialog, QMessageBox,
)
from PyQt6.QtCore import Qt, pyqtSignal, QPoint, QRect
from PyQt6.QtGui import QColor, QCloseEvent, QPainter, QPen

from devices.device_registry import DeviceRegistry
from core.signal_processor import SignalProcessor


# ══════════════════════════════════════════════════════════════════════════════
#  Data model
# ══════════════════════════════════════════════════════════════════════════════

@dataclass
class TraceSpec:
    device_id:  str
    channel_id: str
    label:      str   = ""
    color:      str   = "#00d4ff"
    width:      float = 1.8
    visible:    bool  = True
    style:      str   = "solid"   # solid | dash | dot

@dataclass
class PaneSpec:
    title:    str              = "Plot"
    x_source: str              = "time"  # "time" | "dev_id/ch_id"
    y_label:  str              = ""
    x_label:  str              = "Elapsed (s)"
    y_auto:   bool             = True
    y_min:    float            = -10.0
    y_max:    float            =  10.0
    grid:     bool             = True
    weight:   int              = 1       # relative size
    traces:   List[TraceSpec]  = field(default_factory=list)
    row:      Optional[int]    = None   # canvas grid position; None = unassigned
    col:      Optional[int]    = None

@dataclass
class LayoutConfig:
    panes:         List[PaneSpec] = field(default_factory=list)
    layout_mode:   str            = "stacked"   # stacked | sidebyside | grid | free
    grid_cols:     int            = 2
    time_window_s: float          = 30.0
    link_x:        bool           = True
    show_legend:   bool           = True

    def to_json(self) -> str:
        return json.dumps(asdict(self), indent=2)

    @staticmethod
    def from_json(s: str) -> "LayoutConfig":
        d = json.loads(s)
        panes = []
        for p in d.pop("panes", []):
            traces = [TraceSpec(**t) for t in p.pop("traces", [])]
            panes.append(PaneSpec(**p, traces=traces))
        return LayoutConfig(**d, panes=panes)


def build_default_layout(registry: DeviceRegistry,
                         processor: SignalProcessor) -> LayoutConfig:
    cfg = LayoutConfig()
    for dev in registry.all_instances():
        enabled = [ch for ch in dev.info.channels if ch.enabled]
        if not enabled: continue
        pane = PaneSpec(title=dev.info.name,
                        y_label=enabled[0].unit if enabled else "")
        for ch in enabled:
            pane.traces.append(TraceSpec(
                device_id=dev.info.device_id, channel_id=ch.channel_id,
                label=ch.name, color=ch.color,
            ))
        if pane.traces: cfg.panes.append(pane)
    for dc in processor.get_derived():
        pane = PaneSpec(title=dc.name, y_label=dc.unit)
        pane.traces.append(TraceSpec(
            device_id="derived", channel_id=dc.channel_id,
            label=dc.name, color=dc.color,
        ))
        cfg.panes.append(pane)
    return cfg


# ══════════════════════════════════════════════════════════════════════════════
#  Color swatch
# ══════════════════════════════════════════════════════════════════════════════

class ColorSwatch(QPushButton):
    color_changed = pyqtSignal(str)
    def __init__(self, color="#00d4ff"):
        super().__init__(); self._c = color
        self.setFixedSize(26,20); self._paint(); self.clicked.connect(self._pick)
    def _paint(self):
        self.setStyleSheet(f"QPushButton{{background:{self._c};border:1px solid #2a3558;"
                           f"border-radius:3px;}}QPushButton:hover{{border-color:#3b82f6;}}")
    def _pick(self):
        c = QColorDialog.getColor(QColor(self._c), self)
        if c.isValid(): self._c = c.name(); self._paint(); self.color_changed.emit(self._c)
    @property
    def color(self): return self._c


# ══════════════════════════════════════════════════════════════════════════════
#  Trace row
# ══════════════════════════════════════════════════════════════════════════════

class TraceRow(QFrame):
    removed = pyqtSignal(object)
    changed = pyqtSignal()
    def __init__(self, tr: TraceSpec):
        super().__init__(); self.tr = tr; self.setObjectName("traceRow"); self._build()
    def _build(self):
        lay = QHBoxLayout(self); lay.setContentsMargins(6,3,6,3); lay.setSpacing(6)
        self._vis = QCheckBox(); self._vis.setChecked(self.tr.visible)
        self._vis.toggled.connect(lambda v: (setattr(self.tr,"visible",v), self.changed.emit()))
        lay.addWidget(self._vis)
        self._sw = ColorSwatch(self.tr.color)
        self._sw.color_changed.connect(lambda c: (setattr(self.tr,"color",c), self.changed.emit()))
        lay.addWidget(self._sw)
        src = QLabel(f"{self.tr.device_id} / {self.tr.channel_id}")
        src.setObjectName("traceSource"); src.setMinimumWidth(130); lay.addWidget(src)
        self._lbl = QLineEdit(self.tr.label); self._lbl.setObjectName("traceLabel")
        self._lbl.setPlaceholderText("Label…")
        self._lbl.textChanged.connect(lambda t: setattr(self.tr,"label",t))
        lay.addWidget(self._lbl,1)
        self._sty = QComboBox(); self._sty.setObjectName("traceStyleCb")
        self._sty.addItems(["solid","dash","dot"]); self._sty.setCurrentText(self.tr.style)
        self._sty.setFixedWidth(64)
        self._sty.currentTextChanged.connect(lambda s: setattr(self.tr,"style",s))
        lay.addWidget(self._sty)
        self._w = QDoubleSpinBox(); self._w.setObjectName("traceWidthSpin")
        self._w.setRange(0.5,6.0); self._w.setSingleStep(0.5)
        self._w.setValue(self.tr.width); self._w.setFixedWidth(56)
        self._w.valueChanged.connect(lambda v: setattr(self.tr,"width",v))
        lay.addWidget(self._w)
        rm = QToolButton(); rm.setText("✕"); rm.setObjectName("traceRemoveBtn")
        rm.setFixedSize(22,22); rm.clicked.connect(lambda: self.removed.emit(self))
        lay.addWidget(rm)


# ══════════════════════════════════════════════════════════════════════════════
#  Pane block
# ══════════════════════════════════════════════════════════════════════════════

class PaneBlock(QFrame):
    removed       = pyqtSignal(object)
    changed       = pyqtSignal()
    title_changed = pyqtSignal(object, str)   # (self, new_title)

    def __init__(self, spec: PaneSpec, registry: DeviceRegistry,
                 processor: SignalProcessor):
        super().__init__()
        self.spec = spec; self.registry = registry; self.processor = processor
        self._rows: List[TraceRow] = []
        self.setObjectName("plotBlock"); self._build()

    def _build(self):
        outer = QVBoxLayout(self); outer.setContentsMargins(0,0,0,0); outer.setSpacing(0)

        # Header
        hdr = QWidget(); hdr.setObjectName("plotBlockHeader"); hdr.setFixedHeight(32)
        hl = QHBoxLayout(hdr); hl.setContentsMargins(8,0,6,0); hl.setSpacing(4)
        self._title = QLineEdit(self.spec.title); self._title.setObjectName("plotBlockTitle")
        self._title.textChanged.connect(lambda t: (
            setattr(self.spec, "title", t),
            self.title_changed.emit(self, t),
        ))
        hl.addWidget(self._title, 1)
        rm = QToolButton(); rm.setText("✕"); rm.setObjectName("plotRemoveBtn")
        rm.setFixedSize(22,22); rm.clicked.connect(lambda: self.removed.emit(self)); hl.addWidget(rm)
        outer.addWidget(hdr)

        # Settings row
        sett = QWidget(); sett.setObjectName("plotBlockSettings")
        sl = QHBoxLayout(sett); sl.setContentsMargins(8,6,8,6); sl.setSpacing(8)

        sl.addWidget(QLabel("X Axis:"))
        self._x_cb = QComboBox(); self._x_cb.setObjectName("channelPickerCb")
        self._x_cb.setMinimumWidth(150)
        self._x_cb.addItem("⏱  Time (elapsed s)", userData="time")
        for dev in self.registry.all_instances():
            for ch in dev.info.channels:
                if not ch.enabled:
                    continue
                self._x_cb.addItem(f"{dev.info.device_id}/{ch.channel_id}  ({ch.name})",
                                   userData=f"{dev.info.device_id}/{ch.channel_id}")
        for dc in self.processor.get_derived():
            self._x_cb.addItem(f"[virtual] {dc.channel_id}",
                               userData=f"derived/{dc.channel_id}")
        for i in range(self._x_cb.count()):
            if self._x_cb.itemData(i) == self.spec.x_source:
                self._x_cb.setCurrentIndex(i); break
        self._x_cb.currentIndexChanged.connect(
            lambda: setattr(self.spec,"x_source", self._x_cb.currentData() or "time"))
        sl.addWidget(self._x_cb)

        sl.addWidget(QLabel("Y:"))
        self._ylabel = QLineEdit(self.spec.y_label); self._ylabel.setObjectName("plotYLabelEdit")
        self._ylabel.setPlaceholderText("Y label"); self._ylabel.setMaximumWidth(110)
        self._ylabel.textChanged.connect(lambda t: setattr(self.spec,"y_label",t))
        sl.addWidget(self._ylabel)

        self._auto = QCheckBox("Auto Y"); self._auto.setChecked(self.spec.y_auto)
        self._auto.toggled.connect(self._on_auto); sl.addWidget(self._auto)

        sl.addWidget(QLabel("Min:"))
        self._ymin = QDoubleSpinBox(); self._ymin.setRange(-1e9,1e9)
        self._ymin.setValue(self.spec.y_min); self._ymin.setFixedWidth(72)
        self._ymin.setEnabled(not self.spec.y_auto)
        self._ymin.valueChanged.connect(lambda v: setattr(self.spec,"y_min",v))
        sl.addWidget(self._ymin)

        sl.addWidget(QLabel("Max:"))
        self._ymax = QDoubleSpinBox(); self._ymax.setRange(-1e9,1e9)
        self._ymax.setValue(self.spec.y_max); self._ymax.setFixedWidth(72)
        self._ymax.setEnabled(not self.spec.y_auto)
        self._ymax.valueChanged.connect(lambda v: setattr(self.spec,"y_max",v))
        sl.addWidget(self._ymax)

        self._grid = QCheckBox("Grid"); self._grid.setChecked(self.spec.grid)
        self._grid.toggled.connect(lambda v: setattr(self.spec,"grid",v))
        sl.addWidget(self._grid)

        sl.addWidget(QLabel("Size:"))
        self._wt = QSpinBox(); self._wt.setRange(1,10); self._wt.setValue(self.spec.weight)
        self._wt.setFixedWidth(44); self._wt.setToolTip("Relative pane size")
        self._wt.valueChanged.connect(lambda v: setattr(self.spec,"weight",v))
        sl.addWidget(self._wt); sl.addStretch()
        outer.addWidget(sett)

        # Traces
        tr_w = QWidget(); tr_w.setObjectName("plotBlockTraces")
        self._tlay = QVBoxLayout(tr_w)
        self._tlay.setContentsMargins(4,2,4,4); self._tlay.setSpacing(2)
        for tr in self.spec.traces: self._add_row(tr)

        pick_row = QHBoxLayout()
        self._picker = self._make_picker(); pick_row.addWidget(self._picker,1)
        ab = QPushButton("＋ Add Channel"); ab.setObjectName("addTraceBtn")
        ab.clicked.connect(self._on_add); pick_row.addWidget(ab)
        self._tlay.addLayout(pick_row)
        outer.addWidget(tr_w)

    def _make_picker(self):
        cb = QComboBox(); cb.setObjectName("channelPickerCb")
        for dev in self.registry.all_instances():
            for ch in dev.info.channels:
                if not ch.enabled:
                    continue
                cb.addItem(f"{dev.info.device_id} / {ch.channel_id}  ({ch.name})",
                           userData=(dev.info.device_id, ch.channel_id, ch.name, ch.color))
        for dc in self.processor.get_derived():
            cb.addItem(f"[virtual] {dc.channel_id}  ({dc.name})",
                       userData=("derived", dc.channel_id, dc.name, dc.color))
        return cb

    def _add_row(self, tr: TraceSpec):
        row = TraceRow(tr); row.removed.connect(self._rm_row)
        row.changed.connect(self.changed)
        self._rows.append(row)
        self._tlay.insertWidget(self._tlay.count()-1, row)

    def _rm_row(self, row: TraceRow):
        if row.tr in self.spec.traces: self.spec.traces.remove(row.tr)
        self._rows.remove(row); self._tlay.removeWidget(row); row.deleteLater()
        self.changed.emit()

    def _on_add(self):
        data = self._picker.currentData()
        if not data: return
        d,c,n,col = data
        tr = TraceSpec(device_id=d,channel_id=c,label=n,color=col)
        self.spec.traces.append(tr); self._add_row(tr); self.changed.emit()

    def _on_auto(self, v):
        self.spec.y_auto = v; self._ymin.setEnabled(not v); self._ymax.setEnabled(not v)


# ══════════════════════════════════════════════════════════════════════════════
#  Layout canvas — drag-and-snap tiling pane arranger
# ══════════════════════════════════════════════════════════════════════════════

_CANVAS_CELL_W = 120
_CANVAS_CELL_H = 76
_CANVAS_GAP    = 6
_CANVAS_COLS   = 4


class PaneTile(QFrame):
    def __init__(self, pane_index: int, title: str, parent: QWidget) -> None:
        super().__init__(parent)
        self.pane_index = pane_index
        self.setObjectName("layoutTile")
        self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, True)
        lay = QVBoxLayout(self)
        lay.setContentsMargins(4, 4, 4, 4)
        self._lbl = QLabel(title)
        self._lbl.setObjectName("layoutTileLabel")
        self._lbl.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self._lbl.setWordWrap(True)
        lay.addWidget(self._lbl)

    def set_title(self, title: str) -> None:
        self._lbl.setText(title)

    def set_dragging(self, v: bool) -> None:
        self.setObjectName("layoutTileDragging" if v else "layoutTile")
        self.style().unpolish(self)
        self.style().polish(self)
        self._lbl.setObjectName("layoutTileLabel")
        self._lbl.style().unpolish(self._lbl)
        self._lbl.style().polish(self._lbl)


class LayoutCanvas(QFrame):
    arrangement_changed = pyqtSignal()

    def __init__(self, panes: List[PaneSpec], parent: Optional[QWidget] = None) -> None:
        super().__init__(parent)
        self.setObjectName("layoutCanvasWidget")
        self.setMouseTracking(True)
        self._panes: List[PaneSpec] = panes
        self._tiles: List[PaneTile] = []
        self._grid:  Dict[Tuple[int, int], int] = {}
        self._drag_tile:   Optional[PaneTile]      = None
        self._drag_offset: QPoint                  = QPoint()
        self._ghost_cell:  Optional[Tuple[int,int]] = None
        self._assign_legacy_positions()
        self._rebuild_tiles()

    # ── Public ────────────────────────────────────────────────────────────────

    def sync_panes(self, panes: List[PaneSpec]) -> None:
        self._panes = panes
        self._drag_tile = None
        self._ghost_cell = None
        self._assign_legacy_positions()
        self._rebuild_tiles()

    def update_tile_title(self, pane_index: int, title: str) -> None:
        if 0 <= pane_index < len(self._tiles):
            self._tiles[pane_index].set_title(title)

    # ── Position assignment ───────────────────────────────────────────────────

    def _assign_legacy_positions(self) -> None:
        occupied = {(p.row, p.col) for p in self._panes
                    if p.row is not None and p.col is not None}
        for pane in self._panes:
            if pane.row is None or pane.col is None:
                row = 0
                while (row, 0) in occupied:
                    row += 1
                pane.row, pane.col = row, 0
                occupied.add((row, 0))

    # ── Rebuild ───────────────────────────────────────────────────────────────

    def _rebuild_tiles(self) -> None:
        for t in self._tiles:
            t.deleteLater()
        self._tiles.clear()
        self._grid.clear()
        for i, pane in enumerate(self._panes):
            tile = PaneTile(i, pane.title, self)
            tile.setGeometry(self._cell_rect(pane.row, pane.col))
            tile.show()
            self._tiles.append(tile)
            self._grid[(pane.row, pane.col)] = i
        self._resize_canvas()

    def _resize_canvas(self) -> None:
        if not self._panes:
            self.setFixedSize(
                _CANVAS_COLS * (_CANVAS_CELL_W + _CANVAS_GAP) + _CANVAS_GAP,
                _CANVAS_CELL_H + 2 * _CANVAS_GAP,
            )
            return
        max_row = max((p.row for p in self._panes if p.row is not None), default=0)
        h = (max_row + 1) * (_CANVAS_CELL_H + _CANVAS_GAP) + _CANVAS_GAP
        w = _CANVAS_COLS * (_CANVAS_CELL_W + _CANVAS_GAP) + _CANVAS_GAP
        self.setFixedSize(w, h)

    def _cell_rect(self, row: int, col: int) -> QRect:
        x = _CANVAS_GAP + col * (_CANVAS_CELL_W + _CANVAS_GAP)
        y = _CANVAS_GAP + row * (_CANVAS_CELL_H + _CANVAS_GAP)
        return QRect(x, y, _CANVAS_CELL_W, _CANVAS_CELL_H)

    def _tile_at(self, pos: QPoint) -> Optional[PaneTile]:
        for tile in reversed(self._tiles):
            if tile.geometry().contains(pos):
                return tile
        return None

    def _nearest_cell(self, pos: QPoint) -> Tuple[int, int]:
        max_row = max((p.row for p in self._panes if p.row is not None), default=0)
        max_rows = max(max_row + 2, len(self._panes))
        col = max(0, min(_CANVAS_COLS - 1, pos.x() // (_CANVAS_CELL_W + _CANVAS_GAP)))
        row = max(0, min(max_rows - 1,     pos.y() // (_CANVAS_CELL_H + _CANVAS_GAP)))
        return (int(row), int(col))

    # ── Drag ─────────────────────────────────────────────────────────────────

    def mousePressEvent(self, event) -> None:
        if event.button() != Qt.MouseButton.LeftButton:
            return
        tile = self._tile_at(event.pos())
        if tile is None:
            return
        self._drag_tile = tile
        self._drag_offset = event.pos() - tile.pos()
        tile.set_dragging(True)
        tile.raise_()

    def mouseMoveEvent(self, event) -> None:
        if self._drag_tile is None:
            return
        self._drag_tile.move(event.pos() - self._drag_offset)
        snap = self._nearest_cell(event.pos())
        if snap != self._ghost_cell:
            self._ghost_cell = snap
            self.update()

    def mouseReleaseEvent(self, event) -> None:
        if self._drag_tile is None:
            return
        snap = self._nearest_cell(event.pos())
        self._do_drop(self._drag_tile.pane_index, snap)
        self._drag_tile.set_dragging(False)
        self._drag_tile = None
        self._ghost_cell = None
        self.update()

    def _do_drop(self, pane_index: int, target: Tuple[int, int]) -> None:
        dragged = self._panes[pane_index]
        old = (dragged.row, dragged.col)

        if old == target:
            self._tiles[pane_index].setGeometry(self._cell_rect(*old))
            return

        occupant_idx = self._grid.get(target)

        if occupant_idx is not None:
            occupant = self._panes[occupant_idx]
            occupant.row, occupant.col = old
            self._tiles[occupant_idx].setGeometry(self._cell_rect(*old))
            self._grid[old] = occupant_idx
        else:
            self._grid.pop(old, None)

        dragged.row, dragged.col = target
        self._tiles[pane_index].setGeometry(self._cell_rect(*target))
        self._grid[target] = pane_index

        self._resize_canvas()
        self.arrangement_changed.emit()

    # ── Ghost highlight ───────────────────────────────────────────────────────

    def paintEvent(self, event) -> None:
        super().paintEvent(event)
        if self._ghost_cell is None:
            return
        painter = QPainter(self)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
        r = self._cell_rect(*self._ghost_cell)
        painter.setPen(QPen(QColor("#3b82f6"), 2))
        painter.setBrush(QColor(59, 130, 246, 40))
        painter.drawRoundedRect(r, 4, 4)


# ══════════════════════════════════════════════════════════════════════════════
#  PlotWindow
# ══════════════════════════════════════════════════════════════════════════════

class PlotWindow(QWidget):
    layout_applied = pyqtSignal(object)   # LayoutConfig
    closed         = pyqtSignal()

    def __init__(self, registry: DeviceRegistry, processor: SignalProcessor,
                 current: Optional[LayoutConfig] = None, parent=None):
        super().__init__(parent, Qt.WindowType.Window)
        self.registry  = registry
        self.processor = processor
        self.cfg       = deepcopy(current) if current \
                         else build_default_layout(registry, processor)
        self.setWindowTitle("Plot Builder")
        self.setMinimumSize(720, 560)
        self.resize(820, 760)
        self._blocks: List[PaneBlock] = []
        self._build()
        self._populate()

    def _build(self):
        root = QVBoxLayout(self); root.setContentsMargins(0,0,0,0); root.setSpacing(0)

        # Header
        hdr = QWidget(); hdr.setObjectName("devWindowTitleBar"); hdr.setFixedHeight(44)
        hl  = QHBoxLayout(hdr); hl.setContentsMargins(14,0,10,0)
        hl.addWidget(QLabel("PLOT BUILDER").also(lambda w: w.setObjectName("devWindowTitle")),1)
        root.addWidget(hdr)
        div = QFrame(); div.setFrameShape(QFrame.Shape.HLine)
        div.setObjectName("devWindowDivider"); root.addWidget(div)

        # Global settings bar
        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)

        # Layout canvas section
        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  —  drag tiles to arrange")
        clbl.setObjectName("layoutCanvasLabel")
        cb_lay.addWidget(clbl)
        self._canvas = LayoutCanvas(self.cfg.panes, self)
        self._canvas.arrangement_changed.connect(self._maybe_live)
        cb_lay.addWidget(self._canvas)
        root.addWidget(canvas_bar)

        div2 = QFrame(); div2.setFrameShape(QFrame.Shape.HLine)
        div2.setObjectName("devWindowDivider"); root.addWidget(div2)

        # Scrollable pane blocks
        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)

        # Bottom
        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)

    def _populate(self):
        for b in self._blocks:
            self._blay.removeWidget(b); b.deleteLater()
        self._blocks.clear()
        for spec in self.cfg.panes:
            self._insert(spec)
        self._canvas.sync_panes(self.cfg.panes)
        self.cfg.layout_mode = "free"

    def _insert(self, spec: PaneSpec):
        blk = PaneBlock(spec, self.registry, self.processor)
        blk.removed.connect(self._rm)
        blk.changed.connect(self._maybe_live)
        blk.title_changed.connect(self._on_tile_title)
        self._blocks.append(blk)
        self._blay.insertWidget(self._blay.count()-1, blk)

    def _on_tile_title(self, blk: PaneBlock, title: str) -> None:
        if blk in self._blocks:
            self._canvas.update_tile_title(self._blocks.index(blk), title)

    def _add_pane(self):
        spec = PaneSpec(title=f"Plot {len(self.cfg.panes)+1}")
        self.cfg.panes.append(spec)
        self._insert(spec)
        self._canvas.sync_panes(self.cfg.panes)
        self.cfg.layout_mode = "free"
        self._maybe_live()

    def _rm(self, blk):
        if blk.spec in self.cfg.panes: self.cfg.panes.remove(blk.spec)
        self._blocks.remove(blk); self._blay.removeWidget(blk); blk.deleteLater()
        self._canvas.sync_panes(self.cfg.panes)
        self._maybe_live()

    def _maybe_live(self):
        if self._live.isChecked(): self.layout_applied.emit(deepcopy(self.cfg))

    def _apply(self): self.layout_applied.emit(deepcopy(self.cfg))

    def _reset(self):
        self.cfg = build_default_layout(self.registry, self.processor)
        self._win.setValue(self.cfg.time_window_s)
        self._populate()
        self._maybe_live()

    def _export(self):
        path, _ = QFileDialog.getSaveFileName(self,"Export","layout.json","JSON (*.json)")
        if path: open(path,"w").write(self.cfg.to_json())

    def _import_json(self):
        path, _ = QFileDialog.getOpenFileName(self,"Import","","JSON (*.json)")
        if path:
            try:
                self.cfg = LayoutConfig.from_json(open(path).read())
                self._win.setValue(self.cfg.time_window_s)
                self._populate()
                self._maybe_live()
            except Exception as e:
                QMessageBox.critical(self,"Import failed",str(e))

    def refresh_channels(self):
        self._populate()

    def closeEvent(self, e: QCloseEvent):
        self.closed.emit(); e.accept()


# monkey-patch QLabel.also for inline objectName setting
from PyQt6.QtWidgets import QLabel as _QLabel2
def _also2(self, fn): fn(self); return self
if not hasattr(_QLabel2, "also"): _QLabel2.also = _also2