Добавить общее перетаскивание графиков и независимые шкалы амплитуд

python/set_devices/qt_ports/plot_drag.py

@@ -0,0 +1,108 @@
+"""Shared marker picking and axis-constrained plot drags (Qt 5/6).
+
+The widget supplies plot/value rectangles, a PlotMath core, viewport/markers,
+axis locks and refresh hooks. Geometry and numeric transforms use protocan.plot.
+"""
+from dataclasses import replace
+
+try:
+    from PySide6.QtCore import QPointF, Qt
+    from PySide6.QtWidgets import QApplication
+except ImportError:
+    from PySide2.QtCore import QPointF, Qt
+    from PySide2.QtWidgets import QApplication
+
+
+DRAG_HINT = ('ЛКМ рядом с маркером — двигать маркер; ЛКМ на свободном поле — '
+             'перемещение по X; Shift + ЛКМ — перемещение по Y. '
+             'Щелчок мимо маркеров — одиночный курсор.')
+
+
+def vertical_pan_requested(event):
+    return bool(event.modifiers() & Qt.ShiftModifier)
+
+
+def cursor_hit(plot, position, value, event, radius=8):
+    """Shift always pans; a cursor can only be grabbed near its visible line."""
+    return (not vertical_pan_requested(event) and value is not None
+            and plot.core is not None and plot.has_plot_data
+            and plot.visible_bounds.left <= value <= plot.visible_bounds.right
+            and plot.plot_rect().contains(position)
+            and abs(plot.project(value, 0, plot.plot_rect()).x() - position.x()) <= radius)
+
+
+class PlotDragInteraction:
+    """Capture a hit marker or pan one axis, chosen at the start of the drag."""
+
+    def mousePressEvent(self, event):
+        if event.button() != Qt.LeftButton or not self.core:
+            return super().mousePressEvent(event)
+        pos = event.position() if hasattr(event, 'position') else event.localPos()
+        rect, values = self.plot_rect(), self.value_rect()
+        self._press = self._dragged = None
+        if not rect.contains(pos):
+            return
+        self.setFocus(Qt.MouseFocusReason)
+        self._press = QPointF(pos)
+        self._press_viewport = self.viewport
+        self._press_markers = self.markers
+        self._press_bounds = self.visible_bounds
+        self._pan_vertical = vertical_pan_requested(event)
+        self._pan_moved = False
+        if self.marker_mode.isChecked() and not self._pan_vertical and self.has_plot_data:
+            # X lines span digital lanes; Y lines only occupy the analog pane.
+            markers = self.markers if values.contains(pos) else replace(self.markers, y_enabled=False)
+            self._dragged = markers.hit(self.core, pos.x() - rect.left(),
+                pos.y() - values.top() if values.contains(pos) else 0,
+                rect.width(), values.height(), 12, self._press_bounds)
+            if self._dragged is not None:
+                self.markers = replace(self.markers, selected=self._dragged)
+                self._refresh_controls()
+                self.update()
+        event.accept()
+
+    def mouseMoveEvent(self, event):
+        if not event.buttons() & Qt.LeftButton:
+            self._press = self._dragged = None
+            return super().mouseMoveEvent(event)
+        if self._press is None or not self.core:
+            return super().mouseMoveEvent(event)
+        pos = event.position() if hasattr(event, 'position') else event.localPos()
+        self._update_drag(pos)
+        event.accept()
+
+    def _update_drag(self, pos):
+        delta = pos - self._press
+        self._pan_moved |= delta.manhattanLength() >= QApplication.startDragDistance()
+        rect, values = self.plot_rect(), self.value_rect()
+        if self._dragged is not None:
+            marker = self._dragged
+            self.markers = self._press_markers.drag(self.core, marker,
+                delta.y() if marker.horizontal else delta.x(),
+                values.height() if marker.horizontal else rect.width(), self._press_bounds)
+        else:
+            self.viewport = self._press_viewport.transform(self.core,
+                pan_x=delta.x() / rect.width() if not self._pan_vertical and not self.lock_x else 0,
+                pan_y=delta.y() / values.height() if self._pan_vertical and not self.lock_y else 0)
+        self._refresh_controls()
+        self.update()
+
+    def mouseReleaseEvent(self, event):
+        if event.button() != Qt.LeftButton:
+            return super().mouseReleaseEvent(event)
+        if self._press is not None and self.core:
+            # Qt may coalesce moves; always commit the final release position.
+            pos = event.position() if hasattr(event, 'position') else event.localPos()
+            self._update_drag(pos)
+            single_click = (self._dragged is None and not self._pan_vertical
+                            and not self._pan_moved and self.plot_rect().contains(pos))
+            if single_click:
+                # A click with small hand jitter must not pan the time axis.
+                self.viewport = self._press_viewport
+                self._single_cursor_click(pos)
+            self.view_changed.emit()
+        self._press = self._dragged = None
+        super().mouseReleaseEvent(event)
+
+    def _single_cursor_click(self, pos):
+        """Optional widget hook: return from paired markers to a single cursor."""

python/set_devices/qt_ports/plot_dual_axis.py

