chartflow 0.1__py3-none-any.whl

chartflow/node/arrow_item.py

@@ -0,0 +1,287 @@
+"""
+
+
+箭头项模块 - 表示连接线上的独立箭头
+"""
+
+import math
+from typing import Optional, TYPE_CHECKING, Callable
+
+from PyQt6.QtWidgets import QGraphicsItem, QGraphicsPathItem, QGraphicsSceneMouseEvent
+from PyQt6.QtCore import Qt, QPointF, QRectF
+from PyQt6.QtGui import QPainterPath, QPen, QColor, QBrush, QPainterPathStroker
+
+from chartflow.node.styles import ArrowStyle
+from chartflow.node.enums import ArrowState
+
+class ArrowItem(QGraphicsPathItem):
+    """
+    箭头项 - 表示连接线上的独立箭头，可单独选中和拖拽
+    """
+    
+    def __init__(
+        self,
+        connection: 'ConnectionItem',
+        is_source_arrow: bool = False,
+        parent: Optional[QGraphicsItem] = None
+    ) -> None:
+        """
+        初始化箭头项
+        
+        Args:
+            connection: 所属的连接线
+            is_source_arrow: 是否是源端箭头（反向箭头）
+            parent: 父项
+        """
+        super().__init__(parent)
+        
+        self._connection: 'ConnectionItem' = connection
+        self._is_source_arrow: bool = is_source_arrow
+        self._style: ArrowStyle = ArrowStyle()
+        self._state: ArrowState = ArrowState.IDLE
+        self._arrow_tip: QPointF = QPointF(0, 0)
+        self._arrow_direction: QPointF = QPointF(1, 0)  # 箭头指向的方向
+        
+        # 回调函数（由NodeCanvas设置）
+        self._drag_started_callback: Optional[Callable[[QPointF], None]] = None
+        self._drag_moved_callback: Optional[Callable[[QPointF], None]] = None
+        self._drag_finished_callback: Optional[Callable[[QPointF, bool], None]] = None
+        
+        # 设置可选项标志
+        self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable, True)
+        self.setAcceptHoverEvents(True)
+        self.setZValue(10)  # 确保箭头在连线上方
+        
+        # 初始化样式
+        self._setupStyle()
+        
+        # 拖拽状态
+        self._is_dragging: bool = False
+        self._drag_start_pos: Optional[QPointF] = None
+    
+    def _setupStyle(self) -> None:
+        """设置箭头样式"""
+        self._normal_pen = QPen(self._style.normal_color, self._style.stroke_width)
+        self._normal_pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+        self._normal_pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
+
+        self._selected_pen = QPen(self._style.selected_color, self._style.stroke_width + 1)
+        self._selected_pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+        self._selected_pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
+
+        self._hover_pen = QPen(self._style.hover_color, self._style.stroke_width + 1)
+        self._hover_pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+        self._hover_pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
+
+        self.setPen(self._normal_pen)
+        self.setBrush(QBrush(self._style.normal_color))
+    
+    def setArrowSize(self, size: float) -> None:
+        """设置箭头大小"""
+        self._style.arrow_size = size
+    
+    def setDragCallbacks(
+        self,
+        started: Optional[Callable[[QPointF], None]] = None,
+        moved: Optional[Callable[[QPointF], None]] = None,
+        finished: Optional[Callable[[QPointF, bool], None]] = None
+    ) -> None:
+        """设置拖拽回调函数"""
+        self._drag_started_callback = started
+        self._drag_moved_callback = moved
+        self._drag_finished_callback = finished
+    
+    @property
+    def connection(self) -> 'ConnectionItem':
+        """获取所属的连接线"""
+        return self._connection
+    
+    @property
+    def isSourceArrow(self) -> bool:
+        """是否是源端箭头"""
+        return self._is_source_arrow
+
+    @property
+    def isDragging(self) -> bool:
+        """是否正在拖拽"""
+        return self._is_dragging
+    
+    @property
+    def arrowTip(self) -> QPointF:
+        """获取箭头尖端位置"""
+        return self._arrow_tip
+    
+    @property
+    def arrowDirection(self) -> QPointF:
+        """获取箭头指向的方向"""
+        return self._arrow_direction
+    
+    def updateArrow(
+        self,
+        tip_pos: QPointF,
+        direction: QPointF,
+        from_pos: QPointF
+    ) -> None:
+        """
+        更新箭头形状和位置
+        
+        Args:
+            tip_pos: 箭头尖端位置
+            direction: 箭头指向的方向（单位向量）
+            from_pos: 箭头的起始位置（用于计算角度）
+        """
+        self._arrow_tip = tip_pos
+        self._arrow_direction = direction
+        
+        # 计算箭头两个底点
+        arrow_angle = math.pi / 6  # 30度
+        arrow_size = self._style.arrow_size
+        
+        # 根据方向向量计算垂直向量
+        dx = direction.x()
+        dy = direction.y()
+        
+        # 计算两个底点
+        base1 = QPointF(
+            tip_pos.x() - arrow_size * (dx * math.cos(arrow_angle) - dy * math.sin(arrow_angle)),
+            tip_pos.y() - arrow_size * (dx * math.sin(arrow_angle) + dy * math.cos(arrow_angle))
+        )
+        base2 = QPointF(
+            tip_pos.x() - arrow_size * (dx * math.cos(-arrow_angle) - dy * math.sin(-arrow_angle)),
+            tip_pos.y() - arrow_size * (dx * math.sin(-arrow_angle) + dy * math.cos(-arrow_angle))
+        )
+        
+        # 创建箭头路径（三角形）
+        path = QPainterPath()
+        path.moveTo(tip_pos)
+        path.lineTo(base1)
+        path.lineTo(base2)
+        path.closeSubpath()
+        
+        self.setPath(path)
+        self._applyStyle()
+    
+    def _applyStyle(self) -> None:
+        """应用当前状态的样式"""
+        if self._state == ArrowState.HOVER:
+            self.setPen(self._hover_pen)
+            self.setBrush(QBrush(self._style.hover_color))
+        elif self.isSelected():
+            self.setPen(self._selected_pen)
+            self.setBrush(QBrush(self._style.selected_color))
+        else:
+            self.setPen(self._normal_pen)
+            self.setBrush(QBrush(self._style.normal_color))
+    
+    def boundingRect(self) -> QRectF:
+        """获取边界矩形，添加一些边距以便更容易选中"""
+        rect = super().boundingRect()
+        margin = 8.0
+        return rect.adjusted(-margin, -margin, margin, margin)
+    
+    def shape(self) -> QPainterPath:
+        """获取形状，用于命中测试"""
+        path = super().shape()
+        # 扩大形状以便更容易选中
+        stroke = QPainterPathStroker()
+        stroke.setWidth(10)
+        return stroke.createStroke(path)
+    
+    def hoverEnterEvent(self, event) -> None:
+        """鼠标进入事件"""
+        self._state = ArrowState.HOVER
+        self._applyStyle()
+        super().hoverEnterEvent(event)
+    
+    def hoverLeaveEvent(self, event) -> None:
+        """鼠标离开事件"""
+        self._state = ArrowState.IDLE
+        self._applyStyle()
+        super().hoverLeaveEvent(event)
+    
+    def mousePressEvent(self, event: QGraphicsSceneMouseEvent) -> None:
+        """鼠标按下事件 - 开始拖拽"""
+        if event.button() == Qt.MouseButton.LeftButton:
+            self._is_dragging = True
+            self._drag_start_pos = event.scenePos()
+            self.setSelected(True)
+            if self._drag_started_callback:
+                self._drag_started_callback(event.scenePos())
+            event.accept()
+        else:
+            super().mousePressEvent(event)
+    
+    def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent) -> None:
+        """鼠标移动事件 - 拖拽中"""
+        if self._is_dragging:
+            if self._drag_moved_callback:
+                self._drag_moved_callback(event.scenePos())
+            event.accept()
+        else:
+            super().mouseMoveEvent(event)
+    
+    def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent) -> None:
+        """鼠标释放事件 - 结束拖拽"""
+        if self._is_dragging and event.button() == Qt.MouseButton.LeftButton:
+            self._is_dragging = False
+            # 检查是否连接到了节点
+            scene = self.scene()
+            is_success = False
+            if scene:
+                # 获取该位置的所有项，查找节点（连接线和箭头可能覆盖在节点上）
+                items = scene.items(event.scenePos())
+                target_node = None
+                for item in items:
+                    # 通过类名字符串避免循环导入（NodeItem/ConnectionItem）
+                    _clsname = item.__class__.__name__
+                    if _clsname == 'NodeItem':
+                        target_node = item
+                        break
+                    # 如果是连接线，跳过继续查找
+                    if _clsname == 'ConnectionItem':
+                        continue
+
+                is_success = target_node is not None
+
+            if self._drag_finished_callback:
+                self._drag_finished_callback(event.scenePos(), is_success)
+
+            event.accept()
+        else:
+            super().mouseReleaseEvent(event)
+    
+    def itemChange(self, change: QGraphicsItem.GraphicsItemChange, value):
+        """项状态改变事件"""
+        if change == QGraphicsItem.GraphicsItemChange.ItemSelectedChange:
+            self._applyStyle()
+        return super().itemChange(change, value)
+
+    def setColor(self, color: QColor) -> None:
+        """
+        设置箭头的主颜色（填充和描边）
+
+        Args:
+            color: 主颜色
+        """
+        self._style.normal_color = color
+        self._style.selected_color = color
+        self._style.hover_color = color
+        self._setupStyle()
+
+    def setBorder(self, width: int = 1, color: QColor = None) -> None:
+        """
+        设置箭头的边框宽度和颜色
+
+        Args:
+            width: 边框宽度，<=0 表示无边框
+            color: 边框颜色，None 表示使用默认颜色
+        """
+        if width <= 0:
+            self.setPen(QPen(Qt.PenStyle.NoPen))
+        else:
+            self._style.stroke_width = width
+            if color is not None:
+                self._style.normal_color = color
+                self._style.selected_color = color
+                self._style.hover_color = color
+            self._setupStyle()

