PyClickerRPA 0.1.0__py3-none-any.whl

autoclicker/gui/flow_editor.py

@@ -0,0 +1,340 @@
+"""Node-based visual flow editor — port of floweditor.cpp.
+
+A QGraphicsView of FlowNodes connected by FlowConnections. Converts to/from the
+linear Task: buildTask() does a BFS from the start node and turns back-edges
+(with a repeat count) into Loop steps; loadTask() lays steps out vertically and
+recreates loop/do-until back-edges.
+"""
+from __future__ import annotations
+
+from collections import deque
+
+from PySide6.QtCore import QLineF, Qt, Signal
+from PySide6.QtGui import QColor, QPainter, QPen
+from PySide6.QtWidgets import (
+    QDialog, QGraphicsScene, QGraphicsView, QInputDialog, QMenu,
+)
+
+from autoclicker.models import Step, StepType, Task
+from autoclicker.gui.flow_node import FlowNode, FlowPort
+from autoclicker.gui.flow_connection import FlowConnection
+
+# Context-menu "add node" grouping (label, StepType)
+_ADD_MENU = {
+    "点击": [("找图点击", StepType.ClickImage), ("找字点击", StepType.ClickText),
+             ("坐标点击", StepType.ClickPosition), ("长按", StepType.LongPress)],
+    "输入": [("按键", StepType.KeyPress), ("输入文字", StepType.TypeText), ("快捷键", StepType.Hotkey)],
+    "手势": [("拖拽", StepType.Drag), ("捏合", StepType.Pinch), ("滚轮", StepType.Scroll)],
+    "流程": [("等待", StepType.Wait), ("随机等待", StepType.RandomWait),
+             ("等待图片出现", StepType.WaitImage), ("等待图片消失", StepType.WaitImageGone),
+             ("条件(图片)", StepType.IfImageFound), ("条件(文字)", StepType.IfTextFound),
+             ("条件(颜色)", StepType.IfColorMatch), ("调用子任务", StepType.CallSub),
+             ("设置变量", StepType.SetVar), ("循环直到", StepType.DoUntil)],
+}
+
+
+class FlowEditor(QGraphicsView):
+    taskChanged = Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._scene = QGraphicsScene(self)
+        self._scene.setSceneRect(-2000, -2000, 4000, 4000)
+        self.setScene(self._scene)
+        self.setRenderHint(QPainter.Antialiasing)
+        self.setDragMode(QGraphicsView.NoDrag)
+        self.setBackgroundBrush(QColor(30, 30, 30))
+        self.setMinimumSize(400, 300)
+
+        grid = QPen(QColor(50, 50, 50), 1)
+        for x in range(-2000, 2001, 50):
+            self._scene.addLine(x, -2000, x, 2000, grid)
+        for y in range(-2000, 2001, 50):
+            self._scene.addLine(-2000, y, 2000, y, grid)
+
+        self.nodes: list[FlowNode] = []
+        self.connections: list[FlowConnection] = []
+        self._dragging = False
+        self._drag_start_port: FlowPort | None = None
+        self._drag_line = None
+        self._panning = False
+        self._pan_start = None
+
+    # ---- graph ops ----
+    def add_node(self, step: Step, pos) -> FlowNode:
+        node = FlowNode(step)
+        node.setPos(pos)
+        self._scene.addItem(node)
+        self.nodes.append(node)
+        self.taskChanged.emit()
+        return node
+
+    def connect_nodes(self, from_port: FlowPort, to_port: FlowPort):
+        for conn in from_port.connections:
+            if conn.to_port is to_port:
+                return None
+        conn = FlowConnection(from_port, to_port)
+        self._scene.addItem(conn)
+        self.connections.append(conn)
+        self.taskChanged.emit()
+        return conn
+
+    def clear(self):
+        for conn in self.connections:
+            conn.detach()
+            self._scene.removeItem(conn)
+        self.connections.clear()
+        for node in self.nodes:
+            self._scene.removeItem(node)
+        self.nodes.clear()
+
+    # ---- mouse ----
+    def mousePressEvent(self, event):
+        if event.button() == Qt.MiddleButton:
+            self._panning = True
+            self._pan_start = event.position().toPoint()
+            self.setCursor(Qt.ClosedHandCursor)
+            return
+        if event.button() == Qt.LeftButton:
+            item = self.itemAt(event.position().toPoint())
+            if isinstance(item, FlowPort) and item.port_type == FlowPort.OUTPUT:
+                self._dragging = True
+                self._drag_start_port = item
+                start = item.center_scene_pos()
+                self._drag_line = self._scene.addLine(QLineF(start, start), QPen(Qt.white, 2, Qt.DashLine))
+                return
+        super().mousePressEvent(event)
+
+    def mouseMoveEvent(self, event):
+        if self._panning:
+            delta = event.position().toPoint() - self._pan_start
+            self._pan_start = event.position().toPoint()
+            self.horizontalScrollBar().setValue(self.horizontalScrollBar().value() - delta.x())
+            self.verticalScrollBar().setValue(self.verticalScrollBar().value() - delta.y())
+            return
+        if self._dragging and self._drag_line:
+            start = self._drag_start_port.center_scene_pos()
+            end = self.mapToScene(event.position().toPoint())
+            self._drag_line.setLine(QLineF(start, end))
+            return
+        super().mouseMoveEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        if self._panning:
+            self._panning = False
+            self.setCursor(Qt.ArrowCursor)
+            return
+        if self._dragging:
+            self._dragging = False
+            if self._drag_line:
+                self._scene.removeItem(self._drag_line)
+                self._drag_line = None
+            item = self.itemAt(event.position().toPoint())
+            if isinstance(item, FlowPort) and item.port_type == FlowPort.INPUT and item is not self._drag_start_port:
+                conn = self.connect_nodes(self._drag_start_port, item)
+                if conn:
+                    from_node = self._drag_start_port.parentItem()
+                    to_node = item.parentItem()
+                    if to_node.pos().y() < from_node.pos().y():  # back-edge
+                        count, ok = QInputDialog.getInt(self, "循环次数", "重复次数 (-1 = 无限):", -1, -1, 99999, 1)
+                        if ok:
+                            conn.set_repeat_count(count)
+            self._drag_start_port = None
+            return
+        super().mouseReleaseEvent(event)
+
+    def mouseDoubleClickEvent(self, event):
+        node = self._node_at(event.position().toPoint())
+        if node:
+            self._edit_node(node)
+            return
+        super().mouseDoubleClickEvent(event)
+
+    def wheelEvent(self, event):
+        factor = 1.15 if event.angleDelta().y() > 0 else 1 / 1.15
+        self.scale(factor, factor)
+
+    def keyPressEvent(self, event):
+        if event.key() in (Qt.Key_Delete, Qt.Key_Backspace):
+            self._delete_selected()
+            return
+        super().keyPressEvent(event)
+
+    def contextMenuEvent(self, event):
+        menu = QMenu(self)
+        scene_pos = self.mapToScene(event.pos())
+        node = self._node_at(event.pos())
+        item = self.itemAt(event.pos())
+        conn = item if isinstance(item, FlowConnection) else None
+
+        if node:
+            menu.addAction("编辑节点", lambda: self._edit_node(node))
+        if conn:
+            menu.addAction("设置重复次数", lambda: self._set_repeat(conn))
+        if node or conn:
+            menu.addAction("删除", self._delete_selected)
+            menu.addSeparator()
+
+        add_menu = menu.addMenu("添加节点")
+        for group, items in _ADD_MENU.items():
+            sub = add_menu.addMenu(group)
+            for label, st in items:
+                sub.addAction(label, lambda st=st, p=scene_pos: self.add_node(Step(type=st), p))
+        menu.exec(event.globalPos())
+
+    # ---- helpers ----
+    def _node_at(self, view_pos) -> FlowNode | None:
+        item = self.itemAt(view_pos)
+        while item is not None and not isinstance(item, FlowNode):
+            item = item.parentItem()
+        return item
+
+    def _edit_node(self, node: FlowNode):
+        from autoclicker.gui.task_widget import StepEditorDialog
+        dlg = StepEditorDialog(node.step(), self)
+        if dlg.exec() == QDialog.Accepted:
+            node.set_step(dlg.result_step())
+            self.taskChanged.emit()
+
+    def _set_repeat(self, conn: FlowConnection):
+        count, ok = QInputDialog.getInt(self, "重复次数", "执行次数 (-1 = 无限, 1 = 单次):",
+                                        conn.repeat_count, -1, 99999, 1)
+        if ok:
+            conn.set_repeat_count(count)
+            self.taskChanged.emit()
+
+    def _delete_selected(self):
+        selected = self._scene.selectedItems()
+        for item in selected:
+            if isinstance(item, FlowConnection):
+                item.detach()
+                if item in self.connections:
+                    self.connections.remove(item)
+                self._scene.removeItem(item)
+        for item in selected:
+            if isinstance(item, FlowNode):
+                to_remove = [c for c in self.connections
+                             if c.from_port.parentItem() is item or c.to_port.parentItem() is item]
+                for c in to_remove:
+                    c.detach()
+                    self.connections.remove(c)
+                    self._scene.removeItem(c)
+                if item in self.nodes:
+                    self.nodes.remove(item)
+                self._scene.removeItem(item)
+        self.taskChanged.emit()
+
+    def _find_start(self) -> FlowNode | None:
+        for node in self.nodes:
+            if not node.input_port.connections:
+                return node
+        return self.nodes[0] if self.nodes else None
+
+    # ---- graph <-> Task ----
+    def build_task(self) -> Task:
+        task = Task(name="FlowTask")
+        start = self._find_start()
+        if not start:
+            return task
+
+        order: list[FlowNode] = []
+        visited = {start}
+        queue = deque([start])
+        while queue:
+            current = queue.popleft()
+            order.append(current)
+            for conn in current.output_port.connections:
+                nxt = conn.to_port.parentItem()
+                if nxt not in visited:
+                    visited.add(nxt)
+                    queue.append(nxt)
+
+        node_index = {node: i for i, node in enumerate(order)}
+        for node in order:
+            s = node.step()
+            if s.type == StepType.DoUntil:
+                for conn in node.output_port.connections:
+                    target = conn.to_port.parentItem()
+                    ti = node_index.get(target, -1)
+                    mi = node_index.get(node, -1)
+                    if ti >= 0 and ti <= mi:
+                        s.loopTarget = ti
+                        break
+            task.steps.append(s)
+
+        # Back-edges with a repeat count become Loop steps
+        for conn in self.connections:
+            from_node = conn.from_port.parentItem()
+            to_node = conn.to_port.parentItem()
+            fi = node_index.get(from_node, -1)
+            ti = node_index.get(to_node, -1)
+            if fi >= 0 and ti >= 0 and ti <= fi and conn.repeat_count != 1:
+                loop = Step(type=StepType.Loop, loopTarget=ti, loopCount=conn.repeat_count)
+                insert_pos = fi + 1
+                task.steps.insert(insert_pos, loop)
+                for node in list(node_index):
+                    if node_index[node] >= insert_pos:
+                        node_index[node] += 1
+        return task
+
+    def load_task(self, task: Task):
+        self.clear()
+        y = 0.0
+        prev = None
+        step_to_node: dict[int, int] = {}
+        node_idx = 0
+        for i, step in enumerate(task.steps):
+            if step.type == StepType.Loop:
+                continue
+            step_to_node[i] = node_idx
+            node_idx += 1
+
+        from PySide6.QtCore import QPointF
+        for i, step in enumerate(task.steps):
+            if step.type == StepType.Loop:
+                continue
+            node = self.add_node(step, QPointF(0, y))
+            if prev is not None:
+                self.connect_nodes(prev.output_port, node.input_port)
+            prev = node
+            y += 100
+
+        for i, step in enumerate(task.steps):
+            if step.type == StepType.Loop:
+                real_from = step_to_node.get(i - 1, -1)
+                real_to = step_to_node.get(step.loopTarget, -1)
+                if 0 <= real_from < len(self.nodes) and 0 <= real_to < len(self.nodes):
+                    conn = self.connect_nodes(self.nodes[real_from].output_port, self.nodes[real_to].input_port)
+                    if conn:
+                        conn.set_repeat_count(step.loopCount)
+
+        for i, node in enumerate(self.nodes):
+            if node.step().type == StepType.DoUntil:
+                real_to = step_to_node.get(node.step().loopTarget, -1)
+                if 0 <= real_to < len(self.nodes) and real_to <= i:
+                    self.connect_nodes(node.output_port, self.nodes[real_to].input_port)
+
+    def validate_graph(self) -> tuple[bool, list[str]]:
+        if not self.nodes:
+            return False, ["流程图为空，请添加节点"]
+        start = self._find_start()
+        if not start:
+            return False, ["找不到起始节点"]
+        reachable = {start}
+        queue = deque([start])
+        while queue:
+            current = queue.popleft()
+            for conn in current.output_port.connections:
+                nxt = conn.to_port.parentItem()
+                if nxt not in reachable:
+                    reachable.add(nxt)
+                    queue.append(nxt)
+            for conn in current.input_port.connections:
+                prev = conn.from_port.parentItem()
+                if prev not in reachable:
+                    reachable.add(prev)
+                    queue.append(prev)
+        warnings = [f"  · {n.step().display_name()}" for n in self.nodes if n not in reachable]
+        if warnings:
+            warnings.insert(0, f"有 {len(warnings)} 个节点未连接到主流程:")
+        return True, warnings