@@ -0,0 +1,124 @@
+"""Independent amplitude axes for SignalPlot-compatible Qt canvases."""
+import math
+
+try:
+    from PySide6.QtCore import QPointF, Qt
+    from PySide6.QtGui import QColor
+except ImportError:
+    from PySide2.QtCore import QPointF, Qt
+    from PySide2.QtGui import QColor
+from protocan.plot import Bounds, Viewport
+
+
+def split_amplitudes(series, minimum_ratio=10):
+    """Split at the largest decade gap; zero-valued channels join small ones."""
+    magnitudes = sorted((max((abs(v) for v in s.values if math.isfinite(v)), default=0), s.key)
+                        for s in series if s.visible and not s.discrete and len(s.values))
+    positive = [(m, key) for m, key in magnitudes if m > 0]
+    gaps = [(positive[i + 1][0] / positive[i][0], positive[i][0])
+            for i in range(len(positive) - 1)]
+    if not gaps or max(gaps)[0] < minimum_ratio:
+        return set()
+    threshold = max(gaps)[1]
+    return {key for magnitude, key in magnitudes if magnitude <= threshold}
+
+
+class DualAxisPlot:
+    """Mixin: left axis for large channels, right for small channels.
+
+    Shift-wheel selects the axis by the pointer's half of the analog pane.
+    The host supplies series_bounds/project_series rendering hooks.
+    """
+    def __init__(self, *args, **kwargs):
+        self.right_axis_keys = set()
+        self.right_data_bounds = Bounds(0, 1, 0, 1)
+        self.right_viewport = Viewport()
+        super().__init__(*args, **kwargs)
+
+    def _sync_bounds(self):
+        keys = split_amplitudes(self._series)
+        if keys != self.right_axis_keys:
+            self.right_viewport = Viewport()
+        self.right_axis_keys = keys
+        super()._sync_bounds()
+
+    def set_plot_bounds(self, bounds, has_data=True, x_origin=0):
+        if self.right_axis_keys:
+            groups = [[], []]
+            for series in self._series:
+                if series.visible and not series.discrete:
+                    groups[series.key in self.right_axis_keys].extend(
+                        v for v in series.values if math.isfinite(v))
+            ranges = []
+            for values in groups:
+                low, high = (min(values), max(values)) if values else (0, 1)
+                pad = max((high - low) * .08, max(abs(low), abs(high)) * .01, 1e-6)
+                ranges.append(Bounds(bounds.left, bounds.right, low - pad, high + pad))
+            bounds, self.right_data_bounds = ranges
+        super().set_plot_bounds(bounds, has_data, x_origin)
+
+    @property
+    def right_visible_bounds(self):
+        right = (self.right_data_bounds.visible(self.core, self.right_viewport)
+                 if self.core else self.right_data_bounds)
+        left = self.visible_bounds
+        return Bounds(left.left, left.right, right.bottom, right.top)
+
+    def series_bounds(self, series):
+        return self.right_visible_bounds if series.key in self.right_axis_keys else self.visible_bounds
+
+    def plot_rect(self):
+        rect = super().plot_rect()
+        if self.right_axis_keys:
+            rect.setWidth(max(1, rect.width() - 72))
+        return rect
+
+    def right_axis_margin(self):
+        return 72 if self.right_axis_keys else 0
+
+    def reset_viewport(self):
+        self.right_viewport = Viewport()
+        super().reset_viewport()
+
+    def reset_interaction(self):
+        self.right_viewport = Viewport()
+        super().reset_interaction()
+
+    def wheelEvent(self, event):
+        if not event.modifiers() & Qt.ShiftModifier:
+            return super().wheelEvent(event)
+        pos = event.position() if hasattr(event, 'position') else event.posF()
+        rect = self.value_rect()
+        if not rect.top() <= pos.y() <= rect.bottom():
+            event.ignore()
+            return
+        ticks = event.angleDelta().y() or event.angleDelta().x()
+        if not ticks:
+            ticks = (event.pixelDelta().y() or event.pixelDelta().x()) * 2
+        if ticks and self.core and not self.lock_y:
+            factor = 1.25 ** max(-8, min(8, ticks / 120))
+            self.setFocus(Qt.MouseFocusReason)
+            if self.right_axis_keys and pos.x() >= rect.center().x():
+                self.right_viewport = self.right_viewport.transform(
+                    self.core, 1, factor, focus_y=(pos.y() - rect.top()) / rect.height())
+                self.update()
+                self.view_changed.emit()
+            else:
+                self._navigation_zoom(factor, True, pos)
+        event.accept()
+
+    def paint_axes_and_markers(self, painter):
+        super().paint_axes_and_markers(painter)
+        if not self.right_axis_keys or not self.core:
+            return
+        rect, bounds = self.value_rect(), self.right_visible_bounds
+        painter.save()
+        painter.setPen(QColor('#a4b8cd'))
+        step = self.core.tick_step(bounds.top - bounds.bottom, rect.height())
+        first = math.ceil(bounds.bottom / step)
+        count = min(100, max(0, math.floor(bounds.top / step) - first + 1))
+        for index in range(count):
+            value = (first + index) * step
+            y = rect.top() + bounds.fraction(self.core, value, True) * rect.height()
+            painter.drawText(QPointF(rect.right() + 7, y + 4), f'{value:.4g}')
+        painter.restore()