chartflow/node/color_utils.py

@@ -0,0 +1,113 @@
+"""颜色工具模块 - 连线渐变用的感知亮度调整
+
+提供基于 WCAG 相对亮度(WCAG 2.x)的颜色调整辅助:
+
+  - :func:`relative_luminance`: 计算 QColor 的 WCAG 相对亮度(0~1)。
+  - :func:`color_at_relative_luminance`: 把一个颜色调整到指定相对亮度,
+    尽量保留色相与饱和度(均匀缩放 sRGB 线性通道, 再二分微调收敛)。
+  - :data:`PORT_GRADIENT_NEUTRAL_LUMINANCE`: 记录为常量的"当前连线灰度亮度",
+    取自默认连线灰 ``DEFAULT_CONNECTION_NORMAL = #8B93A1``。
+
+连线渐变规则: 当某一端为 port 时, 该端颜色取 port.color(或所在侧默认色),
+并用 :func:`color_at_relative_luminance` 调整到 ``PORT_GRADIENT_NEUTRAL_LUMINANCE``;
+连线中点为同一亮度下的中性灰。两端点同亮度(中间 RGB 插值不严格保证)。
+"""
+
+from typing import Optional
+
+from PyQt6.QtGui import QColor
+
+
+# ---- 常量: 当前连线灰度亮度(取自默认连线灰 #8B93A1 的 WCAG 相对亮度) ----
+PORT_GRADIENT_NEUTRAL_LUMINANCE: float = 0.289296
+
+
+def _srgb_to_linear(c: float) -> float:
+    """sRGB 单通道(0~1) -> 线性光(0~1)。"""
+    return c / 12.92 if c <= 0.03928 else ((c + 0.055) / 1.055) ** 2.4
+
+
+def _linear_to_srgb(c: float) -> float:
+    """线性光(0~1) -> sRGB 单通道(0~1)。"""
+    return c * 12.92 if c <= 0.0031308 else 1.055 * (c ** (1 / 2.4)) - 0.055
+
+
+def relative_luminance(color: QColor) -> float:
+    """计算 QColor 的 WCAG 相对亮度(0~1)。
+
+    公式: L = 0.2126*R_lin + 0.7152*G_lin + 0.0722*B_lin。
+    """
+    r, g, b, _ = color.getRgb()
+    return (
+        0.2126 * _srgb_to_linear(r / 255.0)
+        + 0.7152 * _srgb_to_linear(g / 255.0)
+        + 0.0722 * _srgb_to_linear(b / 255.0)
+    )
+
+
+def color_at_relative_luminance(color: QColor, target_lum: float) -> QColor:
+    """把 ``color`` 调整到 WCAG 相对亮度 ``target_lum``, 尽量保留色相与饱和度。
+
+    做法:
+      1. 把 sRGB 三通道转到线性光;
+      2. 以 0 为中心均匀缩放三个线性通道(保持 RGB 比例 => 保留色相),
+         使相对亮度逼近目标;
+      3. 因 G 通道权重最大, 缩放后做少量二分微调(仅调 G 线性分量)收敛误差。
+
+    Args:
+        color: 原始颜色(QColor)。
+        target_lum: 目标相对亮度(0~1)。
+
+    Returns:
+        调整后的 QColor(已 clamp 到合法范围)。输入为纯黑时回退到
+        与目标亮度等价的灰度。
+    """
+    target_lum = max(0.0, min(1.0, float(target_lum)))
+    r, g, b, a = color.getRgb()
+    rl, gl, bl = _srgb_to_linear(r / 255.0), _srgb_to_linear(g / 255.0), _srgb_to_linear(b / 255.0)
+
+    cur_lum = 0.2126 * rl + 0.7152 * gl + 0.0722 * bl
+    if cur_lum <= 1e-9:
+        # 纯黑无方向信息: 回退为与目标亮度等价的灰度
+        grey_lin = target_lum  # 灰度三通道相等 => rel_lum = (0.2126+0.7152+0.0722)*g = g
+        gs = _linear_to_srgb(grey_lin)
+        v = int(round(max(0.0, min(1.0, gs)) * 255.0))
+        return QColor(v, v, v, a)
+
+    # 1) 均匀缩放线性通道(保留色相)
+    scale = target_lum / cur_lum
+    rl2, gl2, bl2 = rl * scale, gl * scale, bl * scale
+    # clamp 线性分量到 [0,1] (sRGB 上限)
+    rl2, gl2, bl2 = (max(0.0, min(1.0, c)) for c in (rl2, gl2, bl2))
+
+    # 2) 二分微调: 仅调 G(权重最大), 收敛到 target_lum
+    def lum_of(rg, gg, bg):
+        return 0.2126 * rg + 0.7152 * gg + 0.0722 * bg
+
+    lo, hi = 0.0, 1.0
+    for _ in range(24):
+        mid = (lo + hi) / 2.0
+        if lum_of(rl2, mid, bl2) < target_lum:
+            lo = mid
+        else:
+            hi = mid
+    gl2 = (lo + hi) / 2.0
+
+    rs = _linear_to_srgb(rl2)
+    gs = _linear_to_srgb(gl2)
+    bs = _linear_to_srgb(bl2)
+    ri = int(round(max(0.0, min(1.0, rs)) * 255.0))
+    gi = int(round(max(0.0, min(1.0, gs)) * 255.0))
+    bi = int(round(max(0.0, min(1.0, bs)) * 255.0))
+    return QColor(ri, gi, bi, a)
+
+
+def neutral_grey_at_relative_luminance(target_lum: float, alpha: int = 255) -> QColor:
+    """返回与目标相对亮度等价的中性灰(R=G=B)。
+
+    灰度三通道相等时, 相对亮度 = (0.2126+0.7152+0.0722)*g = g, 故直接取 g=target_lum。
+    """
+    g = max(0.0, min(1.0, float(target_lum)))
+    gs = _linear_to_srgb(g)
+    v = int(round(max(0.0, min(1.0, gs)) * 255.0))
+    return QColor(v, v, v, alpha)