autoclicker/gui/flow_node.py

@@ -0,0 +1,107 @@
+"""Flow graph node + port — port of flownode.cpp."""
+from __future__ import annotations
+
+import uuid
+
+from PySide6.QtCore import QRectF, Qt
+from PySide6.QtGui import QColor, QPen
+from PySide6.QtWidgets import QGraphicsEllipseItem, QGraphicsItem, QGraphicsTextItem
+
+from autoclicker.models import Step, StepType
+
+_COLORS = {
+    StepType.ClickImage: (66, 133, 244),
+    StepType.ClickText: (52, 168, 83),
+    StepType.ClickPosition: (251, 188, 4),
+    StepType.Wait: (100, 100, 100),
+    StepType.RandomWait: (100, 100, 100),
+    StepType.Loop: (234, 67, 53),
+    StepType.IfImageFound: (171, 71, 188),
+    StepType.IfTextFound: (171, 71, 188),
+    StepType.IfElse: (171, 71, 188),
+    StepType.CallSub: (0, 150, 136),
+    StepType.SetVar: (121, 85, 72),
+    StepType.KeyPress: (255, 112, 67),
+    StepType.TypeText: (255, 112, 67),
+    StepType.Hotkey: (255, 112, 67),
+    StepType.Drag: (255, 167, 38),
+    StepType.Pinch: (156, 39, 176),
+    StepType.WaitImage: (0, 150, 136),
+    StepType.WaitImageGone: (0, 121, 107),
+    StepType.Scroll: (158, 158, 158),
+    StepType.IfColorMatch: (233, 30, 99),
+    StepType.DoUntil: (183, 28, 28),
+}
+
+
+class FlowPort(QGraphicsEllipseItem):
+    INPUT = "input"
+    OUTPUT = "output"
+
+    def __init__(self, port_type: str, parent):
+        super().__init__(-6, -6, 12, 12, parent)
+        self.port_type = port_type
+        self.setBrush(QColor(100, 200, 100) if port_type == self.INPUT else QColor(100, 100, 200))
+        self.setPen(QPen(Qt.white, 1))
+        self.setFlag(QGraphicsItem.ItemIsSelectable, False)
+        self.setCursor(Qt.CrossCursor)
+        self.connections: list = []
+
+    def center_scene_pos(self):
+        return self.mapToScene(self.rect().center())
+
+
+class FlowNode(QGraphicsItem):
+    WIDTH = 180
+    HEIGHT = 60
+
+    def __init__(self, step: Step, parent=None):
+        super().__init__(parent)
+        self._step = step
+        self.id = uuid.uuid4().hex[:8]
+        self.setFlag(QGraphicsItem.ItemIsMovable)
+        self.setFlag(QGraphicsItem.ItemIsSelectable)
+        self.setFlag(QGraphicsItem.ItemSendsGeometryChanges)
+        self.setCursor(Qt.OpenHandCursor)
+
+        self.input_port = FlowPort(FlowPort.INPUT, self)
+        self.input_port.setPos(self.WIDTH / 2, -6)
+        self.output_port = FlowPort(FlowPort.OUTPUT, self)
+        self.output_port.setPos(self.WIDTH / 2, self.HEIGHT + 6)
+
+        self._label = QGraphicsTextItem(self)
+        self._label.setDefaultTextColor(Qt.white)
+        self._label.setTextWidth(self.WIDTH - 16)
+        self._update_label()
+
+    def step(self) -> Step:
+        return self._step
+
+    def set_step(self, step: Step):
+        self._step = step
+        self._update_label()
+        self.update()
+
+    def boundingRect(self) -> QRectF:
+        return QRectF(-2, -8, self.WIDTH + 4, self.HEIGHT + 16)
+
+    def paint(self, painter, option, widget=None):
+        color = self._color()
+        painter.setPen(QPen(Qt.yellow, 2) if self.isSelected() else QPen(color.darker(150), 1))
+        painter.setBrush(color)
+        painter.drawRoundedRect(QRectF(0, 0, self.WIDTH, self.HEIGHT), 8, 8)
+
+    def _update_label(self):
+        self._label.setPlainText(self._step.display_name())
+        self._label.setPos(8, 8)
+
+    def _color(self) -> QColor:
+        return QColor(*_COLORS.get(self._step.type, (80, 80, 80)))
+
+    def itemChange(self, change, value):
+        if change == QGraphicsItem.ItemPositionHasChanged:
+            for conn in list(self.input_port.connections):
+                conn.update_path()
+            for conn in list(self.output_port.connections):
+                conn.update_path()
+        return super().itemChange(change, value)

autoclicker/gui/hotkeys.py

@@ -0,0 +1,40 @@
+"""Global hotkeys (pynput) → Qt signals.
+
+F6 toggles run/stop; ESC is an emergency stop. Hooks are observe-only (keys
+still pass through to other apps). Signals are emitted from the listener thread
+and delivered to the GUI thread by Qt.
+"""
+from __future__ import annotations
+
+from PySide6.QtCore import QObject, Signal
+
+from pynput import keyboard
+
+
+class HotkeyManager(QObject):
+    toggleRunRequested = Signal()   # F6
+    stopRequested = Signal()        # ESC
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._gh = None
+
+    def start(self):
+        if self._gh is not None:
+            return
+        try:
+            self._gh = keyboard.GlobalHotKeys({
+                "<f6>": self.toggleRunRequested.emit,
+                "<esc>": self.stopRequested.emit,
+            })
+            self._gh.start()
+        except Exception:
+            self._gh = None
+
+    def stop(self):
+        if self._gh is not None:
+            try:
+                self._gh.stop()
+            except Exception:
+                pass
+            self._gh = None