PyClickerRPA 0.1.0__py3-none-any.whl

autoclicker/gui/main_window.py

@@ -0,0 +1,651 @@
+"""Main window — port of mainwindow.cpp (Phase 2: toolbar + list editor + preview + log).
+
+The flow-graph editor tab arrives in Phase 3; this window already offers the
+linear list editor, window targeting, capture preview, run/stop/pause wired to
+the engine, and JSON save/load.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+import uuid
+import zipfile
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QAction, QGuiApplication, QKeySequence
+from PySide6.QtWidgets import (
+    QComboBox, QDockWidget, QFileDialog, QHBoxLayout, QInputDialog, QLabel,
+    QMainWindow, QMessageBox, QPushButton, QSplitter, QTableWidget,
+    QTableWidgetItem, QTabWidget, QTextEdit, QVBoxLayout, QWidget,
+)
+
+from autoclicker import capture as capture_mod
+from autoclicker import windows as windows_mod
+from autoclicker.models import Step, StepType, Task
+from autoclicker.gui.preview_label import PreviewLabel, PickMode
+from autoclicker.gui.qt_runner import QtRunner
+from autoclicker.gui.task_widget import TaskWidget
+from autoclicker.gui.flow_editor import FlowEditor
+from autoclicker.gui.recorder import Recorder
+from autoclicker.gui.scheduler_widget import SchedulerWidget
+from autoclicker.gui.snippet_library import SnippetLibrary
+from autoclicker.gui.hotkeys import HotkeyManager
+from autoclicker.gui.monitor import MonitorController
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("AutoClicker (Python)")
+        self.resize(1100, 720)
+        self._windows: list[windows_mod.WindowInfo] = []
+        self._last_capture = None
+        self._save_path = ""
+
+        self._runner = QtRunner(self)
+        self._runner.logMessage.connect(self._append_log)
+        self._runner.stepStarted.connect(self._on_step_started)
+        self._runner.matchFound.connect(
+            lambda x, y, c: self._append_log(f"  → 命中 ({x},{y}) {c:.3f}"))
+        self._runner.runFinished.connect(self._on_finished)
+
+        self._recorder = Recorder(self)
+        self._recorder.stepRecorded.connect(self._on_step_recorded)
+
+        self._build_ui()
+        self._build_menu()
+
+        self._pick_index = -1   # step index awaiting coord pick from preview
+
+        self.scheduler.runTaskRequested.connect(self._run_scheduled)
+        self.snippets.insertRequested.connect(self._on_snippet_insert)
+        self.preview.regionSelected.connect(self._on_region_selected)
+        self.preview.colorPicked.connect(self._on_color_picked)
+        self.preview.pointPicked.connect(self._on_point_picked)
+        self.preview.twoPointsPicked.connect(self._on_two_points_picked)
+        self._runner.matchFound.connect(lambda x, y, c: self.preview.add_marker(x, y))
+        self._runner.varChanged.connect(self._on_var_changed)
+        self.task_widget.testStepRequested.connect(self._test_single_step)
+
+        self._hotkeys = HotkeyManager(self)
+        self._hotkeys.toggleRunRequested.connect(self._hotkey_toggle)
+        self._hotkeys.stopRequested.connect(self.stop_task)
+        self._hotkeys.start()
+
+        self._really_quit = False
+        self._monitor = MonitorController(self)
+        self._monitor.triggered.connect(self._on_monitor_trigger)
+        self._monitor.status.connect(self._append_log)
+        self._build_tray()
+
+        self.refresh_windows()
+
+    def _hotkey_toggle(self):
+        if self._runner.is_running():
+            self.stop_task()
+        else:
+            self.run_task()
+
+    def _test_single_step(self, step):
+        if self._runner.is_running():
+            self._append_log("正在运行中,无法试跑单步")
+            return
+        self.log.clear()
+        self._clear_vars()
+        self.preview.clear_markers()
+        self._set_running(True)
+        self._append_log("试跑单步…")
+        self._runner.start(Task(steps=[step]), target_hwnd=self._target_hwnd())
+
+    # ---- system tray ----
+    def _build_tray(self):
+        from PySide6.QtWidgets import QSystemTrayIcon, QMenu, QStyle
+        if not QSystemTrayIcon.isSystemTrayAvailable():
+            self._tray = None
+            return
+        icon = self.style().standardIcon(QStyle.SP_ComputerIcon)
+        self.setWindowIcon(icon)
+        self._tray = QSystemTrayIcon(icon, self)
+        self._tray.setToolTip("AutoClicker")
+        menu = QMenu()
+        menu.addAction("显示主窗口", self._show_normal)
+        menu.addAction("停止监视", lambda: self._monitor.stop())
+        menu.addSeparator()
+        menu.addAction("退出", self._quit)
+        self._tray.setContextMenu(menu)
+        self._tray.activated.connect(
+            lambda reason: self._show_normal() if reason == QSystemTrayIcon.DoubleClick else None)
+        self._tray.show()
+
+    def _show_normal(self):
+        self.showNormal()
+        self.activateWindow()
+
+    def _quit(self):
+        self._really_quit = True
+        self.close()
+
+    # ---- monitor / trigger ----
+    def monitor_configure(self):
+        kind, ok = QInputDialog.getItem(self, "监视条件", "类型:", ["图片出现", "颜色匹配"], 0, False)
+        if not ok:
+            return
+        interval, ok = QInputDialog.getInt(self, "轮询间隔", "毫秒:", 1000, 100, 600000, 100)
+        if not ok:
+            return
+        cond = {"interval_ms": interval}
+        if kind == "图片出现":
+            path, _ = QFileDialog.getOpenFileName(self, "选择模板图片", "", "图片 (*.png *.jpg *.jpeg *.bmp)")
+            if not path:
+                return
+            thr, ok = QInputDialog.getDouble(self, "匹配阈值", "0~1:", 0.8, 0.0, 1.0, 2)
+            if not ok:
+                return
+            cond.update(type="image", image=path, threshold=thr)
+        else:
+            color, ok = QInputDialog.getText(self, "目标颜色", "#RRGGBB:")
+            if not ok or not color:
+                return
+            x, ok = QInputDialog.getInt(self, "X", "像素 X:", 0, 0, 100000)
+            if not ok:
+                return
+            y, ok = QInputDialog.getInt(self, "Y", "像素 Y:", 0, 0, 100000)
+            if not ok:
+                return
+            tol, ok = QInputDialog.getInt(self, "容差", "0~255:", 30, 0, 255)
+            if not ok:
+                return
+            cond.update(type="color", color=color, x=x, y=y, tolerance=tol)
+        self._monitor.start(self._target_hwnd(), cond)
+        self._append_log(f"开始监视: {cond}")
+
+    def _on_monitor_trigger(self):
+        self._append_log("监视触发!")
+        if self._runner.is_running():
+            return
+        task = self._current_task()
+        if not task.steps:
+            return
+        self._clear_vars()
+        self.preview.clear_markers()
+        self._set_running(True)
+        self._runner.start(task, target_hwnd=self._target_hwnd(),
+                           screenshot_on_fail=True, screenshot_dir=".failures")
+
+    def closeEvent(self, event):
+        # Minimize to tray instead of quitting, unless explicitly quitting
+        if getattr(self, "_tray", None) is not None and not self._really_quit:
+            event.ignore()
+            self.hide()
+            from PySide6.QtWidgets import QSystemTrayIcon
+            self._tray.showMessage("AutoClicker", "已最小化到托盘,监视仍在后台运行",
+                                   QSystemTrayIcon.MessageIcon.Information, 2000)
+            return
+        try:
+            self._hotkeys.stop()
+            self._monitor.stop()
+            if self._recorder.is_recording():
+                self._recorder.stop()
+        except Exception:
+            pass
+        super().closeEvent(event)
+
+    # ---- UI ----
+    def _build_ui(self):
+        central = QWidget()
+        self.setCentralWidget(central)
+        root = QVBoxLayout(central)
+
+        bar = QHBoxLayout()
+        self.window_combo = QComboBox()
+        self.window_combo.setMinimumWidth(280)
+        refresh_btn = QPushButton("刷新")
+        refresh_btn.clicked.connect(self.refresh_windows)
+        capture_btn = QPushButton("截图")
+        capture_btn.clicked.connect(self.capture)
+        self.record_btn = QPushButton("● 录制")
+        self.record_btn.clicked.connect(self.toggle_record)
+        self.run_btn = QPushButton("▶ 运行")
+        self.run_btn.clicked.connect(self.run_task)
+        self.pause_btn = QPushButton("⏸ 暂停")
+        self.pause_btn.clicked.connect(self.toggle_pause)
+        self.pause_btn.setEnabled(False)
+        self.stop_btn = QPushButton("■ 停止")
+        self.stop_btn.clicked.connect(self.stop_task)
+        self.stop_btn.setEnabled(False)
+        bar.addWidget(QLabel("目标窗口"))
+        bar.addWidget(self.window_combo, 1)
+        bar.addWidget(refresh_btn)
+        bar.addWidget(capture_btn)
+        bar.addStretch()
+        bar.addWidget(self.record_btn)
+        bar.addWidget(self.run_btn)
+        bar.addWidget(self.pause_btn)
+        bar.addWidget(self.stop_btn)
+        root.addLayout(bar)
+
+        splitter = QSplitter(Qt.Horizontal)
+        self.tabs = QTabWidget()
+        self.flow_editor = FlowEditor()
+        self.task_widget = TaskWidget()
+        self.scheduler = SchedulerWidget()
+        self.snippets = SnippetLibrary()
+        self.tabs.addTab(self.flow_editor, "流程图")
+        self.tabs.addTab(self.task_widget, "步骤列表")
+        self.tabs.addTab(self.scheduler, "定时")
+        self.tabs.addTab(self.snippets, "片段")
+        splitter.addWidget(self.tabs)
+
+        # Right pane: preview + preview tools
+        right = QWidget()
+        rlay = QVBoxLayout(right)
+        rlay.setContentsMargins(0, 0, 0, 0)
+        ptools = QHBoxLayout()
+        for text, slot in [("裁剪模板", self.crop_template), ("取色", self.pick_color),
+                           ("取坐标→选中步骤", self.pick_coord_for_step), ("OCR叠加", self.ocr_overlay)]:
+            b = QPushButton(text)
+            b.clicked.connect(slot)
+            ptools.addWidget(b)
+        ptools.addStretch()
+        rlay.addLayout(ptools)
+        self.preview = PreviewLabel()
+        rlay.addWidget(self.preview, 1)
+        splitter.addWidget(right)
+        splitter.setSizes([560, 540])
+        root.addWidget(splitter, 1)
+
+        self.log = QTextEdit()
+        self.log.setReadOnly(True)
+        self.log.setMaximumHeight(180)
+        root.addWidget(self.log)
+
+        # Live variables dock (updated from runner varChanged)
+        self.var_table = QTableWidget(0, 2)
+        self.var_table.setHorizontalHeaderLabels(["变量", "值"])
+        self.var_table.horizontalHeader().setStretchLastSection(True)
+        self._var_rows: dict[str, int] = {}
+        dock = QDockWidget("变量", self)
+        dock.setWidget(self.var_table)
+        self.addDockWidget(Qt.RightDockWidgetArea, dock)
+
+    def _on_var_changed(self, name: str, value: str):
+        row = self._var_rows.get(name)
+        if row is None:
+            row = self.var_table.rowCount()
+            self.var_table.insertRow(row)
+            self.var_table.setItem(row, 0, QTableWidgetItem(name))
+            self._var_rows[name] = row
+        self.var_table.setItem(row, 1, QTableWidgetItem(value))
+
+    def _clear_vars(self):
+        self.var_table.setRowCount(0)
+        self._var_rows.clear()
+
+    def _build_menu(self):
+        m = self.menuBar().addMenu("文件")
+        save = QAction("保存", self, shortcut=QKeySequence.Save, triggered=self.save_task)
+        save_as = QAction("另存为…", self, triggered=lambda: self.save_task(force_dialog=True))
+        open_ = QAction("打开", self, shortcut=QKeySequence.Open, triggered=self.open_task)
+        m.addAction(save)
+        m.addAction(save_as)
+        m.addAction(open_)
+        m.addSeparator()
+        m.addAction(QAction("导出任务包(.zip)…", self, triggered=self.export_package))
+        m.addAction(QAction("导入任务包(.zip)…", self, triggered=self.import_package))
+
+        e = self.menuBar().addMenu("编辑")
+        e.addAction(QAction("选中步骤存为片段…", self, triggered=self.save_snippet))
+        e.addSeparator()
+        e.addAction(QAction("复制步骤到剪贴板(JSON)", self, triggered=self.copy_steps_json))
+        e.addAction(QAction("从剪贴板粘贴步骤(JSON)", self, triggered=self.paste_steps_json))
+
+        mon = self.menuBar().addMenu("监视")
+        mon.addAction(QAction("配置并开始监视…", self, triggered=self.monitor_configure))
+        mon.addAction(QAction("停止监视", self, triggered=lambda: self._monitor.stop()))
+
+    # ---- windows / capture ----
+    def refresh_windows(self):
+        self._windows = windows_mod.list_windows()
+        self.window_combo.clear()
+        self.window_combo.addItem("(整个屏幕)", None)
+        for info in self._windows:
+            self.window_combo.addItem(f"{info.title}  [{info.width}x{info.height}]", info)
+
+    def _target_hwnd(self):
+        info = self.window_combo.currentData()
+        return info.hwnd if info else None
+
+    def _current_task(self) -> Task:
+        """Task from the active editor tab (flow graph or linear list)."""
+        if self.tabs.currentWidget() is self.flow_editor:
+            return self.flow_editor.build_task()
+        return self.task_widget.get_task()
+
+    def capture(self):
+        try:
+            hwnd = self._target_hwnd()
+            img = capture_mod.capture_window(hwnd) if hwnd else capture_mod.capture_screen()
+            if img is None or img.size == 0:
+                self._append_log("截图为空(窗口可能最小化或被遮挡)")
+                return
+            self._last_capture = img
+            self.preview.set_image_ndarray(img)
+            self._append_log(f"截图: {img.shape[1]}x{img.shape[0]}")
+        except Exception as e:
+            self._append_log(f"截图失败: {e}")
+
+    # ---- run control ----
+    def run_task(self):
+        if self._runner.is_running():
+            return
+        task = self._current_task()
+        if not task.steps:
+            self._append_log("任务为空")
+            return
+        self.log.clear()
+        self._clear_vars()
+        self.preview.clear_markers()
+        self._set_running(True)
+        self._runner.start(task, target_hwnd=self._target_hwnd(),
+                           screenshot_on_fail=True, screenshot_dir=".failures")
+
+    def stop_task(self):
+        self._runner.stop()
+
+    def toggle_pause(self):
+        if self.pause_btn.text().startswith("⏸"):
+            self._runner.pause()
+            self.pause_btn.setText("▶ 继续")
+        else:
+            self._runner.resume()
+            self.pause_btn.setText("⏸ 暂停")
+
+    def _set_running(self, running: bool):
+        self.run_btn.setEnabled(not running)
+        self.stop_btn.setEnabled(running)
+        self.pause_btn.setEnabled(running)
+        if not running:
+            self.pause_btn.setText("⏸ 暂停")
+
+    def _on_step_started(self, index: int, desc: str):
+        self._append_log(f"[{index + 1}] {desc}")
+
+    def _on_finished(self):
+        self._set_running(False)
+
+    def _append_log(self, msg: str):
+        self.log.append(msg)
+
+    # ---- save / load ----
+    def save_task(self, force_dialog: bool = False):
+        path = self._save_path
+        if force_dialog or not path:
+            path, _ = QFileDialog.getSaveFileName(self, "保存任务", "", "任务文件 (*.json)")
+            if not path:
+                return
+        if not path.lower().endswith(".json"):
+            path += ".json"
+        if self._current_task().save_to_file(path):
+            self._save_path = path
+            self._append_log(f"已保存: {path}")
+        else:
+            QMessageBox.warning(self, "保存失败", f"无法写入 {path}")
+
+    def open_task(self):
+        path, _ = QFileDialog.getOpenFileName(self, "打开任务", "", "任务文件 (*.json)")
+        if not path:
+            return
+        try:
+            task = Task.load_from_file(path)
+        except Exception as e:
+            QMessageBox.warning(self, "打开失败", str(e))
+            return
+        self._load_task_into_editors(task, path)
+
+    def _load_task_into_editors(self, task: Task, path: str = ""):
+        self.task_widget.set_task(task)
+        self.flow_editor.load_task(task)
+        if path:
+            self._save_path = path
+            self.setWindowTitle(f"AutoClicker (Python) — {os.path.basename(path)}")
+            self._append_log(f"已加载: {path} ({len(task.steps)} 步)")
+
+    # ---- recorder ----
+    def toggle_record(self):
+        if self._recorder.is_recording():
+            self._recorder.stop()
+            self.record_btn.setText("● 录制")
+            self._append_log("录制结束")
+            return
+        hwnd = self._target_hwnd()
+        self._recorder.start(hwnd)
+        self.record_btn.setText("■ 停止录制")
+        self.tabs.setCurrentWidget(self.task_widget)
+        self._append_log("开始录制(在目标窗口内操作;再次点击结束)")
+
+    def _on_step_recorded(self, step: Step):
+        self.task_widget.append_step(step)
+
+    # ---- scheduler / snippets ----
+    def _run_scheduled(self, path: str):
+        if self._runner.is_running():
+            self._append_log(f"定时触发但任务运行中，跳过: {path}")
+            return
+        try:
+            task = Task.load_from_file(path)
+        except Exception as e:
+            self._append_log(f"定时任务加载失败 {path}: {e}")
+            return
+        if not task.steps:
+            return
+        self._append_log(f"定时触发: {path}")
+        self._clear_vars()
+        self.preview.clear_markers()
+        self._set_running(True)
+        self._runner.start(task, target_hwnd=self._target_hwnd(),
+                           screenshot_on_fail=True, screenshot_dir=".failures")
+
+    def _on_snippet_insert(self, steps):
+        self.task_widget.insert_steps(list(steps))
+        self.tabs.setCurrentWidget(self.task_widget)
+        self._append_log(f"插入片段: {len(steps)} 步")
+
+    def save_snippet(self):
+        steps = self.task_widget.get_selected_steps()
+        if not steps:
+            self._append_log("请先在「步骤列表」中选中要保存的步骤")
+            return
+        name, ok = QInputDialog.getText(self, "存为片段", "片段名称:")
+        if ok and name:
+            self.snippets.save_snippet(name, steps)
+            self._append_log(f"已保存片段: {name} ({len(steps)} 步)")
+
+    # ---- step clipboard (JSON) ----
+    def copy_steps_json(self):
+        import json
+        steps = self.task_widget.get_selected_steps()
+        if not steps:
+            self._append_log("请先在「步骤列表」中选中要复制的步骤")
+            return
+        QGuiApplication.clipboard().setText(json.dumps([s.to_json() for s in steps], ensure_ascii=False, indent=2))
+        self._append_log(f"已复制 {len(steps)} 步到剪贴板(JSON)")
+
+    def paste_steps_json(self):
+        import json
+        text = QGuiApplication.clipboard().text()
+        try:
+            data = json.loads(text)
+            assert isinstance(data, list)
+        except (json.JSONDecodeError, AssertionError):
+            self._append_log("剪贴板内容不是有效的步骤 JSON 数组")
+            return
+        steps = [Step.from_json(o) for o in data]
+        if not steps:
+            return
+        self.task_widget.insert_steps(steps)
+        self.tabs.setCurrentWidget(self.task_widget)
+        self._append_log(f"已从剪贴板粘贴 {len(steps)} 步")
+
+    # ---- preview picking ----
+    _SINGLE_POINT_TYPES = {StepType.ClickPosition, StepType.LongPress, StepType.Scroll,
+                           StepType.IfColorMatch, StepType.Pinch}
+
+    def crop_template(self):
+        if not self.preview.has_image():
+            self._append_log("请先截图")
+            return
+        self._pick_index = -1
+        self.preview.set_pick_mode(PickMode.REGION)
+        self._append_log("在预览上框选模板区域…")
+
+    def pick_color(self):
+        if not self.preview.has_image():
+            self._append_log("请先截图")
+            return
+        self._pick_index = -1
+        self.preview.set_pick_mode(PickMode.COLOR)
+        self._append_log("在预览上点击取色…")
+
+    def pick_coord_for_step(self):
+        if not self.preview.has_image():
+            self._append_log("请先截图")
+            return
+        i = self.task_widget.current_index()
+        step = self.task_widget.step_at(i)
+        if step is None:
+            self._append_log("请先在「步骤列表」选中一个坐标类步骤")
+            return
+        if step.type == StepType.Drag:
+            self._pick_index = i
+            self.preview.set_pick_mode(PickMode.TWO_POINTS)
+            self._append_log("在预览上依次点击 起点、终点…")
+        elif step.type in self._SINGLE_POINT_TYPES:
+            self._pick_index = i
+            self.preview.set_pick_mode(PickMode.POINT)
+            self._append_log(f"在预览上点击以设置「{step.display_name()}」的坐标…")
+        else:
+            self._append_log("该步骤类型不支持坐标拾取")
+
+    def _on_point_picked(self, pt):
+        if self._pick_index < 0:
+            return
+        step = self.task_widget.step_at(self._pick_index)
+        if step is not None:
+            step.x, step.y = pt.x(), pt.y()
+            self.task_widget.replace_step(self._pick_index, step)
+            self._append_log(f"已设置坐标 ({pt.x()}, {pt.y()})")
+        self._pick_index = -1
+
+    def _on_two_points_picked(self, a, b):
+        if self._pick_index < 0:
+            return
+        step = self.task_widget.step_at(self._pick_index)
+        if step is not None:
+            step.x, step.y, step.x2, step.y2 = a.x(), a.y(), b.x(), b.y()
+            self.task_widget.replace_step(self._pick_index, step)
+            self._append_log(f"已设置拖拽 ({a.x()},{a.y()}) → ({b.x()},{b.y()})")
+        self._pick_index = -1
+
+    def _on_region_selected(self, rect):
+        if self._last_capture is None:
+            return
+        import cv2
+        x, y, w, h = rect.x(), rect.y(), rect.width(), rect.height()
+        crop = self._last_capture[y:y + h, x:x + w]
+        if crop.size == 0:
+            return
+        d = os.path.join(os.getcwd(), ".templates")
+        os.makedirs(d, exist_ok=True)
+        path = os.path.join(d, f"tmpl_{uuid.uuid4().hex[:8]}.png")
+        cv2.imwrite(path, crop)
+        QGuiApplication.clipboard().setText(path)
+        self._append_log(f"已保存模板: {path}  (路径已复制到剪贴板)")
+
+    def _on_color_picked(self, pt, color):
+        hexstr = color.name()  # #rrggbb
+        QGuiApplication.clipboard().setText(hexstr)
+        self._append_log(f"取色 ({pt.x()},{pt.y()}) = {hexstr}  (已复制到剪贴板)")
+
+    def ocr_overlay(self):
+        if self._last_capture is None:
+            self._append_log("请先截图")
+            return
+        from autoclicker import matcher
+        try:
+            results = matcher.ocr_all(self._last_capture)
+        except Exception as e:
+            self._append_log(f"OCR 失败: {e}")
+            return
+        if not results:
+            self._append_log("OCR: 未识别到文字(或 PaddleOCR 未安装)")
+            return
+        from autoclicker.gui.preview_label import ndarray_to_qimage
+        from PySide6.QtGui import QPainter, QPen, QColor
+        img = ndarray_to_qimage(self._last_capture)
+        painter = QPainter(img)
+        painter.setPen(QPen(QColor(0, 255, 0), 2))
+        for r in results:
+            painter.drawRect(r.x, r.y, r.w, r.h)
+        painter.end()
+        self.preview.set_image_qimage(img)
+        self._append_log(f"OCR: 识别到 {len(results)} 处文字")
+
+    # ---- task package (.zip: task.json + images/) ----
+    def _iter_image_slots(self, task: Task):
+        """Yield (get, set) callables for every image path field in the task."""
+        for s in task.steps:
+            if s.imagePath:
+                yield (lambda s=s: s.imagePath), (lambda v, s=s: setattr(s, "imagePath", v))
+            for i in range(len(s.imagePaths)):
+                yield (lambda s=s, i=i: s.imagePaths[i]), (lambda v, s=s, i=i: s.imagePaths.__setitem__(i, v))
+            if s.until.image:
+                yield (lambda s=s: s.until.image), (lambda v, s=s: setattr(s.until, "image", v))
+
+    def export_package(self):
+        import copy as _copy
+        path, _ = QFileDialog.getSaveFileName(self, "导出任务包", "", "任务包 (*.zip)")
+        if not path:
+            return
+        if not path.lower().endswith(".zip"):
+            path += ".zip"
+        task = _copy.deepcopy(self._current_task())
+        seen: dict[str, str] = {}
+        with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as z:
+            for get, setv in self._iter_image_slots(task):
+                src = get()
+                if not src or not os.path.exists(src):
+                    continue
+                if src not in seen:
+                    arc = f"images/{os.path.basename(src)}"
+                    # avoid collisions
+                    base, ext = os.path.splitext(arc)
+                    n = 1
+                    while arc in seen.values():
+                        arc = f"{base}_{n}{ext}"
+                        n += 1
+                    z.write(src, arc)
+                    seen[src] = arc
+                setv(seen[src])
+            z.writestr("task.json", __import__("json").dumps(task.to_json(), ensure_ascii=False, indent=4))
+        self._append_log(f"已导出任务包: {path}")
+
+    def import_package(self):
+        path, _ = QFileDialog.getOpenFileName(self, "导入任务包", "", "任务包 (*.zip)")
+        if not path:
+            return
+        out_dir = os.path.join(os.getcwd(), ".packages", os.path.splitext(os.path.basename(path))[0])
+        os.makedirs(out_dir, exist_ok=True)
+        with zipfile.ZipFile(path, "r") as z:
+            z.extractall(out_dir)
+        task_json = os.path.join(out_dir, "task.json")
+        if not os.path.exists(task_json):
+            QMessageBox.warning(self, "导入失败", "任务包内缺少 task.json")
+            return
+        task = Task.load_from_file(task_json)
+        for get, setv in self._iter_image_slots(task):
+            rel = get()
+            if rel and not os.path.isabs(rel):
+                setv(os.path.join(out_dir, rel))
+        self._load_task_into_editors(task, "")
+        self._append_log(f"已导入任务包: {path} → {out_dir} ({len(task.steps)} 步)")