TwoPy 0.1.0__py3-none-any.whl

twopy/napari/plotting/options.py

@@ -0,0 +1,269 @@
+"""Qt option widgets for twopy response plots.
+
+Inputs: axis limits, ROI or epoch labels, visibility state, and optional ROI
+colors.
+Outputs: compact Qt controls for plot customization.
+
+This module owns option-panel widgets only. It does not draw response traces,
+load analysis files, or compute responses.
+"""
+
+from collections.abc import Callable, Hashable, Mapping
+from typing import cast
+
+from qtpy.QtCore import QSignalBlocker
+from qtpy.QtGui import QColor
+from qtpy.QtWidgets import (
+    QCheckBox,
+    QDoubleSpinBox,
+    QGridLayout,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
+)
+
+__all__ = [
+    "axis_options_widget",
+    "visibility_options_widget",
+]
+
+type CallableAxisBounds = Callable[..., None]
+type CallableVisibility = Callable[[Hashable, bool], None]
+type CallableVisibilityBatch = Callable[[dict[Hashable, bool]], None]
+type VisibilityKey = int | str
+type VisibilityState = Mapping[int, bool] | Mapping[str, bool]
+
+
+def axis_options_widget(
+    *,
+    x_min: float,
+    x_max: float,
+    y_min: float,
+    y_max: float,
+    on_change: object,
+) -> QWidget:
+    """Create manual axis-bound controls.
+
+    Args:
+        x_min: Initial x-axis minimum.
+        x_max: Initial x-axis maximum.
+        y_min: Initial y-axis minimum.
+        y_max: Initial y-axis maximum.
+        on_change: Callback receiving named axis bounds.
+
+    Returns:
+        Qt widget containing four numeric inputs.
+    """
+    callback = cast(CallableAxisBounds, on_change)
+    widget = QWidget()
+    layout = QGridLayout()
+    layout.addWidget(QLabel("Axis limits"), 0, 0, 1, 2)
+    x_min_spin = _axis_spin_box(x_min)
+    x_max_spin = _axis_spin_box(x_max)
+    y_min_spin = _axis_spin_box(y_min)
+    y_max_spin = _axis_spin_box(y_max)
+    layout.addWidget(QLabel("x min"), 1, 0)
+    layout.addWidget(x_min_spin, 1, 1)
+    layout.addWidget(QLabel("x max"), 2, 0)
+    layout.addWidget(x_max_spin, 2, 1)
+    layout.addWidget(QLabel("y min"), 3, 0)
+    layout.addWidget(y_min_spin, 3, 1)
+    layout.addWidget(QLabel("y max"), 4, 0)
+    layout.addWidget(y_max_spin, 4, 1)
+
+    def update_bounds() -> None:
+        """Pass current spin-box values back to the response widget."""
+        callback(
+            x_min=x_min_spin.value(),
+            x_max=x_max_spin.value(),
+            y_min=y_min_spin.value(),
+            y_max=y_max_spin.value(),
+        )
+
+    x_min_spin.valueChanged.connect(update_bounds)
+    x_max_spin.valueChanged.connect(update_bounds)
+    y_min_spin.valueChanged.connect(update_bounds)
+    y_max_spin.valueChanged.connect(update_bounds)
+    widget.setLayout(layout)
+    return widget
+
+
+def visibility_options_widget(
+    *,
+    title: str,
+    labels: tuple[str, ...],
+    visibility: VisibilityState,
+    on_change: object,
+    on_change_batch: object | None = None,
+    keys: tuple[VisibilityKey, ...] | None = None,
+    colors: tuple[QColor, ...] | None = None,
+) -> QWidget:
+    """Create select-all/select-none checkboxes for plot visibility.
+
+    Args:
+        title: Section label.
+        labels: Checkbox labels.
+        visibility: Current visibility by label or by ``keys`` when keys are
+            provided.
+        on_change: Callback receiving ``(label, visible)``.
+        on_change_batch: Optional callback receiving all labels changed by
+            Select all or None. This prevents one bulk click from redrawing the
+            plots once per checkbox.
+        keys: Optional stable callback keys matching ``labels``. Labels stay
+            human-readable; keys prevent duplicate display names from toggling
+            the wrong underlying item.
+        colors: Optional swatch colors matching ``labels`` by position.
+
+    Returns:
+        Qt widget containing controls.
+    """
+    callback = cast(CallableVisibility, on_change)
+    batch_callback = (
+        cast(CallableVisibilityBatch, on_change_batch)
+        if on_change_batch is not None
+        else None
+    )
+    widget = QWidget()
+    visibility_lookup = dict(visibility.items())
+    layout = QVBoxLayout()
+    layout.addWidget(QLabel(title))
+    button_row = QHBoxLayout()
+    all_button = QPushButton("Select all")
+    none_button = QPushButton("None")
+    button_row.addWidget(all_button)
+    button_row.addWidget(none_button)
+    layout.addLayout(button_row)
+
+    list_widget = QWidget()
+    list_layout = QVBoxLayout()
+    list_layout.setContentsMargins(0, 0, 0, 0)
+    checkboxes: list[QCheckBox] = []
+    checkbox_keys: list[VisibilityKey] = []
+    for index, label in enumerate(labels):
+        key = keys[index] if keys is not None and index < len(keys) else label
+        checkbox = QCheckBox(label)
+        checkbox.setChecked(visibility_lookup.get(key, True))
+        checkbox.stateChanged.connect(
+            lambda _state, item=key, box=checkbox: callback(item, box.isChecked())
+        )
+        checkboxes.append(checkbox)
+        checkbox_keys.append(key)
+        list_layout.addWidget(_visibility_row(checkbox, _color_at(colors, index)))
+    list_widget.setLayout(list_layout)
+
+    scroll = QScrollArea()
+    scroll.setWidgetResizable(True)
+    scroll.setWidget(list_widget)
+    scroll.setMaximumHeight(_visibility_list_height(checkboxes, visible_rows=8))
+    layout.addWidget(scroll)
+
+    def set_all(checked: bool) -> None:
+        """Set all checkboxes and visibility flags together."""
+        blockers = [QSignalBlocker(checkbox) for checkbox in checkboxes]
+        for checkbox in checkboxes:
+            checkbox.setChecked(checked)
+        del blockers
+        if batch_callback is not None:
+            batch_callback({key: checked for key in checkbox_keys})
+            return
+        for key in checkbox_keys:
+            callback(key, checked)
+
+    all_button.clicked.connect(lambda: set_all(True))
+    none_button.clicked.connect(lambda: set_all(False))
+    widget.setLayout(layout)
+    return widget
+
+
+def _axis_spin_box(value: float) -> QDoubleSpinBox:
+    """Create one numeric axis-limit input.
+
+    Args:
+        value: Initial value.
+
+    Returns:
+        Configured spin box.
+    """
+    spin_box = QDoubleSpinBox()
+    spin_box.setRange(-1_000_000.0, 1_000_000.0)
+    spin_box.setDecimals(3)
+    spin_box.setSingleStep(0.1)
+    spin_box.setValue(value)
+    return spin_box
+
+
+def _visibility_row(checkbox: QCheckBox, color: QColor | None) -> QWidget:
+    """Create one compact checkbox row, with an optional color swatch.
+
+    Args:
+        checkbox: Visibility checkbox.
+        color: Optional ROI color.
+
+    Returns:
+        Row widget for the visibility list.
+    """
+    row = QWidget()
+    layout = QHBoxLayout()
+    layout.setContentsMargins(0, 0, 0, 0)
+    if color is not None:
+        layout.addWidget(_color_swatch(color))
+    layout.addWidget(checkbox)
+    layout.addStretch(1)
+    row.setLayout(layout)
+    return row
+
+
+def _color_swatch(color: QColor) -> QWidget:
+    """Create the small color square shown beside one ROI label.
+
+    Args:
+        color: ROI color.
+
+    Returns:
+        Fixed-size Qt widget styled as a color square.
+    """
+    swatch = QWidget()
+    swatch.setFixedSize(12, 12)
+    swatch.setStyleSheet(
+        f"background-color: {color.name()}; border: 1px solid #cfd6df;"
+    )
+    return swatch
+
+
+def _color_at(colors: tuple[QColor, ...] | None, index: int) -> QColor | None:
+    """Return one optional swatch color.
+
+    Args:
+        colors: Optional colors.
+        index: Requested label index.
+
+    Returns:
+        Matching color, or ``None``.
+    """
+    if colors is None or index >= len(colors):
+        return None
+    return colors[index]
+
+
+def _visibility_list_height(
+    checkboxes: list[QCheckBox],
+    *,
+    visible_rows: int,
+) -> int:
+    """Return a compact maximum height for a checkbox list.
+
+    Args:
+        checkboxes: Checkbox widgets in one visibility section.
+        visible_rows: Number of rows to show before scrolling.
+
+    Returns:
+        Pixel height for the scroll area.
+    """
+    if len(checkboxes) == 0:
+        return 0
+    row_height = max(checkbox.sizeHint().height() for checkbox in checkboxes)
+    rows = min(len(checkboxes), visible_rows)
+    return row_height * rows + 8

