PDPSManagerApp_PyQt5.py

# -*- coding: utf-8 -*-
"""
PDPSManagerApp - PyQt5 GUI 重写版
将原 tkinter GUI 全部替换为 PyQt5，业务逻辑类保持不变。
"""

import os
import sys
import subprocess
import threading
import queue
import traceback
import json
import math
import zipfile
from datetime import datetime
from typing import List, Dict, Optional, Tuple

import pandas as pd
import numpy as np
import winreg
import re
import ctypes
import threading
import queue
import traceback
from PyQt5.QtWidgets import (QMessageBox, QInputDialog, QLineEdit, QDialog,
                             QVBoxLayout, QLabel, QProgressBar, QPushButton, QApplication)
from PyQt5.QtCore import QTimer, Qt
from PyQt5.QtGui import QFont

from PIL import Image

# ── PyQt5 ──────────────────────────────────────────────────────────────────
from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QWidget, QTabWidget, QFrame, QSplitter,
    QVBoxLayout, QHBoxLayout, QGridLayout, QFormLayout,
    QLabel, QPushButton, QLineEdit, QTextEdit, QPlainTextEdit,
    QComboBox, QCheckBox, QRadioButton, QButtonGroup,
    QTreeWidget, QTreeWidgetItem, QHeaderView,
    QTableWidget, QTableWidgetItem, QAbstractItemView,
    QProgressBar, QScrollArea, QGroupBox,
    QMenu, QAction, QMessageBox, QFileDialog, QDialog,
    QStatusBar, QSizePolicy, QDoubleSpinBox, QSpinBox,
    QStyleFactory
)
from PyQt5.QtGui import (
    QFont, QColor, QPixmap, QIcon, QPalette, QImage,
    QStandardItemModel, QStandardItem
)
from PyQt5.QtCore import (
    Qt, QThread, pyqtSignal, QTimer, QSize, QMimeData, QModelIndex
)

# ── 全局常量 ────────────────────────────────────────────────────────────────
CONFIG_FILE = "pdps_master_config_v13.xlsx"
REG_PATH = r"Software\TECNOMATIX\TUNE\NewAssembler\Options\EMS"

# ── pycatia 可选导入 ────────────────────────────────────────────────────────
try:
    from pycatia import catia as pycatia_catia
    from pycatia.mec_mod_interfaces.part_document import PartDocument
    PYCATIA_AVAILABLE = True
except Exception:
    PYCATIA_AVAILABLE = False


# ============================================================================
# 业务逻辑类（直接从原文件保留，不做任何修改）
# ============================================================================

