chartflow 0.1.2__tar.gz → 0.1.5__tar.gz

{chartflow-0.1.2 → chartflow-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartflow
-Version: 0.1.2
+Version: 0.1.5
 Summary: Self-use. with fsm. node. chart. edit. Used for fsm and run, structure graph. use pyqt to show and interact
 Author-email: 2229066748@qq.com
 Maintainer: Eagle'sBaby

{chartflow-0.1.2 → chartflow-0.1.5}/chartflow/flow/chart.py

@@ -958,7 +958,8 @@ class Chart(IChart):
         shape_map = {
             "ellipse": NodeShape.ELLIPSE,
             "rectangle": NodeShape.RECTANGLE,
-            "diamond": NodeShape.DIAMOND
+            "diamond": NodeShape.DIAMOND,
+            "hexagon": NodeShape.HEXAGON
         }
 
         # Create node mapping

{chartflow-0.1.2 → chartflow-0.1.5}/chartflow/node/__init__.py

@@ -19,12 +19,16 @@ from chartflow.node.node_item import QNodeItem
 from chartflow.node.port_item import QNodePort, QNodePortSpec
 from chartflow.node._port_interface import IQNodePort
 from chartflow.node.connection_item import ConnectionItem
+from chartflow.node._connection_interface import IConnectionItem, IQConnectionEditor
 from chartflow.node.arrow_item import ArrowItem
 from chartflow.node.selection_rect import SelectionRect
 from chartflow.node.style_panel import StylePanel
 from chartflow.node.node_canvas import QNodeCanvas
 from chartflow.node.main_window import NodeCanvasWindow
 from chartflow.node.qnode_editor import QNodeEditor
+from chartflow.node.qconnection_editor import (
+    QConnectionEditor, QConnectionNameEditor, openConnectionEditor,
+)
 from chartflow.node.popmenu import (
     ICanvasPopMenu, QCanvasPopMenu,
     INodePopMenu, QNodePopMenu,
@@ -50,6 +54,7 @@ __all__ = [
     "QNodePortSpec",
     "IQNodePort",
     "ConnectionItem",
+    "IConnectionItem",
     "ArrowItem",
     "SelectionRect",
     # UI Components
@@ -59,6 +64,10 @@ __all__ = [
     "NodeCanvasWindow",
     # Editor
     "QNodeEditor",
+    "QConnectionEditor",
+    "QConnectionNameEditor",
+    "IQConnectionEditor",
+    "openConnectionEditor",
     # Pop Menus
     "ICanvasPopMenu", "QCanvasPopMenu",
     "INodePopMenu", "QNodePopMenu",

chartflow-0.1.5/chartflow/node/_connection_interface.py

@@ -0,0 +1,196 @@
+"""
+连接项接口契约模块
+
+定义 IConnectionItem(Protocol) 与 IQConnectionEditor(Protocol) ——
+连接项(连线)及其编辑器的对外类型契约。
+
+Protocol 仅用于静态类型检查与文档, 不参与运行时继承(不进入 MRO),
+因此可安全地与 QGraphicsPathItem / QWidget 继承体系并存。
+
+IConnectionItem 声明了 ConnectionItem 对外暴露的名称/数据/编辑器/
+信号/序列化接口; IQConnectionEditor 声明了连线编辑器(见
+qconnection_editor.QConnectionEditor)的对外接口, 与节点编辑器
+QNodeEditor 的接口形态保持一致。
+
+约定: 本模块只含类型声明, 不得有运行时依赖, 以避免循环导入。
+"""
+
+from typing import Any, Dict, Optional, Protocol, runtime_checkable
+
+from PyQt6.QtCore import QPointF, pyqtSignal
+
+
+@runtime_checkable
+class IConnectionItem(Protocol):
+    """连接项接口契约
+
+    声明一条连线(ConnectionItem)在 名称 / 编辑器 / 序列化 方面应具备的
+    对外属性与方法。几何/样式/箭头/端口锚定等既有接口不在此重复声明。
+
+    契约分组:
+
+    - **名称与数据**: ``name`` / ``data``
+    - **编辑器**: ``editorClass`` / ``editorEmbedded`` / ``isEditWindowOpen`` /
+      :meth:`setEditWindowOpen` / :meth:`closeEditor`
+    - **几何**: ``center``(连线中点, 编辑器/名称 label 的锚点)
+    - **信号**: ``editRequested`` / ``nameChanged``
+    - **序列化**: :meth:`toDict` / :meth:`fromDict`
+
+    所有坐标默认为 **场景坐标(scene coordinate)**, 几何单位为像素。
+    """
+
+    # ---- 名称与数据 ----
+    @property
+    def name(self) -> str:
+        """连线名称(可读写)。
+
+        读取返回当前名称(可为空串); 赋值会更新连线中点的名称 label
+        (空串时隐藏)并发出 :attr:`nameChanged` 信号。名称会被
+        :meth:`toDict` / :meth:`fromDict` 序列化。
+        """
+        ...
+
+    @name.setter
+    def name(self, value: str) -> None: ...
+
+    @property
+    def data(self) -> Dict[str, Any]:
+        """连线自定义数据字典(只读引用, 内容可改)。
+
+        返回内部 ``_data`` 字典本身而非副本, 调用方可直接增删键值,
+        供自定义编辑器(如保存备注/参数)持久化内容使用。
+        会被 :meth:`toDict` / :meth:`fromDict` 序列化。
+        """
+        ...
+
+    # ---- 编辑器 ----
+    @property
+    def editorClass(self) -> Optional[type]:
+        """连线编辑器类(可读写)。
+
+        设为某个 ``QWidget`` 子类 ``type`` 时, 双击连线(或右键菜单
+        Edit Connection)会通过 :attr:`editRequested` 信号请求由该类创建
+        编辑面板; ``None`` 表示使用内置默认名称编辑器
+        (:class:`~chartflow.node.qconnection_editor.QConnectionNameEditor`)。
+        编辑器类本身不可序列化(与节点 editorClass 一致)。
+        """
+        ...
+
+    @editorClass.setter
+    def editorClass(self, value: Optional[type]) -> None: ...
+
+    @property
+    def editorEmbedded(self) -> bool:
+        """编辑器是否嵌入连线中点(可读写, 默认 ``True``)。
+
+        - ``True``: 编辑器经 ``QGraphicsProxyWidget`` 嵌入连线中点, 随连线
+          路径更新自动跟随;
+        - ``False``: 编辑器作为独立浮动窗口打开(与节点编辑器一致)。
+
+        该状态会被 :meth:`toDict` / :meth:`fromDict` 序列化(仅在
+        ``False`` 时落盘, 避免污染默认导出)。
+        """
+        ...
+
+    @editorEmbedded.setter
+    def editorEmbedded(self, value: bool) -> None: ...
+
+    @property
+    def isEditWindowOpen(self) -> bool:
+        """当前是否有编辑器窗口/嵌入面板打开(只读)。"""
+        ...
+
+    def setEditWindowOpen(self, open: bool) -> None:
+        """切换编辑窗口打开状态, 进而控制中点名称 label 的高亮提示。
+
+        由编辑器(如 :class:`QConnectionEditor`)在 show/close 时自动驱动;
+        打开时名称 label 显示高亮底衬(类比节点的 📖 悬浮标记)。
+
+        Args:
+            open: ``True`` 表示编辑器已打开, ``False`` 已关闭。
+        """
+        ...
+
+    def closeEditor(self) -> None:
+        """关闭当前打开的编辑器并清理嵌入代理(无打开编辑器时为空操作)。
+
+        画布在删除连线(:meth:`NodeCanvas.removeConnection`)时调用,
+        防止编辑器窗口/嵌入代理悬挂。
+        """
+        ...
+
+    # ---- 几何 ----
+    @property
+    def center(self) -> QPointF:
+        """连线中点的 **场景坐标**(只读), 取自 ``path().pointAtPercent(0.5)``。
+
+        作为名称 label 与嵌入编辑器的锚点; 自环连线同样按路径 50% 处取值。
+        """
+        ...
+
+    # ---- 信号(只读属性, 返回 pyqtSignal) ----
+    @property
+    def editRequested(self) -> pyqtSignal:
+        """编辑请求信号(只读)。
+
+        双击连线或点击右键菜单 Edit Connection 时发射, 载荷为本连线实例;
+        画布默认连接到打开编辑器的处理器(无 editorClass 时打开内置名称
+        编辑器), 宿主可自行断开/接管。
+        """
+        ...
+
+    @property
+    def nameChanged(self) -> pyqtSignal:
+        """名称变更信号(只读)。名称被修改时发射, 载荷为 (连线, 新名称)。"""
+        ...
+
+    # ---- 序列化 ----
+    def toDict(self) -> dict:
+        """将连线的 名称/数据/编辑器布局 序列化为字典。
+
+        仅包含非默认键: ``name``(非空) / ``data``(非空) /
+        ``editor_embedded``(仅 ``False``)。拓扑(source/target/port)与样式
+        由画布 export 与 styleToDict 负责, 不在此重复。
+
+        Returns:
+            连线数据字典(深拷贝, 修改返回值不影响连线)。
+        """
+        ...
+
+    def fromDict(self, data: dict) -> None:
+        """从字典恢复连线的 名称/数据/编辑器布局(增量合并, 忽略未知键)。
+
+        Args:
+            data: 由 :meth:`toDict` 产生(或同构)的字典。
+        """
+        ...
+
+
+@runtime_checkable
+class IQConnectionEditor(Protocol):
+    """连线编辑器接口契约
+
+    声明连线编辑器应具备的对外接口, 与节点编辑器
+    :class:`~chartflow.node.qnode_editor.QNodeEditor` 形态保持一致:
+    构造时传入被编辑对象, 提供 ``getTitle`` / ``save`` / ``load``。
+
+    具体实现由 :class:`~chartflow.node.qconnection_editor.QConnectionEditor`
+    承担; 用户自定义编辑器继承该类(或满足本契约)即可。
+    """
+
+    @property
+    def connection(self) -> IConnectionItem:
+        """获取当前编辑的连线(只读)。"""
+        ...
+
+    def getTitle(self) -> str:
+        """获取编辑器窗口标题(嵌入模式下一般不可见)。"""
+        ...
+
+    def save(self) -> bool:
+        """保存编辑器内容到连线。返回是否成功。"""
+        ...
+
+    def load(self) -> bool:
+        """从连线加载内容到编辑器。返回是否成功。"""
+        ...

{chartflow-0.1.2 → chartflow-0.1.5}/chartflow/node/_node_base.py

@@ -398,7 +398,10 @@ class _NodeCore(QGraphicsEllipseItem):
 
         - 名称需容纳在内部区域(INNER_RATIO 以内); 有 hit 时额外预留
           (dot 深度 + 间距 + hit 文本宽度), 避免 hit 与名称重叠。
-        - 矩形且有端口时: 宽度由名称(+hit)决定, 高度由最多端口的一侧决定(可长宽不等)。
+        - 矩形且有端口时: 宽度由名称(+hit)决定, 高度由最多端口的一侧决定
+          (可长宽不等, 但宽不短于高——顶/底边不短于左右边)。
+        - 六边形: 平顶/平底边长(=rw)须不短于斜边长 hypot(rw/2, rh),
+          即 rw >= rh * 2/√3, 按此加宽(名称短时正方形不满足该约束)。
         - 其余(椭圆/菱形/无端口矩形): 保持方形。
         """
         tw, th = self._nameTextSize()
@@ -411,6 +414,8 @@ class _NodeCore(QGraphicsEllipseItem):
             port_extent = self._portInwardExtent()
             rw = max(rw_name, name_half + port_extent + NAME_INNER_PAD, self._min_radius)
             rh = max(rh_name, self._halfHeightForPorts(rw), self._min_radius)
+            # 矩形: 顶/底边(宽)不短于左右边(高); 名称短/端口多导致超高时加宽
+            rw = max(rw, rh)
             return rw, rh
 
         # 方形
@@ -421,6 +426,10 @@ class _NodeCore(QGraphicsEllipseItem):
                 R = max(R, self._circlePortRadius())
             else:
                 R = max(R, self._halfHeightForPorts(R))
+        if self._shape == NodeShape.HEXAGON:
+            # 六边形: 顶/底边 >= 斜边 -> rw >= rh * 2/√3; 加宽而非压扁,
+            # 以保留端口/名称的纵向空间
+            return R * 2.0 / math.sqrt(3.0), R
         return R, R
 
     def _setSize(self, rw: float, rh: float) -> None:
@@ -429,6 +438,12 @@ class _NodeCore(QGraphicsEllipseItem):
             # 圆形节点固定为标准圆(宽高相等), 保证端口沿弧线布局正确
             side = max(rw, rh)
             rw = rh = side
+        elif self._shape == NodeShape.HEXAGON:
+            # 六边形: 顶/底边 >= 斜边 -> rw >= rh * 2/√3(兜底, 含自定义半径路径)
+            rw = max(rw, rh * 2.0 / math.sqrt(3.0))
+        elif self._shape == NodeShape.RECTANGLE:
+            # 矩形: 顶/底边(宽)不短于左右边(高)(兜底)
+            rw = max(rw, rh)
         self._rw = rw
         self._rh = rh
         self._radius = rw  # 兼容椭圆/菱形及旧代码
@@ -475,6 +490,7 @@ class _NodeCore(QGraphicsEllipseItem):
           - ELLIPSE: 圆(半径 + 外环)
           - RECTANGLE: 圆角矩形(外扩外环)
           - DIAMOND: 菱形(四顶点外扩外环)
+          - HEXAGON: 六边形(六顶点外扩外环)
         """
         rect = self.rect()
         m = self._hitShapeMargin()
@@ -488,7 +504,7 @@ class _NodeCore(QGraphicsEllipseItem):
             # 圆角半径与 paint() 一致(基于原始 rect, 否则圆角位置错位)
             corner = min(rect.width(), rect.height()) * 0.2
             path.addRoundedRect(outer, corner, corner)
-        else:  # DIAMOND
+        elif self._shape == NodeShape.DIAMOND:
             c = rect.center()
             hw = rect.width() / 2.0 + m
             hh = rect.height() / 2.0 + m
@@ -497,6 +513,17 @@ class _NodeCore(QGraphicsEllipseItem):
             path.lineTo(c.x(), c.y() + hh)
             path.lineTo(c.x() - hw, c.y())
             path.closeSubpath()
+        else:  # HEXAGON
+            c = rect.center()
+            hw = rect.width() / 2.0 + m
+            hh = rect.height() / 2.0 + m
+            path.moveTo(c.x() - hw / 2.0, c.y() - hh)
+            path.lineTo(c.x() + hw / 2.0, c.y() - hh)
+            path.lineTo(c.x() + hw, c.y())
+            path.lineTo(c.x() + hw / 2.0, c.y() + hh)
+            path.lineTo(c.x() - hw / 2.0, c.y() + hh)
+            path.lineTo(c.x() - hw, c.y())
+            path.closeSubpath()
         return path
 
     def _centerText(self) -> None:

{chartflow-0.1.2 → chartflow-0.1.5}/chartflow/node/_node_interface.py

@@ -78,6 +78,7 @@ class INodeItem(Protocol):
         - ``ELLIPSE`` 椭圆/圆形(强制为宽高相等的标准圆)
         - ``RECTANGLE`` 圆角矩形
         - ``DIAMOND`` 菱形
+        - ``HEXAGON`` 六边形(平顶/平底, 左右尖角)
 
         赋值后若未设置自定义半径, 会按新形状重算尺寸; 切换到圆形时
         端口会从轴向排布切换为沿侧弧径向排布。
@@ -396,7 +397,8 @@ class INodeItem(Protocol):
         """计算从节点中心指向 ``target_pos`` 方向、落在节点外轮廓上的交点。
 
         依据当前 :attr:`nodeShape` 采用不同算法: 圆形用三角函数、
-        圆角矩形先求外接矩形交点再修正圆角、菱形用 L1 范数缩放。
+        圆角矩形先求外接矩形交点再修正圆角、菱形用 L1 范数缩放、
+        六边形取平顶边与斜边两组约束的较小射线交点。
 
         Args:
             target_pos: 目标位置(场景坐标)。

{chartflow-0.1.2 → chartflow-0.1.5}/chartflow/node/_node_ports.py

@@ -56,6 +56,11 @@ class _NodePortMixin:
         self._port_label_timer.setSingleShot(True)
         self._port_label_timer.setInterval(PORT_LABEL_HOVER_DELAY_MS)
         self._port_label_timer.timeout.connect(self._showAllPortLabels)
+        # label 钉住态(始终可见)与闪现计时器(flashPortLabels 用)
+        self._port_labels_pinned: bool = False
+        self._port_flash_timer: QTimer = QTimer()
+        self._port_flash_timer.setSingleShot(True)
+        self._port_flash_timer.timeout.connect(self._unflashPortLabels)
 
     # ------------------------------------------------------------------ #
     # ports 属性
@@ -126,6 +131,50 @@ class _NodePortMixin:
             result[key] = ports
         return result
 
+    # ------------------------------------------------------------------ #
+    # 端口 label 显隐(钉住 / 闪现)
+    # ------------------------------------------------------------------ #
+    @property
+    def portLabelsVisible(self) -> bool:
+        """端口 label 是否始终可见(读写)。
+
+        True 时全部端口 label 钉住常显(优先于 hover 规则); False 时交还
+        hover 规则(节点 hover>0.5s 显示全部 / hover 单个 dot 显示该条)。
+        对重建端口(ports 重赋值)后新建的端口项同样生效。
+        """
+        return self._port_labels_pinned
+
+    @portLabelsVisible.setter
+    def portLabelsVisible(self, on: bool) -> None:
+        self._port_labels_pinned = bool(on)
+        self._setAllPortsLabelPinned(on)
+
+    def _setAllPortsLabelPinned(self, on: bool) -> None:
+        for side in ("left", "right"):
+            for item in self._port_items[side]:
+                item.setLabelPinned(on)
+
+    def flashPortLabels(self, continue_time: int = 1500) -> None:
+        """模拟弹出全部端口 label 并持续 ``continue_time`` 毫秒, 到期自动收回。
+
+        重复调用会重新计时。与 hover 规则正交: 闪现收回后 label 回到
+        hover/钉住所决定的可见态。continue_time <= 0 时立即收回。
+        """
+        for side in ("left", "right"):
+            for item in self._port_items[side]:
+                item.setLabelFlashed(True)
+        if continue_time <= 0:
+            self._unflashPortLabels()
+            return
+        self._port_flash_timer.start(max(0, int(continue_time)))
+
+    def _unflashPortLabels(self) -> None:
+        """闪现到期: 解除全部端口的闪现态(label 回到 hover/钉住规则)。"""
+        self._port_flash_timer.stop()
+        for side in ("left", "right"):
+            for item in self._port_items[side]:
+                item.setLabelFlashed(False)
+
     # ------------------------------------------------------------------ #
     # 端口渲染项构建/移除
     # ------------------------------------------------------------------ #
@@ -142,6 +191,7 @@ class _NodePortMixin:
         for side in ("left", "right"):
             for spec in self._ports_spec.get(side, []):
                 item = QNodePort(spec, side, self)
+                item.setLabelPinned(self._port_labels_pinned)  # 继承钉住态
                 self._port_items[side].append(item)
         self._layoutPorts()
 
@@ -163,21 +213,22 @@ class _NodePortMixin:
     # 端口布局
     # ------------------------------------------------------------------ #
     def _layoutPorts(self) -> None:
-        """分布端口: 圆形沿侧弧径向; 菱形沿左/右斜边贴合排布; 矩形沿边缘轴向。"""
+        """分布端口: 圆形沿侧弧径向; 菱形/六边形沿左/右斜边贴合排布; 矩形沿边缘轴向。"""
         is_circle = self._shape == NodeShape.ELLIPSE
-        is_diamond = self._shape == NodeShape.DIAMOND
+        # 菱形与六边形(左右均为两条斜边)共用斜边贴合布局
+        is_slant = self._shape in (NodeShape.DIAMOND, NodeShape.HEXAGON)
         for side in ("left", "right"):
             for it in self._port_items[side]:
-                # 互斥的排布模式: _radial(圆形) / _diamond(菱形) / 皆 False(矩形)
+                # 互斥的排布模式: _radial(圆形) / _diamond(斜边) / 皆 False(矩形)
                 if it._radial != is_circle:
                     it._radial = is_circle
                     it.update()
-                if it._diamond != is_diamond:
-                    it._diamond = is_diamond
+                if it._diamond != is_slant:
+                    it._diamond = is_slant
                     it.update()
         if is_circle:
             self._layoutPortsOnCircle()
-        elif is_diamond:
+        elif is_slant:
             self._layoutPortsOnDiamond()
         else:
             self._layoutPortsAxisAligned()
@@ -227,16 +278,29 @@ class _NodePortMixin:
                 it.setPos(QPointF(x, y))
                 it.update()
 
+    def _slantInsetX(self) -> float:
+        """斜边上端点(顶/底侧)相对中心 x 的内缩量。
+
+        菱形: 0(斜边直达中线上的顶/底尖角);
+        六边形: half_w / 2(斜边从侧尖角连到平顶/平底边的端点)。
+        """
+        if self._shape == NodeShape.HEXAGON:
+            return self.rect().width() / 4.0
+        return 0.0
+
     def _layoutPortsOnDiamond(self) -> None:
-        """菱形: 端口沿左/右两条斜边贴合排布, dot 旋转使底边贴合斜边、
+        """菱形/六边形: 端口沿左/右两条斜边贴合排布, dot 旋转使底边贴合斜边、
         apex 沿斜边内法线(指向节点内部), 出射方向沿斜边外法线。
 
         每侧(right/left)对应两条斜边(上、下), 总弧长 2L(L=单条斜边长)。
         端口沿弧长以 PORT_MIN_GAP 紧凑排布, 整组围绕侧顶点(右顶点/左顶点,
         即赤道)居中。**所有四个顶点(top/side/bottom 及对侧顶点)附近都预留
-        顶点间隙**, 故端口自然落在斜边中段, 不压在任何菱角上。
+        顶点间隙**, 故端口自然落在斜边中段, 不压在任何尖角上。
+
+        斜边端点由 _slantInsetX() 参数化: 菱形斜边连到中线的顶/底尖角,
+        六边形斜边连到平顶/平底边的端点(x=±hw/2), 布局算法完全一致。
 
-        注意: 菱形斜边的内法线是**该斜边的常量法线**(垂直于斜边), 而非"指向
+        注意: 斜边的内法线是**该斜边的常量法线**(垂直于斜边), 而非"指向
         圆心"的方向 —— 二者仅在斜边中点重合。dot 底边须平行于斜边, 故
         _orient_angle 必须取斜边内法线方向(使旋转后底边贴合斜边)。
         """
@@ -246,20 +310,22 @@ class _NodePortMixin:
         hh = rect.height() / 2.0
         if hw <= 0 or hh <= 0:
             return
-        L = math.hypot(hw, hh)  # 单条斜边长
-        # 斜边内法线(指向节点内部, 垂直于斜边)。菱形四条斜边, 内法线方向固定。
-        #   右上(TR: top->right) 斜边方向 (hw, hh), 内法线 (-hh, hw)
-        #   右下(RB: right->bottom) 方向 (-hw, hh), 内法线 (-hh, -hw)
-        #   左下(BL: bottom->left) 方向 (-hw, -hh), 内法线 (hh, -hw)
-        #   左上(LT: left->top) 方向 (hw, -hh), 内法线 (hh, hw)
+        kx = self._slantInsetX()
+        sw = hw - kx  # 斜边的水平跨度(菱形=hw, 六边形=hw/2)
+        L = math.hypot(sw, hh)  # 单条斜边长
+        # 斜边内法线(指向节点内部, 垂直于斜边)。四条斜边, 内法线方向固定。
+        #   右上(TR: top->right) 斜边方向 (sw, hh), 内法线 (-hh, sw)
+        #   右下(RB: right->bottom) 方向 (-sw, hh), 内法线 (-hh, -sw)
+        #   左下(BL: bottom->left) 方向 (-sw, -hh), 内法线 (hh, -sw)
+        #   左上(LT: left->top) 方向 (sw, -hh), 内法线 (hh, sw)
         def inward_normal(ix, iy):
             nl = math.hypot(ix, iy)
             return (ix / nl, iy / nl) if nl > 1e-6 else (0.0, 0.0)
 
-        NORM_TR = inward_normal(-hh, hw)   # 右上斜边内法线
-        NORM_RB = inward_normal(-hh, -hw)  # 右下斜边内法线
-        NORM_BL = inward_normal(hh, -hw)   # 左下斜边内法线
-        NORM_LT = inward_normal(hh, hw)    # 左上斜边内法线
+        NORM_TR = inward_normal(-hh, sw)   # 右上斜边内法线
+        NORM_RB = inward_normal(-hh, -sw)  # 右下斜边内法线
+        NORM_BL = inward_normal(hh, -sw)   # 左下斜边内法线
+        NORM_LT = inward_normal(hh, sw)    # 左上斜边内法线
 
         # 四个顶点处的弧长预留(像素, 沿弧长方向): 避免端口压在任何菱角上。
         # top/bottom 顶点处一条斜边交汇, side 顶点处两条斜边交汇, 均需避让。
@@ -316,30 +382,31 @@ class _NodePortMixin:
                 s_values.append(L + vertex_gap + off_c)        # 下半中段内
             for it, s in zip(items, s_values):
                 # s ∈ [0, 2L]; 上半斜边 s∈[0,L](top→侧顶点), 下半 s∈[L,2L](侧顶点→bottom)
+                # 斜边端点: 侧尖角(±hw,0) <-> 顶/底端点(±kx,∓hh); kx=0 即菱形
                 if side == "right":
                     if s <= L:
-                        # 上半(TR): top(0,-hh) -> right(+hw,0), t=s/L
+                        # 上半(TR): (kx,-hh) -> right(+hw,0), t=s/L
                         t = max(0.0, min(1.0, s / L))
-                        px = cx + hw * t
+                        px = cx + kx + sw * t
                         py = cy + (-hh) + hh * t
                         nx, ny = NORM_TR
                     else:
-                        # 下半(RB): right(+hw,0) -> bottom(0,+hh), t=(s-L)/L
+                        # 下半(RB): right(+hw,0) -> (kx,+hh), t=(s-L)/L
                         t = max(0.0, min(1.0, (s - L) / L))
-                        px = cx + hw + (-hw) * t
+                        px = cx + hw - sw * t
                         py = cy + hh * t
                         nx, ny = NORM_RB
                 else:  # left
                     if s <= L:
-                        # 上半(LT): top(0,-hh) -> left(-hw,0), t=s/L
+                        # 上半(LT): (-kx,-hh) -> left(-hw,0), t=s/L
                         t = max(0.0, min(1.0, s / L))
-                        px = cx + (-hw) * t
+                        px = cx - kx - sw * t
                         py = cy + (-hh) + hh * t
                         nx, ny = NORM_LT
                     else:
-                        # 下半(BL): left(-hw,0) -> bottom(0,+hh), t=(s-L)/L
+                        # 下半(BL): left(-hw,0) -> (-kx,+hh), t=(s-L)/L
                         t = max(0.0, min(1.0, (s - L) / L))
-                        px = cx + (-hw) + hw * t
+                        px = cx - hw + sw * t
                         py = cy + hh * t
                         nx, ny = NORM_BL
                 it._orient_angle = math.degrees(math.atan2(ny, nx))
@@ -347,15 +414,15 @@ class _NodePortMixin:
                 it.update()
 
     def _diamondSideBias(self) -> float:
-        """菱形每条斜边上端口组的"逻辑中点"参数(0=远端顶点, 1=侧顶点)。
+        """菱形/六边形每条斜边上端口组的"逻辑中点"参数(0=远端顶点, 1=侧顶点)。
 
         取 0.7: 端口组偏向侧顶点(左右两角), 体现"左右两侧"的视觉聚类,
-        同时仍处于斜边中段(避开顶点预留区), 不会压在任何菱角上。
+        同时仍处于斜边中段(避开顶点预留区), 不会压在任何尖角上。
         """
         return 0.7
 
     def _diamondVertexGap(self) -> float:
-        """菱形每个顶点处沿弧长预留的间隙(像素)。
+        """菱形/六边形每个顶点处沿弧长预留的间隙(像素)。
 
         四个顶点(top/底/左/右)处斜边交汇, 法线方向不连续, 端口压在顶点上
         视觉突兀。预留固定像素间隙使端口落在斜边中段。取 10px: 对常见尺寸
@@ -372,6 +439,8 @@ class _NodePortMixin:
             return corner + 4.0
         if self._shape == NodeShape.DIAMOND:
             return half_h * 0.30
+        if self._shape == NodeShape.HEXAGON:
+            return half_h * 0.25
         # ELLIPSE
         return half_h * 0.22