twopy/napari/plotting/panels.py

@@ -0,0 +1,119 @@
+"""Small Qt panel builders for response plotting widgets.
+
+Inputs: already-created buttons, labels, layouts, and plot widgets.
+Outputs: composed Qt widgets used by the napari response docks.
+
+This module owns generic panel layout only. It does not load data, compute
+responses, or export figures.
+"""
+
+from qtpy.QtWidgets import (
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QScrollArea,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
+)
+
+from twopy.napari.plotting.widgets import EpochPlotWidget
+
+__all__ = [
+    "epoch_plot_panel",
+    "plot_size_widget",
+    "response_update_tab",
+    "scrolling_tab",
+]
+
+
+def epoch_plot_panel(*, title: str, plot: EpochPlotWidget) -> QWidget:
+    """Create one titled plot panel for the horizontal response strip.
+
+    Args:
+        title: Plot title.
+        plot: Epoch response plot widget.
+
+    Returns:
+        Qt widget containing the title and plot.
+    """
+    panel = QWidget()
+    layout = QVBoxLayout()
+    layout.addWidget(QLabel(title))
+    layout.addWidget(plot)
+    panel.setLayout(layout)
+    return panel
+
+
+def response_update_tab(
+    *,
+    reload_saved_button: QPushButton,
+    recompute_preview_button: QPushButton,
+    save_analysis_button: QPushButton,
+    recording_summary_label: QLabel,
+    analysis_output_label: QLabel,
+    roi_output_label: QLabel,
+    status_label: QLabel,
+) -> QWidget:
+    """Create the tab that owns response recompute/reload actions.
+
+    Args:
+        reload_saved_button: Button that reloads persisted response outputs.
+        recompute_preview_button: Button that computes responses from current
+            Labels ROIs.
+        save_analysis_button: Button that saves ROIs and persisted analysis.
+        recording_summary_label: Label showing root, genotype, stimulus, and
+            recording time for the selected recording.
+        analysis_output_label: Label showing the analysis output path.
+        roi_output_label: Label showing the ROI output path.
+        status_label: Label showing the latest save or reload status.
+
+    Returns:
+        Qt widget for the Update tab.
+    """
+    tab = QWidget()
+    layout = QVBoxLayout()
+    layout.addWidget(save_analysis_button)
+    layout.addWidget(recompute_preview_button)
+    layout.addWidget(reload_saved_button)
+    layout.addWidget(recording_summary_label)
+    layout.addWidget(analysis_output_label)
+    layout.addWidget(roi_output_label)
+    layout.addWidget(status_label)
+    layout.addStretch(1)
+    tab.setLayout(layout)
+    return tab
+
+
+def plot_size_widget(spin_box: QSpinBox) -> QWidget:
+    """Create the compact plot-size control row.
+
+    Args:
+        spin_box: Numeric plot-size input.
+
+    Returns:
+        Qt widget containing the label and spin box.
+    """
+    widget = QWidget()
+    layout = QHBoxLayout()
+    layout.addWidget(QLabel("Plot size"))
+    layout.addWidget(spin_box)
+    widget.setLayout(layout)
+    return widget
+
+
+def scrolling_tab(layout: QVBoxLayout) -> QScrollArea:
+    """Create a scrollable options tab around one layout.
+
+    Args:
+        layout: Layout that callers will populate with controls.
+
+    Returns:
+        Scroll area suitable for a tab body.
+    """
+    content = QWidget()
+    content.setLayout(layout)
+    scroll = QScrollArea()
+    scroll.setWidgetResizable(True)
+    scroll.setWidget(content)
+    return scroll