# ── CATIAWeldPointExtractor ──────────────────────────────────────────────────
class CATIAWeldPointExtractor:
    """CATIA 焊点提取工具类（兼容 win32com 和 pycatia）"""
    def __init__(self, catia_app=None):
        self.catia_app = catia_app
        self.weld_points_data: List[Dict] = []
        self.status_message = "就绪"
        self.connection_type = None

    def connect_catia(self, use_pycatia=False) -> bool:
        try:
            if use_pycatia:
                if not PYCATIA_AVAILABLE:
                    return False
                self.catia_app = pycatia_catia()
                self.connection_type = 'pycatia'
                self.status_message = "已连接 | CATIA (pycatia)"
                return True
            else:
                import win32com.client
                try:
                    self.catia_app = win32com.client.GetActiveObject("CATIA.Application")
                except Exception:
                    self.catia_app = win32com.client.Dispatch("CATIA.Application")
                self.connection_type = 'win32com'
                self.status_message = "已连接 | CATIA (win32com)"
                return True
        except Exception as e:
            self.status_message = "连接 CATIA 失败"
            return False

    def set_catia_app(self, catia_app, connection_type='win32com'):
        self.catia_app = catia_app
        self.connection_type = connection_type
        self.status_message = f"CATIA 应用已设置 ({connection_type})"

    def get_status(self):
        return self.status_message

    def extract_weld_points(self, auto_rename: bool = False) -> List[Dict]:
        if not self.catia_app:
            self.status_message = "请先连接 CATIA"
            return []
        self.weld_points_data = []
        try:
            if self.connection_type == 'pycatia':
                doc = self.catia_app.active_document
                if not doc or not hasattr(doc, 'part'):
                    self.status_message = "当前文档不是 Part 文档"
                    return []
                part = doc.part
                selection = doc.selection
                part_full_name = doc.name
            else:
                doc = self.catia_app.ActiveDocument
                if not doc:
                    return []
                try:
                    part = doc.Part
                except:
                    self.status_message = "当前文档不是 Part 文档"
                    return []
                selection = doc.Selection
                part_full_name = doc.Name

            spa_workbench = None
            try:
                if self.connection_type == 'pycatia':
                    spa_workbench = doc.spa_workbench()
                else:
                    spa_workbench = doc.GetWorkbench("SPAWorkbench")
            except:
                pass

            if self.connection_type == 'pycatia':
                selection.clear()
                selection.search("CATGmoSearch.Point,all")
                count = selection.count
            else:
                selection.Clear()
                selection.Search("CATGmoSearch.Point,all")
                count = selection.Count

            # ── 预扫描：构建 {点名称 → 直接父图形集名称} 映射表 ────────────
            # 比逐点调用 .Parent 更可靠，避免 win32com/pycatia 的 Parent 属性失效问题
            point_parent_map = self._build_point_parent_map(part)

            for i in range(1, count + 1):
                try:
                    if self.connection_type == 'pycatia':
                        item = selection.item(i)
                        point_obj = item.value
                        name = getattr(point_obj, 'name', f"Point_{i}")
                    else:
                        item = selection.Item(i)
                        point_obj = item.Value
                        name = getattr(point_obj, 'Name', f"Point_{i}")

                    # ── 从映射表获取父图形集名 ──────────────────────────────
                    # 优先用精确名查询，再去掉 GSMPoint 后缀的基本名匹配
                    geo_set_name = point_parent_map.get(name, "")
                    if not geo_set_name:
                        # 点名可能含 ".N" 后缀，尝试去掉后缀再匹配
                        base_name = re.sub(r'\.GSMPoint\.\d+$', '', name, flags=re.IGNORECASE)
                        base_name = re.sub(r'-GSMPoint\.\d+$', '', base_name, flags=re.IGNORECASE)
                        geo_set_name = point_parent_map.get(base_name, "")

                    # ── 获取坐标 ────────────────────────────────────────────
                    x, y, z = 0, 0, 0
                    try:
                        if spa_workbench:
                            if self.connection_type == 'pycatia':
                                ref = part.create_reference_from_object(point_obj)
                                m = spa_workbench.get_measurable(ref)
                                coords = m.get_point()
                            else:
                                ref = part.CreateReferenceFromObject(point_obj)
                                m = spa_workbench.GetMeasurable(ref)
                                coords = [0, 0, 0]
                                m.GetPoint(coords)
                            x, y, z = coords[0], coords[1], coords[2]
                    except:
                        pass

                    # ── 自动重命名 ───────────────────────────────────────────
                    # geo_set_name 即为图形集名（如 DPUB-501000588-XAX&DPUB-501000592-XAX&...）
                    # 直接用它提取零件号，无需再向上遍历父节点
                    std_name = name
                    if auto_rename:
                        std_name = self._generate_standard_name(name, geo_set_name)

                    # ── 根据图形集名称中 & 数量推断焊接层数类型 ────────────
                    weld_type = self._weld_type_from_location(geo_set_name)
                    location_str = f"{x:.3f},{y:.3f},{z:.3f}"
                    self.weld_points_data.append({
                        "Class": "PmWeldPoint",
                        "ExternalId": std_name,
                        "Name": std_name,
                        "Location": location_str,
                        "X": round(x, 3),
                        "Y": round(y, 3),
                        "Z": round(z, 3),
                        "Type": weld_type
                    })
                except:
                    pass

            self.status_message = f"已提取 {len(self.weld_points_data)} 个焊点"
        except Exception as e:
            self.status_message = f"提取失败: {e}"
        return self.weld_points_data

    def _generate_standard_name(self, original_name: str, geo_set_name: str) -> str:
        """
        生成标准命名：{前缀}_{零件数字段}_{焊点数字段}

        焊点名示例：  T1E-0000010296-RSW-GSMPoint.2
          → 前缀 = T1E，焊点 ID = 10296

        图形集名示例：DPUB-501000588-XAX&DPUB-501000592-XAX&DPUB-501001638-XAX
          → 取第一段 DPUB-501000588-XAX，零件 ID = 501000588（首个纯数字段）

        结果示例：T1E_501000588_10296
        """
        try:
            # ── 1. 提取前缀（焊点名第一个"-"之前）──────────────────────────
            orig_segs = original_name.split('-')
            prefix = orig_segs[0].strip() if orig_segs else "UNK"

            # ── 2. 提取零件 ID（从图形集名第一个 & 段中找首个纯数字段）──────
            part_id = ""
            if geo_set_name:
                # 取 & 之前的第一个零件名段，如 "DPUB-501000588-XAX"
                first_part_seg = geo_set_name.split('&')[0].strip()
                for seg in first_part_seg.split('-'):
                    seg_clean = seg.split('_')[0]       # 去掉下划线后缀，如 "XWS_00" → "XWS"
                    if seg_clean.isdigit():
                        part_id = seg_clean
                        break
                if not part_id:
                    # 降级：取第二段（不要求纯数字）
                    p_segs = first_part_seg.split('-')
                    part_id = p_segs[1].split('_')[0] if len(p_segs) > 1 else p_segs[0]

            if not part_id:
                part_id = re.sub(r'[^A-Za-z0-9]', '', geo_set_name)[:12] or "PART"

            # ── 3. 提取焊点数字（第二段去前导零）──────────────────────────
            weld_id = "0"
            if len(orig_segs) > 1:
                raw = orig_segs[1].strip()
                weld_id = raw.lstrip('0') or "0"

            return f"{prefix}_{part_id}_{weld_id}"
        except Exception:
            return original_name

    @staticmethod
    def _weld_type_from_location(location_name: str) -> str:
        """
        根据图形集名称中 '&' 的数量推断焊接层数类型：
          无 & 或 1 个 & → 双层板 → "2T"
          2 个 &         → 三层板 → "3T"
          N 个 &         → (N+1) 层板 → "{N+1}T"

        规则：N 个 & 连接 (N+1) 个零件，即 (N+1) 层板。
        无 & 时认为只有1个零件段，默认双层板（实际为单零件贴合场景取2T）。
        """
        count = location_name.count('&')
        layers = max(2, count + 1)   # 0 个 & → 1 个零件 → 默认 2T; 2 个 & → 3 个零件 → 3T
        return f"{layers}T"

    def _build_point_parent_map(self, part) -> Dict[str, str]:
        """
        预扫描零件的全部 HybridBodies（图形集）层级，
        构建 {点名称: 直接父图形集名称} 映射表。
        支持 win32com 和 pycatia 两种连接方式。
        """
        point_parent_map: Dict[str, str] = {}

        def _scan_body(hb, conn_type: str):
            """递归扫描一个 HybridBody 内的所有点和子图形集。"""
            try:
                if conn_type == 'pycatia':
                    hb_name = hb.name
                    shapes = hb.hybrid_shapes
                    shape_count = shapes.count
                    sub_bodies = hb.hybrid_bodies
                    sub_count = sub_bodies.count
                    def get_shape(j): return shapes.item(j)
                    def get_shape_name(s): return s.name
                    def get_sub(j): return sub_bodies.item(j)
                else:
                    hb_name = hb.Name
                    shapes = hb.HybridShapes
                    shape_count = shapes.Count
                    sub_bodies = hb.HybridBodies
                    sub_count = sub_bodies.Count
                    def get_shape(j): return shapes.Item(j)
                    def get_shape_name(s): return s.Name
                    def get_sub(j): return sub_bodies.Item(j)

                # 登记本 HybridBody 内直属的所有形状
                for j in range(1, shape_count + 1):
                    try:
                        shape = get_shape(j)
                        sname = get_shape_name(shape)
                        if sname:
                            point_parent_map[sname] = hb_name
                    except Exception:
                        pass

                # 递归处理子图形集（但子图形集内的点归属子图形集，不覆盖父级）
                for j in range(1, sub_count + 1):
                    try:
                        _scan_body(get_sub(j), conn_type)
                    except Exception:
                        pass

            except Exception as e:
                print(f"_scan_body error: {e}")

        try:
            if self.connection_type == 'pycatia':
                root_bodies = part.hybrid_bodies
                for i in range(1, root_bodies.count + 1):
                    _scan_body(root_bodies.item(i), 'pycatia')
            else:
                root_bodies = part.HybridBodies
                for i in range(1, root_bodies.Count + 1):
                    _scan_body(root_bodies.Item(i), 'win32com')
        except Exception as e:
            print(f"_build_point_parent_map error: {e}")

        return point_parent_map

    # ---------------------------
    # 生成球体（完整实现 - PyQt5版）
    # ---------------------------
    def generate_spheres_from_points(self, parent_qt=None):
        """
        从焊点生成球体（win32com 版本为主）
        parent_qt: 可选，传入 QWidget (如 QMainWindow) 用于设置父窗口及更新 status_label
        """
        # 入口判断
        weld_points_data = self.get_data() if hasattr(self, "get_data") else self.weld_points_data
        if not weld_points_data:
            QMessageBox.warning(parent_qt, "警告", "没有焊点数据可生成球体")
            return

        # 参数对话框
        radius_str, ok = QInputDialog.getText(parent_qt, "球体半径", "请输入球体半径（mm）:", QLineEdit.Normal, "10")
        if not ok or not radius_str:
            return
        try:
            radius = float(radius_str)
        except ValueError:
            QMessageBox.critical(parent_qt, "参数错误", "请输入有效的半径数值")
            return

        name_prefix, ok = QInputDialog.getText(parent_qt, "名称前缀", "球体名称前缀:", QLineEdit.Normal, "SPHERE")
        if not ok:
            return
        name_prefix = name_prefix or "SPHERE"

        geom_set_name, ok = QInputDialog.getText(parent_qt, "几何集名称", "几何集名称:", QLineEdit.Normal,
                                                 "Geometry_Spheres")
        if not ok:
            return
        geom_set_name = geom_set_name or "Geometry_Spheres"

        # 创建进度对话框
        progress_dialog = QDialog(parent_qt)
        progress_dialog.setWindowTitle("生成球体")
        progress_dialog.resize(420, 160)
        progress_dialog.setWindowModality(Qt.WindowModal)  # 模态窗口，阻塞父窗口交互

        layout = QVBoxLayout(progress_dialog)

        # 标题 Label
        title_lbl = QLabel(f"将生成 {len(weld_points_data)} 个球体")
        title_lbl.setFont(QFont("Microsoft YaHei", 10))
        layout.addWidget(title_lbl, alignment=Qt.AlignHCenter)

        # 进度条
        progress_bar = QProgressBar()
        progress_bar.setRange(0, 100)
        progress_bar.setValue(0)
        layout.addWidget(progress_bar)

        # 状态 Label
        status_lbl = QLabel("准备中...")
        status_lbl.setStyleSheet("color: gray;")
        layout.addWidget(status_lbl, alignment=Qt.AlignHCenter)

        # 取消按钮
        cancel_btn = QPushButton("取消")
        cancel_btn.setFixedSize(100, 30)
        cancel_btn.setStyleSheet("background-color: #7f8c8d; color: white; border-radius: 4px;")
        layout.addWidget(cancel_btn, alignment=Qt.AlignHCenter)

        cancel_event = threading.Event()
        progress_q = queue.Queue()

        def worker():
            """在后台线程中执行 CATIA 操作"""
            try:
                import pythoncom
                pythoncom.CoInitialize()
                try:
                    import win32com.client
                    try:
                        catia = win32com.client.GetActiveObject("CATIA.Application")
                    except Exception:
                        catia = win32com.client.Dispatch("CATIA.Application")

                    # 获取文档与 Part
                    doc = getattr(catia, "ActiveDocument", None)
                    if doc is None:
                        progress_q.put(("error", "没有活动的 CATIA 文档"))
                        return

                    part = getattr(doc, "Part", None)
                    if part is None:
                        progress_q.put(("error", "当前文档不是 Part 类型"))
                        return

                    hsf = part.HybridShapeFactory
                    hybrid_bodies = part.HybridBodies

                    # 尝试切换工作台（可选）
                    try:
                        catia.StartWorkbench("PartDesign")
                    except:
                        pass

                    # 获取或创建几何集
                    target_body = None
                    try:
                        for i in range(1, hybrid_bodies.Count + 1):
                            body = hybrid_bodies.Item(i)
                            if body.Name == geom_set_name:
                                target_body = body
                                break
                        if target_body is None:
                            target_body = hybrid_bodies.Add()
                            target_body.Name = geom_set_name
                    except Exception as e:
                        progress_q.put(("error", f"无法获取或创建几何集: {str(e)}"))
                        return

                    # 尝试设置 InWorkObject
                    try:
                        part.InWorkObject = target_body
                    except:
                        pass

                    total = len(weld_points_data)
                    created_points = []

                    # 1) 批量创建点并 append 到几何集（不频繁 Update）
                    for idx, weld in enumerate(weld_points_data):
                        if cancel_event.is_set():
                            progress_q.put(("info", f"已取消，已创建 {len(created_points)} 个点"))
                            return
                        try:
                            x = float(weld.get("X", 0))
                            y = float(weld.get("Y", 0))
                            z = float(weld.get("Z", 0))
                        except Exception:
                            progress_q.put(("warn", f"第 {idx + 1} 个坐标解析失败，跳过"))
                            continue
                        try:
                            pt = hsf.AddNewPointCoord(x, y, z)
                            if pt is None:
                                progress_q.put(("warn", f"第 {idx + 1} 个点创建失败"))
                                continue
                            target_body.AppendHybridShape(pt)
                            created_points.append(pt)
                        except Exception as e:
                            progress_q.put(("warn", f"第 {idx + 1} 个点创建异常: {str(e)}"))
                            continue

                        # 每创建 10 个点更新一次进度
                        if (idx + 1) % 10 == 0 or (idx + 1) == total:
                            progress_q.put(("progress", (idx + 1, total)))

                    # 一次性 Update 以生成引用
                    try:
                        part.Update()
                    except:
                        pass

                    # 2) 为每个点创建球体
                    success = 0
                    fail = 0
                    created_count = len(created_points)

                    for i, pt in enumerate(created_points):
                        if cancel_event.is_set():
                            progress_q.put(("info", f"已取消，已创建 {success} 个球体"))
                            return
                        try:
                            pt_ref = part.CreateReferenceFromObject(pt)
                            try:
                                sphere = hsf.AddNewSphere(pt_ref, None, radius, -90.0, 90.0, 0.0, 360.0)
                            except Exception:
                                sphere = hsf.AddNewSphere(pt_ref, None, radius)
                            if sphere is None:
                                fail += 1
                                continue
                            try:
                                target_body.AppendHybridShape(sphere)
                            except:
                                pass
                            try:
                                sphere.Name = f"{name_prefix}_{i + 1}"
                            except:
                                pass
                            success += 1

                            # 每 10 个刷新一次窗口
                            if i % 10 == 0:
                                try:
                                    doc.Windows.Item(1).Refresh()
                                except:
                                    pass
                            progress_q.put(("progress", (created_count + i + 1, created_count * 2)))
                        except Exception:
                            fail += 1
                            continue

                    # 最终 Update
                    try:
                        part.Update()
                        doc.Windows.Item(1).Refresh()
                    except:
                        pass

                    progress_q.put(("done", (success, fail)))

                finally:
                    pythoncom.CoUninitialize()
            except Exception:
                progress_q.put(("error", traceback.format_exc()))

        # 启动后台线程
        t = threading.Thread(target=worker, daemon=True)
        t.start()

        # 声明 QTimer 用于主线程轮询队列更新UI
        poll_timer = QTimer()

        def poll():
            try:
                while not progress_q.empty():
                    typ, val = progress_q.get_nowait()
                    if typ == "progress":
                        cur, tot = val
                        pct = int(min(100.0, (cur / max(1, tot)) * 100.0))
                        progress_bar.setValue(pct)
                        status_lbl.setText(f"处理中: {cur}/{tot}")
                        if parent_qt and hasattr(parent_qt, "status_label"):
                            parent_qt.status_label.setText(f"生成中: {cur}/{tot}")

                    elif typ == "warn":
                        print("WARN:", val)

                    elif typ == "info":
                        QMessageBox.information(progress_dialog, "信息", val)
                        if parent_qt and hasattr(parent_qt, "status_label"):
                            parent_qt.status_label.setText(val)
                        progress_dialog.accept()  # 关闭窗口

                    elif typ == "error":
                        QMessageBox.critical(progress_dialog, "生成球体失败", val)
                        status_lbl.setText("生成失败")
                        if parent_qt and hasattr(parent_qt, "status_label"):
                            parent_qt.status_label.setText("生成失败")
                        progress_dialog.accept()

                    elif typ == "done":
                        success, fail = val
                        QMessageBox.information(progress_dialog, "完成", f"已生成 {success} 个球体，失败 {fail} 个")
                        status_lbl.setText(f"完成: 成功 {success}，失败 {fail}")
                        if parent_qt and hasattr(parent_qt, "status_label"):
                            parent_qt.status_label.setText(f"完成: 成功 {success}，失败 {fail}")
                        progress_dialog.accept()
            except Exception:
                pass

            # 如果线程已经结束，停止定时器
            if not t.is_alive():
                poll_timer.stop()

        def on_cancel():
            reply = QMessageBox.question(progress_dialog, "取消", "确定要取消生成吗？",
                                         QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
            if reply == QMessageBox.Yes:
                cancel_event.set()
                status_lbl.setText("正在取消...")
                cancel_btn.setEnabled(False)  # 防重复点击

        cancel_btn.clicked.connect(on_cancel)

        # 启动轮询并阻塞显示对话框
        poll_timer.timeout.connect(poll)
        poll_timer.start(200)

        progress_dialog.exec_()

    def log_error(self, context, error):
        print(f"Error in {context}: {error}")
        traceback.print_exc()
        self.status_message = f"错误: {context}"


# ── CATIASphereScanner ──────────────────────────────────────────────────────
class CATIASphereScanner:
    def __init__(self, catia_app=None):
        self.catia_app = catia_app
        self.sphere_data = []

    def set_catia_app(self, catia_app):
        self.catia_app = catia_app

    def scan_selected_objects(self) -> List[Dict]:
        if not self.catia_app:
            raise Exception("CATIA 未连接")
        try:
            document = self.catia_app.active_document
            part_doc = PartDocument(document.com_object)
            part = part_doc.part
            selection = document.selection
            spa_workbench = part_doc.spa_workbench()
            count = selection.count
            if count == 0:
                return []
            self.sphere_data = []
            for i in range(1, count + 1):
                try:
                    selected_obj = selection.item(i).value
                    obj_name = getattr(selected_obj, 'name', f"Object_{i}")
                    reference = part.create_reference_from_object(selected_obj)
                    measurable = spa_workbench.get_measurable(reference)
                    cog = measurable.get_cog()
                    try:
                        volume = measurable.volume
                    except:
                        volume = 0
                    radius = (volume * 3 / (4 * 3.14159265359)) ** (1 / 3) if volume > 0 else 0
                    self.sphere_data.append({
                        "Name": obj_name,
                        "X": f"{cog[0]:.2f}",
                        "Y": f"{cog[1]:.2f}",
                        "Z": f"{cog[2]:.2f}",
                        "Radius": f"{radius:.2f}",
                        "Volume": round(volume, 3),
                        "Type": "实体" if volume > 0 else "几何图形",
                        "_coords": cog
                    })
                except Exception as e:
                    print(f"无法测量对象 {i}: {e}")
            return self.sphere_data
        except Exception as e:
            traceback.print_exc()
            return []

    def scan_all_bodies(self, search_keywords=None):
        if not self.catia_app:
            raise Exception("CATIA 未连接")
        try:
            document = self.catia_app.active_document
            part_doc = PartDocument(document.com_object)
            part = part_doc.part
            spa_workbench = part_doc.spa_workbench()
            self.sphere_data = []
            bodies = part.bodies
            for i in range(1, bodies.count + 1):
                body = bodies.item(i)
                if search_keywords:
                    if not any(kw.lower() in body.name.lower() for kw in search_keywords):
                        continue
                try:
                    reference = part.create_reference_from_object(body)
                    measurable = spa_workbench.get_measurable(reference)
                    cog = measurable.get_cog()
                    volume = measurable.volume
                    self.sphere_data.append({
                        "Name": body.name,
                        "X": f"{cog[0]:.2f}",
                        "Y": f"{cog[1]:.2f}",
                        "Z": f"{cog[2]:.2f}",
                        "Radius": f"{(volume * 3 / (4 * 3.14)) ** (1 / 3):.2f}" if volume > 0 else "0",
                        "Volume": round(volume, 3),
                        "Type": "Body",
                        "_coords": cog
                    })
                except:
                    continue
            return self.sphere_data
        except Exception as e:
            traceback.print_exc()
            return []

    def generate_points_at_centers(self, geometrical_set_name="Geometry_COG_Points") -> int:
        if not self.sphere_data:
            return 0
        try:
            part_doc = PartDocument(self.catia_app.active_document.com_object)
            part = part_doc.part
            hs_factory = part.hybrid_shape_factory
            hybrid_bodies = part.hybrid_bodies
            try:
                target_hb = hybrid_bodies.item(geometrical_set_name)
            except:
                target_hb = hybrid_bodies.add()
                target_hb.name = geometrical_set_name
            for data in self.sphere_data:
                x, y, z = data["_coords"]
                new_point = hs_factory.add_new_point_coord(x, y, z)
                new_point.name = f"COG_{data['Name']}"
                target_hb.append_hybrid_shape(new_point)
            part.update()
            return len(self.sphere_data)
        except Exception as e:
            print(f"生成点失败: {e}")
            return 0

    def get_data(self):
        return self.sphere_data


# ── CatiaGunPlacer ──────────────────────────────────────────────────────────
class CatiaGunPlacer:
    def __init__(self, catia_app=None):
        self.catia_app = catia_app
        self.connection_type = None
        self.status_message = "就绪"
        self.gun_template_path = ""
        self.rotation_order = 'kuka'

    def set_rotation_order(self, order: str):
        valid_orders = ['kuka', 'catia_zyx', 'catia_xyz']
        if order in valid_orders:
            self.rotation_order = order

    def set_catia_app(self, catia_app, connection_type='win32com'):
        self.catia_app = catia_app
        self.connection_type = connection_type
        self.status_message = f"CATIA 已连接 ({connection_type})"

    def is_catia_connected(self) -> bool:
        if not self.catia_app:
            return False
        try:
            if self.connection_type == 'pycatia':
                _ = self.catia_app.documents.count
            else:
                _ = self.catia_app.Documents.Count
            return True
        except:
            return False

    def has_active_product(self) -> bool:
        if not self.is_catia_connected():
            return False
        try:
            if self.connection_type == 'pycatia':
                doc = self.catia_app.active_document
                return hasattr(doc, 'product')
            else:
                doc = self.catia_app.ActiveDocument
                try:
                    _ = doc.Product
                    return True
                except:
                    return False
        except:
            return False

    def euler_to_rotation_matrix(self, rx, ry, rz, order=None):
        if order is None:
            order = self.rotation_order
        rx_r, ry_r, rz_r = math.radians(rx), math.radians(ry), math.radians(rz)
        Rx = np.array([[1,0,0],[0,math.cos(rx_r),-math.sin(rx_r)],[0,math.sin(rx_r),math.cos(rx_r)]])
        Ry = np.array([[math.cos(ry_r),0,math.sin(ry_r)],[0,1,0],[-math.sin(ry_r),0,math.cos(ry_r)]])
        Rz = np.array([[math.cos(rz_r),-math.sin(rz_r),0],[math.sin(rz_r),math.cos(rz_r),0],[0,0,1]])
        if order in ('kuka', 'catia_zyx'):
            return Rz @ Ry @ Rx
        else:
            return Rx @ Ry @ Rz

    def euler_to_catia_components(self, x, y, z, rx, ry, rz):
        R = self.euler_to_rotation_matrix(rx, ry, rz)
        return [R[0,0],R[1,0],R[2,0], R[0,1],R[1,1],R[2,1], R[0,2],R[1,2],R[2,2], x, y, z]

    def pose_to_matrix(self, x, y, z, rx, ry, rz, order=None):
        """
        辅助方法：将 6D 位姿（XYZ + 欧拉角）转换为 4x4 齐次变换矩阵
        """
        R = self.euler_to_rotation_matrix(rx, ry, rz, order)
        M = np.eye(4)
        M[:3, :3] = R
        M[0, 3] = x
        M[1, 3] = y
        M[2, 3] = z
        return M

    def get_kuka_correction_matrix(self, kuka_data):
        """
        [新增方法] 将库卡控制柜 TCP (X, Y, Z, A, B, C) 映射为 CATIA 修正矩阵
        """
        try:
            kx = float(kuka_data.get('X', 0))
            ky = float(kuka_data.get('Y', 0))
            kz = float(kuka_data.get('Z', 0))
            ka = float(kuka_data.get('A', 0))
            kb = float(kuka_data.get('B', 0))
            kc = float(kuka_data.get('C', 0))

            # 根据实测数据的映射规律 (补偿模板的建模朝向)
            cx = -kz
            cy = -ky
            cz = kx
            crx = kc
            cry = -kb
            crz = ka

            return self.pose_to_matrix(cx, cy, cz, crx, cry, crz)
        except Exception as e:
            print(f"TCP 转换失败: {e}")
            return np.eye(4)

    def place_guns_batch(self, gun_template, gun_data, progress_callback=None,
                         correction_values=None, rotation_order=None, kuka_tcp_input=None):
        """
        [完全替换原方法] 批量放置焊枪，支持库卡 TCP 矩阵变换与普通坐标偏移
        """
        if not self.is_catia_connected():
            return 0, 0, ["✗ CATIA 未连接"]
        if not self.has_active_product():
            return 0, 0, ["✗ 请先打开一个 Product 文档"]

        if rotation_order:
            self.set_rotation_order(rotation_order)

        gun_template_normalized = os.path.normpath(gun_template).replace('/', '\\')
        success_count, failed_count = 0, 0
        status_list = []

        # 1. 预计算修正矩阵
        import numpy as np
        M_corr = np.eye(4)
        if kuka_tcp_input:
            # 如果是 TCP 模式，生成库卡修正矩阵
            M_corr = self.get_kuka_correction_matrix(kuka_tcp_input)

        try:
            # 2. CATIA 环境与容器准备
            if self.connection_type == 'pycatia':
                doc = self.catia_app.active_document
                product = doc.product
                com_products = product.products.com_object
            else:
                doc = self.catia_app.ActiveDocument
                product = doc.Product
                com_products = product.Products

            from datetime import datetime as dt
            container_name = f"{product.Name if hasattr(product, 'Name') else 'Product'}-GUN-{dt.now().strftime('%Y%m%d_%H%M%S')}"

            try:
                container = com_products.AddNewComponent("Product", container_name)
                container_products = container.Products
            except Exception as e:
                print(f"创建容器失败: {e}，将直接在根节点下插入")
                container_products = com_products

            # 3. 循环插入焊枪并应用变换
            total = len(gun_data)
            for idx, gun in enumerate(gun_data):
                try:
                    # 获取当前焊枪的原始位姿
                    x = float(gun.get('X', 0))
                    y = float(gun.get('Y', 0))
                    z = float(gun.get('Z', 0))
                    rx = float(gun.get('Rx', 0))
                    ry = float(gun.get('Ry', 0))
                    rz = float(gun.get('Rz', 0))

                    # 如果没有勾选 TCP 且存在普通偏移，直接加到基础坐标上
                    if correction_values and not kuka_tcp_input:
                        x += float(correction_values.get('X', 0))
                        y += float(correction_values.get('Y', 0))
                        z += float(correction_values.get('Z', 0))
                        rx += float(correction_values.get('Rx', 0))
                        ry += float(correction_values.get('Ry', 0))
                        rz += float(correction_values.get('Rz', 0))

                    # 基础位姿矩阵
                    M_pose = self.pose_to_matrix(x, y, z, rx, ry, rz)

                    # 核心修正：矩阵乘法 M_final = M_pose * M_corr
                    M_final = M_pose @ M_corr

                    # 插入模型文件
                    file_array = (gun_template_normalized,)
                    container_products.AddComponentsFromFiles(file_array, "All")

                    import time
                    time.sleep(0.3)

                    # 获取刚刚插入的对象并重命名
                    count = container_products.Count
                    new_product = container_products.Item(count)
                    new_product.Name = gun.get('Name', f'Gun_{idx + 1}')

                    # 提取 CATIA 需要的 12 个分量
                    components = [
                        M_final[0, 0], M_final[1, 0], M_final[2, 0],
                        M_final[0, 1], M_final[1, 1], M_final[2, 1],
                        M_final[0, 2], M_final[1, 2], M_final[2, 2],
                        M_final[0, 3], M_final[1, 3], M_final[2, 3]
                    ]

                    # 设置最终位姿
                    new_product.Position.SetComponents(components)

                    success_count += 1
                    status_list.append("✓ 成功")
                    if progress_callback:
                        progress_callback(idx + 1, total, f"插入: {new_product.Name}")

                except Exception as e:
                    failed_count += 1
                    status_list.append(f"✗ {str(e)[:30]}")
                    print(f"插入第{idx + 1}个失败: {e}")

            # 4. 更新文档
            try:
                if self.connection_type == 'pycatia':
                    doc.product.update()
                else:
                    doc.Product.Update()
            except:
                pass

            self.status_message = f"完成 | 成功: {success_count} | 失败: {failed_count}"
            return success_count, failed_count, status_list

        except Exception as e:
            return success_count, failed_count, [f"✗ 致命错误: {str(e)}"]


# ============================================================================
# 样式助手
# ============================================================================
def _lighten(hex_color: str, factor: float = 1.18) -> str:
    """将 HEX 颜色调亮，用于 hover 状态。"""
    h = hex_color.lstrip('#')
    r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
    return "#{:02x}{:02x}{:02x}".format(min(255, int(r*factor)),
                                         min(255, int(g*factor)),
                                         min(255, int(b*factor)))

def _darken(hex_color: str, factor: float = 0.78) -> str:
    """将 HEX 颜色调暗，用于 pressed 状态。"""
    h = hex_color.lstrip('#')
    r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
    return "#{:02x}{:02x}{:02x}".format(int(r*factor), int(g*factor), int(b*factor))

def make_btn(text, color, callback=None, width=None, height=None):
    """创建带悬停/按下变色特效的按钮。"""
    btn = QPushButton(text)
    hov = _lighten(color)      # 悬停时变亮
    prs = _darken(color)       # 按下时变暗
    btn.setStyleSheet(
        f"QPushButton {{"
        f"  background-color: {color}; color: white;"
        f"  border: none; border-radius: 4px;"
        f"  padding: 5px 12px; font-size: 13px;"
        f"}}"
        f"QPushButton:hover {{"
        f"  background-color: {hov};"
        f"  border-bottom: 2px solid {prs};"
        f"}}"
        f"QPushButton:pressed {{"
        f"  background-color: {prs};"
        f"  border-top: 2px solid {hov};"
        f"  padding-top: 7px;"
        f"}}"
        f"QPushButton:disabled {{"
        f"  background-color: #aab7b8; color: #ecf0f1;"
        f"}}"
    )
    if callback:
        btn.clicked.connect(callback)
    if width:
        btn.setFixedWidth(width)
    if height:
        btn.setFixedHeight(height)
    return btn


# ============================================================================
# 页面 1：项目路径管理
# ============================================================================
class ProjectManagerPage(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.search_paths = []
        self.df_data = pd.DataFrame(
            columns=["Company", "Plant", "Area", "Project Name",
                     "Project Code", "File Name", "Full Path", "System Root"])
        self.current_preview_pixmap = None
        self._preview_raw_image = None
        self._setup_ui()
        self.load_local_config()

    def _setup_ui(self):
        root_layout = QVBoxLayout(self)
        root_layout.setContentsMargins(0, 0, 0, 0)
        root_layout.setSpacing(0)

        # ── 顶部工具栏 ───────────────────────────────────────────────────────
        toolbar = QFrame()
        toolbar.setStyleSheet("background-color:#34495e;")
        toolbar.setFixedHeight(50)
        tb_layout = QHBoxLayout(toolbar)
        tb_layout.setContentsMargins(10, 5, 10, 5)

        tb_layout.addWidget(QLabel("🔍 搜索项目:", styleSheet="color:white;"))
        self.search_edit = QLineEdit()
        self.search_edit.setFixedWidth(220)
        self.search_edit.setStyleSheet("color: white")
        self.search_edit.textChanged.connect(self.refresh_tree)
        tb_layout.addWidget(self.search_edit)

        tb_layout.addWidget(QLabel("  🏢 公司筛选:", styleSheet="color:white;"))
        self.combo_company = QComboBox()
        self.combo_company.setFixedWidth(140)
        self.combo_company.addItem("全部公司")
        self.combo_company.setStyleSheet("""
            QComboBox { 
                color: white; 
            }
            QComboBox QAbstractItemView {
                color: white;
            }
        """)
        self.combo_company.currentTextChanged.connect(self.refresh_tree)
        tb_layout.addWidget(self.combo_company)

        tb_layout.addStretch()
        tb_layout.addWidget(make_btn("打开Catia", "#3498db", self.open_catia))
        tb_layout.addWidget(make_btn("＋ 添加目录", "#3498db", self.add_search_folder))
        tb_layout.addWidget(make_btn("🔄 深度扫描", "#27ae60", self.scan_files))
        tb_layout.addWidget(make_btn("💾 保存修改", "#f1c40f", self.save_config))
        root_layout.addWidget(toolbar)

        # ── 主体分割 ─────────────────────────────────────────────────────────
        splitter = QSplitter(Qt.Horizontal)

        # 左侧树
        left = QWidget()
        left_layout = QVBoxLayout(left)
        left_layout.setContentsMargins(4, 4, 4, 4)

        self.tree = QTreeWidget()
        self.tree.setColumnCount(7)
        self.tree.setHeaderLabels(
            ["组织架构", "项目代号", "状态", "文件路径", "文件名", "大小", "修改时间"])
        self.tree.header().setSectionResizeMode(0, QHeaderView.ResizeToContents)
        self.tree.header().setSectionResizeMode(3, QHeaderView.Stretch)
        self.tree.setAlternatingRowColors(True)
        self.tree.setSelectionMode(QAbstractItemView.SingleSelection)
        self.tree.itemSelectionChanged.connect(self.on_item_select)
        self.tree.itemDoubleClicked.connect(lambda item, _: self.launch_pdps())

        # 右键菜单
        self.tree.setContextMenuPolicy(Qt.CustomContextMenu)
        self.tree.customContextMenuRequested.connect(self._show_tree_context_menu)

        left_layout.addWidget(self.tree)
        splitter.addWidget(left)
        splitter.setSizes([900, 300])

        # 右侧详情
        right = QWidget()
        right.setStyleSheet("background:#ecf0f1;")
        right_layout = QVBoxLayout(right)
        right_layout.setContentsMargins(12, 8, 12, 8)

        right_layout.addWidget(QLabel("项目预览", styleSheet="font-weight:bold;"))
        self.lbl_preview = QLabel()
        self.lbl_preview.setMinimumHeight(160)
        self.lbl_preview.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
        self.lbl_preview.setAlignment(Qt.AlignCenter)
        self.lbl_preview.setStyleSheet("background:black;color:white;border-radius:4px;")
        self.lbl_preview.setText("无预览图")
        self._preview_raw_image = None   # 保存原始 PIL Image 供缩放用
        right_layout.addWidget(self.lbl_preview)

        # 编辑字段
        self.entries: Dict[str, QLineEdit] = {}
        form = QFormLayout()
        for label, key in [("所属公司:", "Company"), ("所在厂房:", "Plant"),
                            ("所属区域:", "Area"), ("项目名称:", "Project Name"),
                            ("项目代号:", "Project Code")]:
            e = QLineEdit()
            self.entries[key] = e
            form.addRow(label, e)
        right_layout.addLayout(form)

        lbl_root = QLabel("System Root (修改将同步同级文件):")
        lbl_root.setStyleSheet("color:#e67e22;font-weight:bold;")
        right_layout.addWidget(lbl_root)
        self.txt_root = QTextEdit()
        self.txt_root.setFixedHeight(80)
        self.txt_root.setFont(QFont("Consolas", 9))
        right_layout.addWidget(self.txt_root)

        right_layout.addWidget(make_btn("🔥 确认修改并同步", "#34495e",
                                        self.update_metadata_and_sync, height=32))
        right_layout.addWidget(make_btn("📂 定位文件位置", "#bdc3c7",
                                        self.open_folder, height=28))
        right_layout.addStretch()
        right_layout.addWidget(make_btn("🚀 启动项目", "#27ae60",
                                        self.launch_pdps, height=42))

        self.status_lbl = QLabel("就绪")
        self.status_lbl.setStyleSheet("color:#7f8c8d;font-size:11px;")
        right_layout.addWidget(self.status_lbl)

        splitter.addWidget(right)
        root_layout.addWidget(splitter)

    # ── 右键菜单 ─────────────────────────────────────────────────────────────
    def _show_tree_context_menu(self, pos):
        item = self.tree.itemAt(pos)
        if item and item.data(0, Qt.UserRole) is not None:
            menu = QMenu(self)
            menu.addAction("复制完整路径", self.copy_full_path)
            menu.addAction("打开所在文件夹", self.open_folder)
            menu.addSeparator()
            menu.addAction("查看文件属性", self.show_file_properties)
            menu.exec_(self.tree.mapToGlobal(pos))

    def copy_full_path(self):
        item = self._selected_file_item()
        if item:
            idx = item.data(0, Qt.UserRole)
            path = self.df_data.loc[idx, "Full Path"]
            QApplication.clipboard().setText(path)
            self.status_lbl.setText(f"已复制: {path}")

    def show_file_properties(self):
        item = self._selected_file_item()
        if not item:
            return
        idx = item.data(0, Qt.UserRole)
        row = self.df_data.loc[idx]
        full_path = row["Full Path"]
        if os.path.exists(full_path):
            size = os.path.getsize(full_path)
            mtime = datetime.fromtimestamp(os.path.getmtime(full_path)).strftime('%Y-%m-%d %H:%M:%S')
            info = (f"路径: {full_path}\n大小: {size/1024:.2f} KB\n修改时间: {mtime}\n"
                    f"公司: {row['Company']}\n厂房: {row['Plant']}\n"
                    f"项目: {row['Project Name']}\n代号: {row['Project Code']}")
            QMessageBox.information(self, "文件属性", info)
        else:
            QMessageBox.warning(self, "警告", "文件不存在")

    def _selected_file_item(self):
        items = self.tree.selectedItems()
        if items and items[0].data(0, Qt.UserRole) is not None:
            return items[0]
        return None

    # ── 核心逻辑 ─────────────────────────────────────────────────────────────
    def auto_extract_info(self, psz_path):
        path_parts = os.path.normpath(psz_path).split(os.sep)
        psz_dir = os.path.dirname(psz_path)
        info = {"Company": "", "Plant": "", "Area": "默认区域",
                "Project Name": "", "Project Code": "", "System Root": ""}
        try:
            subfolders = [f for f in os.listdir(psz_dir) if os.path.isdir(os.path.join(psz_dir, f))]
            if any("library" in f.lower() for f in subfolders):
                lib = next(f for f in subfolders if "library" in f.lower())
                info["System Root"] = os.path.normpath(os.path.join(psz_dir, lib))
                info["Area"] = "项目根目录" if "项目" in os.path.basename(psz_dir) else os.path.basename(psz_dir)
            else:
                info["System Root"] = os.path.normpath(os.path.join(psz_dir, ".."))
        except:
            pass

        proj_idx = next((i for i, p in enumerate(path_parts) if "项目" in p), -1)
        comp_idx = next((i for i, p in enumerate(path_parts) if "公司" in p), -1)

        if proj_idx != -1:
            part = path_parts[proj_idx]
            bracket = re.search(r'[（(]([^）)]+)[）)]', part)
            if bracket:
                info["Project Code"] = bracket.group(1).strip()
                info["Project Name"] = part[:bracket.start()].strip()
            else:
                info["Project Name"] = part
            if proj_idx > 0:
                info["Plant"] = path_parts[proj_idx - 1]
            info["Company"] = path_parts[comp_idx] if comp_idx != -1 else (
                path_parts[proj_idx - 2] if proj_idx > 1 else "")
        elif comp_idx != -1:
            info["Company"] = path_parts[comp_idx]
            info["Project Name"] = "未识别项目"

        if not info["Company"]: info["Company"] = "通用客户"
        if not info["Plant"]: info["Plant"] = "未知厂房"
        if not info["Project Name"]: info["Project Name"] = os.path.basename(psz_path)
        return info

    def refresh_tree(self):
        self.tree.clear()
        df = self.df_data.copy()
        company_filter = self.combo_company.currentText()
        if company_filter != "全部公司":
            df = df[df["Company"] == company_filter]
        kw = self.search_edit.text().strip().lower()
        if kw:
            df = df[df.apply(lambda r: kw in str(r.values).lower(), axis=1)]

        # 更新公司下拉框
        companies = ["全部公司"] + sorted(self.df_data["Company"].unique().tolist())
        current = self.combo_company.currentText()
        self.combo_company.blockSignals(True)
        self.combo_company.clear()
        self.combo_company.addItems(companies)
        idx = self.combo_company.findText(current)
        self.combo_company.setCurrentIndex(max(0, idx))
        self.combo_company.blockSignals(False)

        for c, c_grp in df.groupby("Company"):
            company_node = QTreeWidgetItem(self.tree, [f"🏢 {c}"])
            company_node.setForeground(0, QColor("#2c3e50"))
            for p, p_grp in c_grp.groupby("Plant"):
                plant_node = QTreeWidgetItem(company_node, [f"🏭 {p}"])
                for pr, pr_grp in p_grp.groupby("Project Name"):
                    proj_node = QTreeWidgetItem(plant_node, [f"📂 {pr}", pr_grp.iloc[0]["Project Code"]])
                    for a, a_grp in pr_grp.groupby("Area"):
                        area_node = QTreeWidgetItem(proj_node, [f"📁 {a}"])
                        for idx2, row in a_grp.iterrows():
                            fp = row["Full Path"]
                            size_str, mtime_str, status = "N/A", "N/A", "Missing"
                            if os.path.exists(fp):
                                sz = os.path.getsize(fp)
                                size_str = f"{sz/1024:.1f} KB" if sz < 1024*1024 else f"{sz/1024/1024:.1f} MB"
                                mtime_str = datetime.fromtimestamp(os.path.getmtime(fp)).strftime('%Y-%m-%d %H:%M')
                                status = "Ready"
                            file_node = QTreeWidgetItem(area_node, [
                                f"📄 {row['File Name']}", "", status, fp,
                                row['File Name'], size_str, mtime_str])
                            file_node.setData(0, Qt.UserRole, idx2)
                            if status == "Missing":
                                file_node.setForeground(2, QColor("#e74c3c"))
                            else:
                                file_node.setForeground(2, QColor("#27ae60"))

        if kw:
            self.tree.expandAll()

    def on_item_select(self):
        item = self._selected_file_item()
        if not item:
            return
        idx = item.data(0, Qt.UserRole)
        row = self.df_data.loc[idx]
        for k, e in self.entries.items():
            e.setText(str(row.get(k, "")))
        self.txt_root.setPlainText(str(row.get("System Root", "")))
        self.load_preview(row["Full Path"])

    def update_metadata_and_sync(self):
        item = self._selected_file_item()
        if not item:
            return
        idx = item.data(0, Qt.UserRole)
        curr_dir = os.path.dirname(self.df_data.loc[idx, "Full Path"])
        new_root = self.txt_root.toPlainText().strip()
        new_values = {k: e.text() for k, e in self.entries.items()}
        new_values["System Root"] = new_root

        mask = ((self.df_data.index != idx) &
                (self.df_data["Full Path"].apply(lambda x: os.path.dirname(x)) == curr_dir))
        sync_indices = self.df_data[mask].index.tolist()

        for col, value in new_values.items():
            self.df_data.at[idx, col] = value
            if col in self.df_data.columns and sync_indices:
                self.df_data.loc[sync_indices, col] = value

        self.refresh_tree()
        if sync_indices:
            QMessageBox.information(self, "同步成功", f"已更新同级 {len(sync_indices)} 个文件")

    def open_folder(self):
        item = self._selected_file_item()
        if not item:
            return
        idx = item.data(0, Qt.UserRole)
        fp = os.path.normpath(self.df_data.loc[idx, "Full Path"])
        subprocess.run(['explorer', '/select,', fp])

    def open_catia(self):
        def get_catia_path():
            reg_paths = [(r"SOFTWARE\Dassault Systemes\B32\0", "DEST_FOLDER_OSDS"),
                         (r"SOFTWARE\Dassault Systemes\B28\0", "DEST_FOLDER_OSDS")]
            for root_key in [winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER]:
                for rp, val in reg_paths:
                    try:
                        with winreg.OpenKey(root_key, rp) as key:
                            install_dir, _ = winreg.QueryValueEx(key, val)
                            for exe in [r"code\bin\CNEXT.exe", r"code\bin\CATSTART.exe"]:
                                p = os.path.join(install_dir, exe)
                                if os.path.exists(p):
                                    return p
                    except:
                        pass
            return None

        catia_exe = get_catia_path()
        if not catia_exe:
            catia_exe, _ = QFileDialog.getOpenFileName(
                self, "选择 CATIA 可执行文件",
                r"C:\Program Files\Dassault Systemes",
                "Executable (*.exe)")
            if not catia_exe:
                return
        try:
            subprocess.Popen([catia_exe], cwd=os.path.dirname(catia_exe))
            QMessageBox.information(self, "成功", "CATIA 正在启动...")
        except Exception as e:
            QMessageBox.critical(self, "启动失败", f"无法启动 CATIA:\n{str(e)}")

    def launch_pdps(self):
        item = self._selected_file_item()
        if not item:
            return
        idx = item.data(0, Qt.UserRole)
        row = self.df_data.loc[idx]
        if str(row.get("System Root", "")).strip():
            try:
                key = winreg.CreateKey(winreg.HKEY_CURRENT_USER, REG_PATH)
                winreg.SetValueEx(key, "System Root Path", 0, winreg.REG_SZ, row["System Root"])
                winreg.CloseKey(key)
            except Exception as e:
                print(f"注册表写入失败: {e}")
        if os.path.exists(row["Full Path"]):
            os.startfile(row["Full Path"])
        else:
            QMessageBox.critical(self, "错误", "文件不存在")

    def scan_files(self):
        if not self.search_paths:
            return
        existing = {row["Full Path"]: row.to_dict() for _, row in self.df_data.iterrows()}
        new_list = []
        for bp in self.search_paths:
            for root, _, files in os.walk(bp):
                for f in files:
                    if f.lower().endswith(".psz"):
                        path = os.path.normpath(os.path.join(root, f))
                        if path in existing:
                            new_list.append(existing[path])
                        else:
                            rec = {"File Name": f, "Full Path": path}
                            rec.update(self.auto_extract_info(path))
                            new_list.append(rec)
        self.df_data = pd.DataFrame(new_list).drop_duplicates(subset=["Full Path"])
        self.refresh_tree()

    def load_preview(self, path):
        self._preview_raw_image = None
        try:
            with zipfile.ZipFile(path, 'r') as z:
                if "Preview Images/previmg.jpg" in z.namelist():
                    with z.open("Preview Images/previmg.jpg") as f:
                        self._preview_raw_image = Image.open(f).copy()
        except Exception as e:
            print(f"预览图加载失败: {e}")
        self._update_preview_display()

    def _update_preview_display(self):
        """根据当前 lbl_preview 的实际宽度缩放并显示预览图。"""
        if self._preview_raw_image is None:
            self.lbl_preview.setPixmap(QPixmap())
            self.lbl_preview.setText("无预览图")
            return
        w = max(self.lbl_preview.width(), 100)
        h = max(int(w * 0.65), 120)          # 保持约 3:2 比例
        self.lbl_preview.setFixedHeight(h)
        img = self._preview_raw_image.copy()
        img.thumbnail((w - 4, h - 4), Image.Resampling.LANCZOS)
        data = img.convert("RGBA").tobytes("raw", "RGBA")
        qimg = QImage(data, img.width, img.height, QImage.Format_RGBA8888)
        self.lbl_preview.setPixmap(QPixmap.fromImage(qimg))
        self.lbl_preview.setText("")

    def resizeEvent(self, event):
        """窗口/面板大小变化时同步刷新预览图缩放。"""
        super().resizeEvent(event)
        self._update_preview_display()

    def add_search_folder(self):
        d = QFileDialog.getExistingDirectory(self, "选择搜索目录")
        if d:
            self.search_paths.append(d)
            self.scan_files()

    def save_config(self):
        self.df_data.to_excel(CONFIG_FILE, index=False)
        with open("paths_config.ini", "w") as f:
            f.write(",".join(self.search_paths))
        QMessageBox.information(self, "保存", "本地数据库已更新")

    def load_local_config(self):
        if os.path.exists(CONFIG_FILE):
            self.df_data = pd.read_excel(CONFIG_FILE).fillna("")
            self.refresh_tree()
        if os.path.exists("paths_config.ini"):
            with open("paths_config.ini", "r") as f:
                self.search_paths = f.read().split(",")


# ============================================================================
# 页面 2：CATIA 工具箱
# ============================================================================
class ToolBoxPage(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.catia_app = None
        self.weld_extractor = CATIAWeldPointExtractor()
        self.sphere_scanner = CATIASphereScanner()
        self._setup_ui()
        self.try_auto_connect_catia()

    def _setup_ui(self):
        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)

        # 标题栏
        title_bar = QFrame()
        title_bar.setStyleSheet("background:#34495e;")
        title_bar.setFixedHeight(52)
        tb_layout = QHBoxLayout(title_bar)
        title_text = "🛠️ CATIA 焊点处理工具"
        if not PYCATIA_AVAILABLE:
            title_text += "  ⚠️ pycatia 未安装"
        lbl = QLabel(title_text)
        lbl.setStyleSheet("color:white;font-size:15px;font-weight:bold;")
        tb_layout.addWidget(lbl)
        layout.addWidget(title_bar)

        # 主体
        scroll = QScrollArea()
        scroll.setWidgetResizable(True)
        container = QWidget()
        container.setStyleSheet("background:#ecf0f1;")
        main_layout = QVBoxLayout(container)
        main_layout.setContentsMargins(30, 20, 30, 20)
        main_layout.setSpacing(20)

        # ── 工具1：焊点导出 ────────────────────────────────────────────────
        weld_group = QGroupBox("📍 焊点数据导出")
        weld_group.setStyleSheet("QGroupBox{font-size:13px;font-weight:bold;}")
        weld_v = QVBoxLayout(weld_group)

        btn_row1 = QHBoxLayout()
        btn_row1.addWidget(make_btn("🔗 连接 CATIA", "#3498db", self.connect_catia, height=40))
        btn_row1.addWidget(make_btn("📊 提取焊点", "#e67e22", self.extract_weld_points, height=40))
        btn_row1.addWidget(make_btn("💾 导出 Excel", "#27ae60", self.export_welds_to_excel, height=40))
        btn_row1.addWidget(make_btn("📥 导入数据", "#9b59b6", self.import_weld_data, height=40))

        ball_widget = QWidget()
        ball_layout = QHBoxLayout(ball_widget)
        ball_layout.setContentsMargins(0, 0, 0, 0)
        ball_layout.addWidget(make_btn("💾 生成点球", "#27ae60", self.newball, height=40))
        self.auto_rename_chk = QCheckBox("按标准自动重命名")
        ball_layout.addWidget(self.auto_rename_chk)
        btn_row1.addWidget(ball_widget)
        btn_row1.addStretch()
        weld_v.addLayout(btn_row1)

        self.weld_table = QTreeWidget()
        self.weld_table.setColumnCount(8)
        self.weld_table.setHeaderLabels(
            ["Class", "ExternalId", "Name", "Location", "X", "Y", "Z", "Type"])
        self.weld_table.setFixedHeight(220)
        self.weld_table.header().setSectionResizeMode(QHeaderView.ResizeToContents)
        self.weld_table.header().setSectionResizeMode(3, QHeaderView.Stretch)
        weld_v.addWidget(self.weld_table)
        main_layout.addWidget(weld_group)

        # ── 工具2：几何体重心 ─────────────────────────────────────────────
        sphere_group = QGroupBox("🔵 几何体重心提取")
        sphere_group.setStyleSheet("QGroupBox{font-size:13px;font-weight:bold;}")
        sphere_v = QVBoxLayout(sphere_group)

        btn_row2 = QHBoxLayout()
        btn_row2.addWidget(make_btn("🔍 扫描所有", "#9b59b6", self.scan_all, height=40))
        btn_row2.addWidget(make_btn("🎯 扫描选中", "#3498db", self.scan_selected, height=40))
        btn_row2.addWidget(make_btn("📝 生成重心点", "#e74c3c", self.generate_points, height=40))
        btn_row2.addWidget(make_btn("💾 导出坐标", "#27ae60", self.export_sphere_coords, height=40))
        btn_row2.addStretch()
        sphere_v.addLayout(btn_row2)

        self.sphere_table = QTreeWidget()
        self.sphere_table.setColumnCount(5)
        self.sphere_table.setHeaderLabels(["Name", "X", "Y", "Z", "Radius"])
        self.sphere_table.setFixedHeight(220)
        self.sphere_table.header().setSectionResizeMode(0, QHeaderView.Stretch)
        sphere_v.addWidget(self.sphere_table)
        main_layout.addWidget(sphere_group)

        main_layout.addStretch()
        scroll.setWidget(container)
        layout.addWidget(scroll)

        # 状态栏
        self.status_label = QLabel("就绪 | 使用 pycatia")
        self.status_label.setStyleSheet(
            "background:#34495e;color:white;padding:4px 10px;font-size:11px;")
        layout.addWidget(self.status_label)

    def try_auto_connect_catia(self):
        """
        [优化版] 启动时静默尝试连接 CATIA
        """
        # 1. 初始状态设置（橙色：检测中）
        self.status_label.setText("🔄 正在自动检测 CATIA 实例...")
        self.status_label.setStyleSheet("background:#f39c12; color:white; padding:4px 10px; font-size:11px;")
        QApplication.processEvents()  # 刷新UI显示

        try:
            import win32com.client
            import pythoncom

            # 2. 核心检测：只获取已打开的，不主动创建新进程
            try:
                # 尝试抓取现有 CATIA
                raw_catia = win32com.client.GetActiveObject("CATIA.Application")
            except pythoncom.com_error:
                # 捕获错误：说明 CATIA 没开
                self.status_label.setText("⚠️ CATIA 未启动 (请先开启 CATIA 后手动连接)")
                self.status_label.setStyleSheet("background:#e74c3c; color:white; padding:4px 10px; font-size:11px;")
                return

            # 3. 既然检测到了，则执行正式连接逻辑
            if PYCATIA_AVAILABLE:
                self.catia_app = pycatia_catia()
                conn_type = 'pycatia'
            else:
                self.catia_app = raw_catia
                conn_type = 'win32com'

            # 4. 初始化子工具类
            self.weld_extractor.set_catia_app(self.catia_app, conn_type)
            self.sphere_scanner.set_catia_app(self.catia_app)

            # 5. 更新 UI 为成功状态（绿色）
            self.status_label.setText(f"✅ CATIA 已连接 ({conn_type})")
            self.status_label.setStyleSheet("background:#27ae60; color:white; padding:4px 10px; font-size:11px;")

        except Exception as e:
            self.status_label.setText(f"❌ 连接异常: {str(e)[:20]}")
            self.status_label.setStyleSheet("background:#c0392b; color:white; padding:4px 10px; font-size:11px;")

    def connect_catia(self):
        """
        [优化版] 手动点击“连接 CATIA”按钮触发的逻辑
        """
        # 复用自动连接的逻辑
        self.try_auto_connect_catia()

        # 根据连接结果弹出反馈
        if self.catia_app:
            QMessageBox.information(self, "连接成功", "已成功建立与 CATIA 的通讯链路。")
        else:
            QMessageBox.warning(self, "连接失败",
                                "未检测到运行中的 CATIA 实例。\n\n"
                                "请检查：\n"
                                "1. CATIA 是否已经完全启动？\n"
                                "2. 是否有多个 CATIA 进程冲突？")

    def extract_weld_points(self):
        if not self.catia_app:
            QMessageBox.warning(self, "警告", "请先连接 CATIA")
            return
        self.weld_table.clear()
        auto_rename = self.auto_rename_chk.isChecked()
        weld_data = self.weld_extractor.extract_weld_points(auto_rename=auto_rename)
        for d in weld_data:
            item = QTreeWidgetItem([
                d["Class"], d["ExternalId"], d["Name"],
                d["Location"], str(d["X"]), str(d["Y"]), str(d["Z"]), d["Type"]
            ])
            self.weld_table.addTopLevelItem(item)
        self.status_label.setText(self.weld_extractor.get_status())

    def export_welds_to_excel(self):
        data = self.weld_extractor.weld_points_data
        if not data:
            QMessageBox.warning(self, "警告", "没有数据可导出")
            return
        self._export_data(data, "焊点数据.xlsx")

    def import_weld_data(self):
        fp, _ = QFileDialog.getOpenFileName(
            self, "选择数据文件", "",
            "Excel文件 (*.xlsx *.xls);;CSV文件 (*.csv);;所有文件 (*.*)")
        if not fp:
            return
        try:
            if fp.endswith('.csv'):
                df = pd.read_csv(fp)
            else:
                df = pd.read_excel(fp)
            cols = df.columns.tolist()
            x_col = next((c for c in cols if c.upper() in ('X',)), None)
            y_col = next((c for c in cols if c.upper() in ('Y',)), None)
            z_col = next((c for c in cols if c.upper() in ('Z',)), None)
            if not all([x_col, y_col, z_col]):
                QMessageBox.critical(self, "错误", "文件缺少 X/Y/Z 列")
                return
            name_col = next((c for c in cols if c.lower() in ('name', '名称')), None)
            self.weld_extractor.weld_points_data = []
            self.weld_table.clear()
            ok, fail = 0, 0
            for i, row in df.iterrows():
                try:
                    x, y, z = float(row[x_col]), float(row[y_col]), float(row[z_col])
                    name = str(row[name_col]) if name_col else f"Point_{i+1}"
                    d = {"Class": "GeoPoint", "ExternalId": name, "Name": name,
                         "Location": fp, "X": round(x,3), "Y": round(y,3),
                         "Z": round(z,3), "Type": "RSW"}
                    self.weld_extractor.weld_points_data.append(d)
                    self.weld_table.addTopLevelItem(QTreeWidgetItem([
                        d["Class"], d["ExternalId"], d["Name"],
                        d["Location"], str(d["X"]), str(d["Y"]), str(d["Z"]), d["Type"]
                    ]))
                    ok += 1
                except:
                    fail += 1
            QMessageBox.information(self, "导入成功", f"成功: {ok}，失败: {fail}")
            self.status_label.setText(f"已导入 {ok} 个焊点")
        except Exception as e:
            QMessageBox.critical(self, "导入失败", str(e))

    def newball(self):
        self.weld_extractor.generate_spheres_from_points()

    def _simple_input(self, title, label, default=""):
        dialog = QDialog(self)
        dialog.setWindowTitle(title)
        v = QVBoxLayout(dialog)
        v.addWidget(QLabel(label))
        edit = QLineEdit(default)
        v.addWidget(edit)
        btns = QHBoxLayout()
        ok_btn = QPushButton("确定")
        cancel_btn = QPushButton("取消")
        ok_btn.clicked.connect(dialog.accept)
        cancel_btn.clicked.connect(dialog.reject)
        btns.addWidget(ok_btn)
        btns.addWidget(cancel_btn)
        v.addLayout(btns)
        result = dialog.exec_()
        return edit.text(), result == QDialog.Accepted

    def scan_all(self):
        if not self.catia_app:
            QMessageBox.warning(self, "警告", "请先连接 CATIA")
            return
        try:
            data = self.sphere_scanner.scan_all_bodies()
            self._refresh_sphere_table(data)
            self.status_label.setText(f"已扫描 {len(data)} 个几何体")
        except Exception as e:
            QMessageBox.critical(self, "错误", str(e))

    def scan_selected(self):
        if not self.catia_app:
            QMessageBox.warning(self, "警告", "请先连接 CATIA")
            return
        try:
            data = self.sphere_scanner.scan_selected_objects()
            self._refresh_sphere_table(data)
            self.status_label.setText(f"已扫描 {len(data)} 个选中几何体")
        except Exception as e:
            QMessageBox.critical(self, "错误", str(e))

    def _refresh_sphere_table(self, data):
        self.sphere_table.clear()
        for d in data:
            self.sphere_table.addTopLevelItem(QTreeWidgetItem([
                d["Name"], d["X"], d["Y"], d["Z"], d["Radius"]]))

    def generate_points(self):
        if not self.sphere_scanner.get_data():
            QMessageBox.warning(self, "警告", "请先扫描几何体")
            return
        try:
            count = self.sphere_scanner.generate_points_at_centers()
            QMessageBox.information(self, "完成", f"已生成 {count} 个重心点")
        except Exception as e:
            QMessageBox.critical(self, "错误", str(e))

    def export_sphere_coords(self):
        sphere_data = self.sphere_scanner.get_data()
        if not sphere_data:
            QMessageBox.warning(self, "警告", "没有数据可导出")
            return
        export_data = [{k: v for k, v in s.items() if k != "_coords"} for s in sphere_data]
        self._export_data(export_data, "几何体重心数据.xlsx")

    def _export_data(self, data, default_name):
        fp, _ = QFileDialog.getSaveFileName(
            self, "导出数据", default_name,
            "Excel文件 (*.xlsx);;CSV文件 (*.csv);;所有文件 (*.*)")
        if not fp:
            return
        try:
            if fp.endswith('.csv'):
                pd.DataFrame(data).to_csv(fp, index=False, encoding='utf-8-sig')
            else:
                pd.DataFrame(data).to_excel(fp, index=False)
            QMessageBox.information(self, "成功", f"导出完成\n文件: {fp}")
        except PermissionError:
            QMessageBox.critical(self, "错误", "文件被占用，请关闭后重试")
        except Exception as e:
            QMessageBox.critical(self, "错误", str(e))


# ============================================================================
# 页面 3：插枪工具
# ============================================================================
class EditableTableWidget(QTableWidget):
    """支持 Excel 粘贴的可编辑表格"""
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setContextMenuPolicy(Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self._show_context_menu)

    def keyPressEvent(self, event):
        if event.key() == Qt.Key_V and event.modifiers() == Qt.ControlModifier:
            self._paste_from_clipboard()
        else:
            super().keyPressEvent(event)

    def _show_context_menu(self, pos):
        menu = QMenu(self)
        menu.addAction("📋 粘贴 (Ctrl+V)", self._paste_from_clipboard)
        menu.addAction("➕ 添加行", self.add_row)
        menu.addAction("🗑️ 删除行", self.delete_selected_rows)
        menu.addSeparator()
        menu.addAction("📊 从Excel文件导入", self._paste_from_excel_file)
        menu.exec_(self.mapToGlobal(pos))

    def add_row(self):
        row = self.rowCount()
        self.insertRow(row)
        defaults = ["New_Gun", "PmWeldLocationOperation", "0", "0", "0", "0", "0", "0", "待插入"]
        for col, val in enumerate(defaults):
            self.setItem(row, col, QTableWidgetItem(val))

    def delete_selected_rows(self):
        rows = sorted(set(i.row() for i in self.selectedItems()), reverse=True)
        for r in rows:
            self.removeRow(r)

    def _paste_from_clipboard(self):
        text = QApplication.clipboard().text()
        if not text:
            return
        lines = text.strip().split('\n')
        start_row = self.currentRow() if self.currentRow() >= 0 else self.rowCount()
        for line in lines:
            vals = line.split('\t') if '\t' in line else line.split()
            if len(vals) >= 8:
                final = vals[:8] + ["待插入"]
            elif len(vals) >= 7:
                final = [vals[0], "PmWeldLocationOperation"] + vals[1:7] + ["待插入"]
            else:
                while len(vals) < 7:
                    vals.append("0")
                final = [vals[0], "PmWeldLocationOperation"] + vals[1:7] + ["待插入"]
            if start_row >= self.rowCount():
                self.insertRow(self.rowCount())
            for col, v in enumerate(final[:9]):
                self.setItem(start_row, col, QTableWidgetItem(v))
            start_row += 1

    def _paste_from_excel_file(self):
        fp, _ = QFileDialog.getOpenFileName(
            self, "选择 Excel 文件", "",
            "Excel 文件 (*.xlsx *.xls);;所有文件 (*.*)")
        if not fp:
            return
        try:
            df = pd.read_excel(fp)
            required = ['Name', 'X', 'Y', 'Z']
            missing = [c for c in required if c not in df.columns]
            if missing:
                QMessageBox.critical(self, "错误", f"Excel 缺少必需列: {', '.join(missing)}")
                return
            self.setRowCount(0)
            for _, row in df.iterrows():
                if pd.isna(row['Name']):
                    continue
                r = self.rowCount()
                self.insertRow(r)
                vals = [
                    str(row['Name']).strip(),
                    str(row.get('Type', 'PmWeldLocationOperation')).strip(),
                    str(row.get('X', 0)), str(row.get('Y', 0)), str(row.get('Z', 0)),
                    str(row.get('Rx', 0)), str(row.get('Ry', 0)), str(row.get('Rz', 0)),
                    "待插入"
                ]
                for col, v in enumerate(vals):
                    self.setItem(r, col, QTableWidgetItem(v))
            QMessageBox.information(self, "成功", f"已导入 {self.rowCount()} 行")
        except Exception as e:
            QMessageBox.critical(self, "错误", str(e))

    def get_all_data(self) -> List[Dict]:
        data = []
        for r in range(self.rowCount()):
            try:
                row = {
                    'Name':   (self.item(r, 0) or QTableWidgetItem()).text(),
                    'Type':   (self.item(r, 1) or QTableWidgetItem()).text(),
                    'X':      float((self.item(r, 2) or QTableWidgetItem("0")).text()),
                    'Y':      float((self.item(r, 3) or QTableWidgetItem("0")).text()),
                    'Z':      float((self.item(r, 4) or QTableWidgetItem("0")).text()),
                    'Rx':     float((self.item(r, 5) or QTableWidgetItem("0")).text()),
                    'Ry':     float((self.item(r, 6) or QTableWidgetItem("0")).text()),
                    'Rz':     float((self.item(r, 7) or QTableWidgetItem("0")).text()),
                    'Status': (self.item(r, 8) or QTableWidgetItem()).text(),
                }
                data.append(row)
            except ValueError:
                continue
        return data

    def update_status(self, row_index: int, status: str):
        if row_index < self.rowCount():
            self.setItem(row_index, 8, QTableWidgetItem(status))


class CatiaGunPlacementPage(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.gun_placer = CatiaGunPlacer()
        self.catia_app = None
        self._setup_ui()
        self.try_auto_connect_catia()

    def _setup_ui(self):
        root_layout = QVBoxLayout(self)
        root_layout.setContentsMargins(0, 0, 0, 0)

        # ── 顶部控制区 ────────────────────────────────────────────────────────
        ctrl_frame = QFrame()
        ctrl_frame.setStyleSheet("background:#2c3e50;")
        ctrl_layout = QVBoxLayout(ctrl_frame)
        ctrl_layout.setContentsMargins(10, 8, 10, 8)

        title = QLabel("🔧 CATIA 焊枪批量插入工具")
        title.setStyleSheet("color:white;font-size:14px;font-weight:bold;")
        title.setAlignment(Qt.AlignCenter)
        ctrl_layout.addWidget(title)

        # 旋转顺序
        rot_row = QHBoxLayout()
        rot_row.addWidget(QLabel("旋转顺序:", styleSheet="color:white;"))
        self.rotation_group = QButtonGroup(self)
        # 先创建 label，再连接信号，避免 setChecked 触发信号时 label 还不存在
        self.lbl_rotation_info = QLabel("当前: 库卡 (ZYX)")
        self.lbl_rotation_info.setStyleSheet("color:#f1c40f;")
        for text, val in [("库卡 (ZYX)", "kuka"), ("CATIA ZYX", "catia_zyx"), ("CATIA XYZ", "catia_xyz")]:
            rb = QRadioButton(text)
            rb.setStyleSheet("color:white;")
            rb.setProperty("value", val)
            self.rotation_group.addButton(rb)
            rot_row.addWidget(rb)
            if val == "kuka":
                rb.setChecked(True)  # 在连接信号之前设置默认值
        # 所有按钮都设置好后再连接信号
        for btn in self.rotation_group.buttons():
            btn.toggled.connect(self.on_rotation_order_changed)
        rot_row.addWidget(self.lbl_rotation_info)
        rot_row.addStretch()
        ctrl_layout.addLayout(rot_row)

        # 坐标校正
        corr_row = QHBoxLayout()
        corr_row.addWidget(QLabel("坐标校正:", styleSheet="color:white;"))

        # [新增] TCP 模式勾选框
        self.chk_use_tcp = QCheckBox("使用库卡 TCP 变换")
        self.chk_use_tcp.setStyleSheet("color:#f1c40f; font-weight:bold;")
        self.chk_use_tcp.toggled.connect(self.on_tcp_mode_changed)
        corr_row.addWidget(self.chk_use_tcp)

        self.corr_edits = {}
        self.corr_labels = {}  # [新增] 用于保存 Label 的引用，以便后续改字
        for label in ["X", "Y", "Z", "Rx", "Ry", "Rz"]:
            lbl = QLabel(f"{label}:", styleSheet="color:white;")
            self.corr_labels[label] = lbl
            corr_row.addWidget(lbl)

            e = QLineEdit("0.0")
            e.setFixedWidth(80)  # 稍微调窄一点，给 CheckBox 留空间
            e.setStyleSheet("color: white; background-color: rgba(255, 255, 255, 20);")
            self.corr_edits[label] = e
            corr_row.addWidget(e)

        corr_row.addWidget(make_btn("清除校正", "#7f8c8d", self.clear_correction))
        corr_row.addWidget(make_btn("保存配置", "#27ae60", self.save_correction_config))
        corr_row.addWidget(make_btn("加载配置", "#2980b9", self.load_correction_config))
        self.lbl_correction_status = QLabel("模式: 普通坐标偏移")
        self.lbl_correction_status.setStyleSheet("color:#f1c40f;")
        corr_row.addWidget(self.lbl_correction_status)
        ctrl_layout.addLayout(corr_row)

        # 主按钮行
        btn_row = QHBoxLayout()
        btn_row.addWidget(make_btn("🔌 连接 CATIA", "#3498db", self.connect_catia))
        btn_row.addWidget(make_btn("🔫 选择焊钳", "#e67e22", self.select_gun_template))
        btn_row.addWidget(make_btn("➕ 添加行", "#27ae60", self.add_row))
        btn_row.addWidget(make_btn("📋 导入Excel", "#16a085", self.paste_excel))
        btn_row.addWidget(make_btn("🧪 测试插入", "#9b59b6", self.test_single_insert))
        start_btn = make_btn("🚀 批量插入", "#e74c3c", self.start_batch_placement)
        start_btn.setStyleSheet(start_btn.styleSheet() + "font-weight:bold;font-size:14px;")
        btn_row.addWidget(start_btn)
        btn_row.addStretch()
        ctrl_layout.addLayout(btn_row)

        tip = QLabel("💡 提示: 双击单元格编辑 | 右键粘贴数据 | Ctrl+V 快速粘贴 | 支持从 Excel 复制粘贴")
        tip.setStyleSheet("color:#ecf0f1;font-size:10px;")
        ctrl_layout.addWidget(tip)
        root_layout.addWidget(ctrl_frame)

        # ── 主体：左表 + 右面板 ───────────────────────────────────────────────
        splitter = QSplitter(Qt.Horizontal)

        # 左侧数据表
        left = QWidget()
        left_layout = QVBoxLayout(left)
        left_layout.setContentsMargins(4, 4, 4, 4)
        left_layout.addWidget(QLabel("📋 插枪数据 (可编辑)",
                                      styleSheet="font-size:12px;font-weight:bold;"))

        self.data_table = EditableTableWidget()
        self.data_table.setColumnCount(9)
        self.data_table.setHorizontalHeaderLabels(
            ["名称", "类型", "X", "Y", "Z", "Rx (°)", "Ry (°)", "Rz (°)", "状态"])
        self.data_table.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
        self.data_table.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeToContents)
        self.data_table.horizontalHeader().setSectionResizeMode(8, QHeaderView.ResizeToContents)
        self.data_table.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.data_table.setAlternatingRowColors(True)
        left_layout.addWidget(self.data_table)
        splitter.addWidget(left)

        # 右侧配置
        right = QWidget()
        right.setStyleSheet("background:#ecf0f1;")
        right_layout = QVBoxLayout(right)
        right_layout.setContentsMargins(12, 8, 12, 8)

        # 配置
        config_group = QGroupBox("⚙️ 文件路径")
        config_v = QVBoxLayout(config_group)
        config_v.addWidget(QLabel("焊枪模板:"))
        self.lbl_template = QLabel("未选择")
        self.lbl_template.setStyleSheet("background:white;border:1px solid #ccc;padding:4px;")
        self.lbl_template.setWordWrap(True)
        config_v.addWidget(self.lbl_template)
        right_layout.addWidget(config_group)

        # 统计
        stats_group = QGroupBox("📊 统计信息")
        stats_v = QVBoxLayout(stats_group)
        self.lbl_total = QLabel("总数: 0")
        self.lbl_success = QLabel("成功: 0")
        self.lbl_success.setStyleSheet("color:green;")
        self.lbl_failed = QLabel("失败: 0")
        self.lbl_failed.setStyleSheet("color:red;")
        for l in [self.lbl_total, self.lbl_success, self.lbl_failed]:
            stats_v.addWidget(l)
        right_layout.addWidget(stats_group)

        # 类型筛选
        filter_group = QGroupBox("🔽 插入筛选")
        filter_v = QVBoxLayout(filter_group)
        self.filter_all = QCheckBox("✓ 插入全部点")
        self.filter_all.setChecked(True)
        self.filter_all.toggled.connect(self.on_filter_all_changed)
        self.filter_weld = QCheckBox("🔥 仅插入焊点 (PmWeldLocationOperation)")
        self.filter_weld.toggled.connect(self.on_filter_type_changed)
        self.filter_via = QCheckBox("🔄 仅插入过渡点 (PmViaLocationOperation)")
        self.filter_via.toggled.connect(self.on_filter_type_changed)
        self.filter_continuous = QCheckBox("➰ 仅插入连续点 (PmContinuousFeatureOperation)")
        self.filter_continuous.toggled.connect(self.on_filter_type_changed)
        for w in [self.filter_all, self.filter_weld, self.filter_via, self.filter_continuous]:
            filter_v.addWidget(w)
        self.lbl_filter_info = QLabel("当前: 插入全部点")
        self.lbl_filter_info.setStyleSheet("color:#2980b9;font-size:10px;")
        filter_v.addWidget(self.lbl_filter_info)
        right_layout.addWidget(filter_group)

        # 进度
        right_layout.addWidget(QLabel("📊 执行进度", styleSheet="font-weight:bold;"))
        self.progress_bar = QProgressBar()
        self.progress_bar.setRange(0, 100)
        right_layout.addWidget(self.progress_bar)
        self.lbl_progress = QLabel("等待开始...")
        self.lbl_progress.setStyleSheet("color:#7f8c8d;font-size:10px;")
        right_layout.addWidget(self.lbl_progress)

        # 日志
        right_layout.addWidget(QLabel("📝 操作日志", styleSheet="font-weight:bold;"))
        self.log_text = QPlainTextEdit()
        self.log_text.setReadOnly(True)
        self.log_text.setFont(QFont("Consolas", 9))
        self.log_text.setMaximumBlockCount(500)
        right_layout.addWidget(self.log_text)

        right_layout.addWidget(make_btn("❓ 使用说明", "#95a5a6", self.show_help))

        self.status_label = QLabel("就绪")
        self.status_label.setStyleSheet(
            "background:#34495e;color:white;padding:4px 8px;font-size:10px;")
        right_layout.addWidget(self.status_label)

        splitter.addWidget(right)
        splitter.setSizes([850, 350])
        root_layout.addWidget(splitter)

        # 加载示例数据
        #self.add_sample_data()

    def add_sample_data(self):
        samples = [
            ("Gun_001", "PmWeldLocationOperation", "100.0", "200.0", "300.0", "0", "0", "90", "待插入"),
            ("Via_001", "PmViaLocationOperation",  "150.0", "250.0", "350.0", "0", "45", "0", "待插入"),
            ("Gun_002", "PmWeldLocationOperation", "200.0", "300.0", "400.0", "30", "0", "0", "待插入"),
        ]
        for vals in samples:
            r = self.data_table.rowCount()
            self.data_table.insertRow(r)
            for col, v in enumerate(vals):
                self.data_table.setItem(r, col, QTableWidgetItem(v))

    def on_tcp_mode_changed(self, checked):
        """当切换 TCP 模式时，更新 UI 标签"""
        if checked:
            self.corr_labels["Rx"].setText("A:")
            self.corr_labels["Ry"].setText("B:")
            self.corr_labels["Rz"].setText("C:")
            self.lbl_correction_status.setText("模式: 库卡 TCP 矩阵变换")
            self.log("🔄 切换至 [库卡 TCP 变换] 模式，此模式下变换不直接修改表格数据。")
        else:
            self.corr_labels["Rx"].setText("Rx:")
            self.corr_labels["Ry"].setText("Ry:")
            self.corr_labels["Rz"].setText("Rz:")
            self.lbl_correction_status.setText("模式: 普通坐标偏移")
            self.log("🔄 切换至 [普通坐标偏移] 模式。")

    # ── 旋转顺序 ──────────────────────────────────────────────────────────────
    def on_rotation_order_changed(self):
        for btn in self.rotation_group.buttons():
            if btn.isChecked():
                order = btn.property("value")
                self.gun_placer.set_rotation_order(order)
                names = {'kuka': '库卡 (ZYX)', 'catia_zyx': 'CATIA ZYX', 'catia_xyz': 'CATIA XYZ'}
                self.lbl_rotation_info.setText(f"当前: {names.get(order, order)}")
                self.log(f"旋转顺序切换为: {names.get(order, order)}")
                break

    # ── 坐标校正 ──────────────────────────────────────────────────────────────
    def get_correction_values(self):
        try:
            return {k: float(e.text() or 0) for k, e in self.corr_edits.items()}
        except:
            return {k: 0 for k in self.corr_edits}

    def clear_correction(self):
        for e in self.corr_edits.values():
            e.setText("0.0")
        self.lbl_correction_status.setText("校正: 已清除")
        self.log("🔄 坐标校正已清除")

    def save_correction_config(self):
        config = {k: e.text() for k, e in self.corr_edits.items()}
        config['gun_template'] = self.gun_placer.gun_template_path
        config_dir = os.path.join(os.path.expanduser("~"), ".catia_gun_tool")
        os.makedirs(config_dir, exist_ok=True)
        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
        fp = os.path.join(config_dir, f"correction_config_{ts}.json")
        with open(fp, 'w', encoding='utf-8') as f:
            json.dump(config, f, ensure_ascii=False, indent=2)
        QMessageBox.information(self, "成功", f"配置已保存到:\n{fp}")
        self.log(f"✅ 配置已保存: {fp}")

    def load_correction_config(self):
        fp, _ = QFileDialog.getOpenFileName(
            self, "选择配置文件", "", "JSON 文件 (*.json);;所有文件 (*.*)")
        if not fp:
            return
        try:
            with open(fp, 'r', encoding='utf-8') as f:
                config = json.load(f)
            for k, e in self.corr_edits.items():
                if k in config:
                    e.setText(str(config[k]))
            if 'gun_template' in config and os.path.exists(config['gun_template']):
                self.gun_placer.gun_template_path = config['gun_template']
                self.lbl_template.setText(config['gun_template'])
            self.lbl_correction_status.setText("校正: 已加载配置")
            self.log(f"✅ 配置已加载: {os.path.basename(fp)}")
        except Exception as e:
            QMessageBox.critical(self, "错误", f"加载配置失败:\n{str(e)}")

    # ── 筛选逻辑 ──────────────────────────────────────────────────────────────
    def on_filter_all_changed(self, checked):
        if checked:
            self.filter_weld.setChecked(False)
            self.filter_via.setChecked(False)
            self.filter_continuous.setChecked(False)
            self.lbl_filter_info.setText("当前: 插入全部点")

    def on_filter_type_changed(self):
        any_checked = (self.filter_weld.isChecked() or
                       self.filter_via.isChecked() or
                       self.filter_continuous.isChecked())
        if any_checked:
            self.filter_all.setChecked(False)
            selected = []
            if self.filter_weld.isChecked(): selected.append("焊点")
            if self.filter_via.isChecked(): selected.append("过渡点")
            if self.filter_continuous.isChecked(): selected.append("连续点")
            self.lbl_filter_info.setText(f"当前: 插入 {'+'.join(selected)}")
        else:
            self.filter_all.setChecked(True)
            self.lbl_filter_info.setText("当前: 插入全部点")

    # ── CATIA 连接 ────────────────────────────────────────────────────────────
    def try_auto_connect_catia(self):
        """
        静默尝试连接 CATIA：
        1. 检查是否有正在运行的实例
        2. 如果没有，跳过并更新 UI 为未启动
        3. 如果有，自动建立连接
        """
        # 1. 先在界面显示检测中（防止稍微卡顿时用户以为死机）
        self.status_label.setText("🔄 正在检测 CATIA...")
        self.status_label.setStyleSheet("background:#f39c12;color:white;padding:4px 8px;font-size:10px;")
        QApplication.processEvents()  # 强制刷新一下 UI

        try:
            import win32com.client
            import pythoncom

            # 2. 核心检测逻辑：GetActiveObject 只获取已打开的实例，绝不会主动启动 CATIA
            try:
                # 尝试从系统的运行对象表 (ROT) 中抓取 CATIA
                raw_catia_app = win32com.client.GetActiveObject("CATIA.Application")
            except pythoncom.com_error:
                # 如果抛出 com_error，说明 CATIA 根本没打开
                self.status_label.setText("⚠️ CATIA 未启动")
                # 变成醒目的红色背景
                self.status_label.setStyleSheet("background:#e74c3c;color:white;padding:4px 8px;font-size:10px;")
                self.log("ℹ️ 检测到 CATIA 未运行，已跳过自动连接。请在启动 CATIA 后手动点击连接。")
                return

            # 3. 既然没抛出异常，说明 CATIA 开着，开始正式连接
            if PYCATIA_AVAILABLE:
                self.catia_app = pycatia_catia()
                conn_type = 'pycatia'
            else:
                self.catia_app = raw_catia_app
                conn_type = 'win32com'

            # 4. 传递给后端对象并更新 UI 状态
            self.gun_placer.set_catia_app(self.catia_app, conn_type)

            self.status_label.setText(f"✅ CATIA 已连接 ({conn_type})")
            # 变成表示成功的绿色背景
            self.status_label.setStyleSheet("background:#27ae60;color:white;padding:4px 8px;font-size:10px;")
            self.log(f"✅ 自动检测并连接 CATIA 成功 ({conn_type})")

        except Exception as e:
            # 捕获其他未知错误（例如环境缺失）
            self.status_label.setText("❌ CATIA 连接异常")
            self.status_label.setStyleSheet("background:#c0392b;color:white;padding:4px 8px;font-size:10px;")
            self.log(f"❌ 自动连接过程发生异常: {str(e)}")

    def connect_catia(self):
        """手动点击连接按钮时的逻辑"""
        self.log("🔄 正在尝试手动连接 CATIA...")
        self.try_auto_connect_catia()  # 直接复用自动连接逻辑

        # 补充弹窗提示
        if self.gun_placer.is_catia_connected():
            QMessageBox.information(self, "成功", "CATIA 连接成功！")
        else:
            QMessageBox.warning(self, "未检测到 CATIA",
                                "未检测到正在运行的 CATIA 实例。\n请确保 CATIA 已完全启动后重试。")

    def select_gun_template(self):
        fp, _ = QFileDialog.getOpenFileName(
            self, "选择焊枪模板文件", "",
            "CATIA 文件 (*.CATPart *.CATProduct *.cgr);;所有文件 (*.*)")
        if fp:
            self.gun_placer.gun_template_path = fp
            self.lbl_template.setText(fp)
            self.log(f"✅ 已选择模板: {os.path.basename(fp)}")

    def add_row(self):
        self.data_table.add_row()
        self._update_statistics()

    def paste_excel(self):
        self.data_table._paste_from_excel_file()
        self._update_statistics()

    def _update_statistics(self):
        self.lbl_total.setText(f"总数: {self.data_table.rowCount()}")

    def progress_callback(self, current, total, message):
        pct = int((current / max(1, total)) * 100)
        self.progress_bar.setValue(pct)
        self.lbl_progress.setText(f"{message} ({current}/{total})")
        self.log(message)
        QApplication.processEvents()

    def log(self, text: str):
        self.log_text.appendPlainText(text)

    def test_single_insert(self):
        if not self.gun_placer.is_catia_connected():
            QMessageBox.warning(self, "警告", "请先连接 CATIA")
            return
        if not self.gun_placer.gun_template_path:
            QMessageBox.warning(self, "警告", "请先选择焊枪模板文件")
            return
        tp = os.path.normpath(self.gun_placer.gun_template_path).replace('/', '\\')
        self.log("=" * 40)
        self.log("🧪 开始测试插入...")
        self.log(f"模板文件: {tp}")
        self.log(f"文件存在: {os.path.exists(tp)}")
        try:
            sz = os.path.getsize(tp) / 1024
            self.log(f"文件大小: {sz:.2f} KB")
        except:
            pass
        self.log("（测试完成，实际插入请点击批量插入）")

    def start_batch_placement(self):
        if not self.gun_placer.is_catia_connected():
            QMessageBox.warning(self, "警告", "请先连接 CATIA")
            return
        if not self.gun_placer.has_active_product():
            QMessageBox.warning(self, "警告", "请在 CATIA 中打开一个 Product 文档")
            return
        if not self.gun_placer.gun_template_path:
            QMessageBox.warning(self, "警告", "请先选择焊枪模板文件")
            return

        all_gun_data = self.data_table.get_all_data()
        if not all_gun_data:
            QMessageBox.warning(self, "警告", "没有有效的插枪数据")
            return

        # 获取界面输入值
        raw_corr_values = self.get_correction_values()

        # [新增] 解析 TCP 或普通偏移
        kuka_tcp_input = None
        simple_offset = None
        apply_correction = any(v != 0 for v in raw_corr_values.values())

        if self.chk_use_tcp.isChecked():
            # TCP 模式下，UI 上的 Rx, Ry, Rz 对应 A, B, C
            kuka_tcp_input = {
                'X': raw_corr_values['X'],
                'Y': raw_corr_values['Y'],
                'Z': raw_corr_values['Z'],
                'A': raw_corr_values['Rx'],
                'B': raw_corr_values['Ry'],
                'C': raw_corr_values['Rz']
            }
        elif apply_correction:
            simple_offset = raw_corr_values

        rotation_order = None
        for btn in self.rotation_group.buttons():
            if btn.isChecked():
                rotation_order = btn.property("value")
                break

        # 筛选逻辑
        if self.filter_all.isChecked():
            gun_data = all_gun_data
            filter_desc = "全部点"
        else:
            selected_types = []
            if self.filter_weld.isChecked(): selected_types.append("PmWeldLocationOperation")
            if self.filter_via.isChecked(): selected_types.append("PmViaLocationOperation")
            if self.filter_continuous.isChecked(): selected_types.append("PmContinuousFeatureOperation")
            if not selected_types:
                QMessageBox.warning(self, "警告", "请至少选择一种点类型")
                return
            gun_data = [g for g in all_gun_data if g['Type'] in selected_types]
            filter_desc = " + ".join(filter(None, [
                "焊点" if self.filter_weld.isChecked() else None,
                "过渡点" if self.filter_via.isChecked() else None,
                "连续点" if self.filter_continuous.isChecked() else None,
            ]))

        if not gun_data:
            QMessageBox.warning(self, "警告", f"筛选后没有数据\n当前筛选: {filter_desc}")
            return

        confirm_msg = (f"即将插入 {len(gun_data)} 个组件（共 {len(all_gun_data)} 个）\n"
                       f"筛选条件: {filter_desc}\n"
                       f"模板: {os.path.basename(self.gun_placer.gun_template_path)}\n")

        if self.chk_use_tcp.isChecked():
            confirm_msg += f"将应用 TCP 矩阵变换: {kuka_tcp_input}\n"
        elif apply_correction:
            confirm_msg += f"将应用普通坐标偏移: {simple_offset}\n"

        confirm_msg += "\n是否继续?"
        if QMessageBox.question(self, "确认", confirm_msg) != QMessageBox.Yes:
            return

        self.progress_bar.setValue(0)
        self.lbl_success.setText("成功: 0")
        self.lbl_failed.setText("失败: 0")
        self.log("=" * 40)
        self.log(f"🚀 开始批量插入 ({filter_desc})...")

        # [修改] 传递新的参数
        success, failed, status_list = self.gun_placer.place_guns_batch(
            self.gun_placer.gun_template_path,
            gun_data,
            self.progress_callback,
            correction_values=simple_offset,
            rotation_order=rotation_order,
            kuka_tcp_input=kuka_tcp_input  # 传递 TCP 数据
        )

        # 更新状态列
        gun_data_set = set(id(g) for g in gun_data)
        s_idx = 0
        for a_idx, gun in enumerate(all_gun_data):
            if gun in gun_data and s_idx < len(status_list):
                self.data_table.update_status(a_idx, status_list[s_idx])
                s_idx += 1

        self.lbl_success.setText(f"成功: {success}")
        self.lbl_failed.setText(f"失败: {failed}")
        self.log(f"✅ 完成 | 成功: {success} | 失败: {failed}")
        QMessageBox.information(self, "完成", f"批量插入完成!\n成功: {success}\n失败: {failed}")

    def show_help(self):
        help_text = """📖 CATIA 焊枪批量插入工具使用说明

1️⃣ 数据输入方式
  • 双击单元格直接编辑
  • 点击"添加行"添加新数据
  • Ctrl+V 粘贴 Excel 数据
  • 右键选择"从Excel文件导入"

2️⃣ 数据格式
  Name | Type | X | Y | Z | Rx | Ry | Rz

3️⃣ 点类型
  PmWeldLocationOperation     → 焊点
  PmViaLocationOperation      → 过渡点
  PmContinuousFeatureOperation → 连续点

4️⃣ 操作流程
  ① 打开 CATIA，创建/打开 Product 文档
  ② 点击"连接 CATIA"
  ③ 点击"选择模板"，选择焊枪文件
  ④ 输入或粘贴插枪数据
  ⑤ 选择要插入的点类型（筛选）
  ⑥ 点击"批量插入"

5️⃣ 注意事项
  • 模板文件路径不要包含中文字符
  • 插入过程中不要操作 CATIA
  • 欧拉角采用 ZYX 旋转顺序（库卡标准）"""
        msg = QMessageBox(self)
        msg.setWindowTitle("使用说明")
        msg.setText(help_text)
        msg.setTextFormat(Qt.PlainText)
        msg.exec_()


# ============================================================================
# 主窗口
# ============================================================================
class MainApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Tecnomatix PDPS 综合集成工作站 V13.0 (PyQt5)")
        self.resize(1300, 800)
        self.setWindowIcon(QIcon("logo.png"))
        self._setup_ui()

    def _setup_ui(self):
        self.tab_widget = QTabWidget()
        self.tab_widget.setStyleSheet("""
            QTabBar::tab {
                font-family: 微软雅黑; font-size: 12px;
                padding: 8px 20px; min-width: 120px;
            }
            QTabBar::tab:selected { background: #3498db; color: white; }
            QTabBar::tab:!selected { background: #ecf0f1; color: #2c3e50; }
        """)

        self.page_manager = ProjectManagerPage()
        self.page_toolbox = ToolBoxPage()
        self.page_gun = CatiaGunPlacementPage()

        self.tab_widget.addTab(self.page_manager, "📂 项目路径管理")
        self.tab_widget.addTab(self.page_toolbox, "🛠️ Catia工具箱")
        self.tab_widget.addTab(self.page_gun, "🔧 插枪工具")

        self.setCentralWidget(self.tab_widget)

        # 状态栏
        self.statusBar().showMessage("就绪 | 请选择功能模块")
        self.statusBar().setStyleSheet("font-family:微软雅黑;font-size:10px;")


# ============================================================================
# 入口
# ============================================================================
def main():
    # DPI 感知
    try:
        ctypes.windll.shcore.SetProcessDpiAwareness(1)
    except Exception:
        try:
            ctypes.windll.user32.SetProcessDPIAware()
        except Exception:
            pass

    # 高 DPI 支持必须在 QApplication 创建之前设置
    QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
    QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)

    app = QApplication(sys.argv)
    app.setStyle(QStyleFactory.create("Fusion"))

    # 全局字体
    font = QFont("微软雅黑", 10)
    app.setFont(font)

    window = MainApp()
    window.show()
    sys.exit(app.exec_())


if __name__ == "__main__":
    main()