IDTools.py内容:import tkinter as tk
from tkinter import ttk, filedialog, messagebox, scrolledtext
#import xml.etree.ElementTree as ET
from lxml import etree as ET
import os
import re
from xml.dom import minidom
from collections import OrderedDict, defaultdict
class ConfigUpdaterApp:
def __init__(self, root):
self.root = root
self.root.title("ID统一配置文件自动更新工具")
self.root.geometry("1920x1080")
self.root.configure(bg="#f0f0f0")
# 创建样式
self.style = ttk.Style()
self.style.configure("TButton", padding=6, relief="flat", background="#4a7a8c", foreground="blue")
self.style.configure("Treeview", font=("Consolas", 10), rowheight=25)
self.style.configure("Treeview.Heading", font=("Arial", 11, "bold"))
self.style.configure("TNotebook", background="#f0f0f0")
self.style.configure("TNotebook.Tab", padding=(10, 5), font=("Arial", 10, "bold"))
self.style.configure("XMLText", font=("Consolas", 10), background="#f8f8f8")
# 创建主框架
self.create_widgets()
# 初始化数据结构
self.rawdata_template = []
self.rawdata_source = None
self.event_template = []
self.event_source = None
self.current_filter = ""
self.variable_mapping = {}
self.module_mapping = {}
self.init_module()
self.event_categories = []
self.special_mapping_id = {}
self.special_mapping_name = {}
self.init_special_mapping()
def init_module(self):
"""
初始化moduleID与SVEC模板中一致
:return:
"""
self.module_mapping["System"] = "00"
self.module_mapping["CryoPump"] = "00"
self.module_mapping["HeatExchanger"] = "00"
self.module_mapping["EFEM"] = "01"
self.module_mapping["LP1"] = "01"
self.module_mapping["LP2"] = "01"
self.module_mapping["LP3"] = "01"
self.module_mapping["Transfer"] = "02"
self.module_mapping["TC"] = "02"
self.module_mapping["Buffer"] = "03"
self.module_mapping["BF"] = "03"
self.module_mapping["Bufferr"] = "03"
self.module_mapping["LA"] = "11"
self.module_mapping["LB"] = "12"
self.module_mapping["LC"] = "13"
self.module_mapping["LD"] = "14"
self.module_mapping["LAB"] = "15"
self.module_mapping["LCD"] = "16"
self.module_mapping["Ch1"] = "21"
self.module_mapping["Ch2"] = "22"
self.module_mapping["Ch3"] = "23"
self.module_mapping["Ch4"] = "24"
self.module_mapping["Ch5"] = "25"
self.module_mapping["Ch6"] = "26"
self.module_mapping["ChA"] = "27"
self.module_mapping["ChB"] = "28"
self.module_mapping["ChC"] = "29"
self.module_mapping["ChD"] = "30"
self.module_mapping["ChE"] = "31"
self.module_mapping["ChF"] = "32"
def get_module_id(self, module_name):
"""
根据module_name和映射表获取id
:param module_name:
:return:
"""
if module_name not in self.module_mapping:
return None
else:
return self.module_mapping[module_name]
def create_widgets(self):
"""创建界面组件"""
# 创建选项卡
self.notebook = ttk.Notebook(self.root)
self.notebook.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
self.template_frame = ttk.Frame(self.notebook)
self.notebook.add(self.template_frame, text="TemplateConfig")
self.create_template_tab(self.template_frame)
# RawdataConfig 标签页
self.rawdata_frame = ttk.Frame(self.notebook)
self.notebook.add(self.rawdata_frame, text="RawdataConfig")
self.create_rawdata_tab(self.rawdata_frame)
# EventConfig 标签页
self.event_frame = ttk.Frame(self.notebook)
self.notebook.add(self.event_frame, text="EventConfig")
self.create_event_tab(self.event_frame)
# 状态栏
self.status_var = tk.StringVar(value="就绪")
status_bar = ttk.Label(self.root, textvariable=self.status_var,
relief=tk.SUNKEN, anchor=tk.W, padding=5)
status_bar.pack(side=tk.BOTTOM, fill=tk.X)
def create_template_tab(self, parent):
btn_frame = ttk.Frame(parent)
btn_frame.pack(fill=tk.X, padx=10, pady=10)
ttk.Button(btn_frame, text="加载模板源文件", command=self.load_rawdata_template_txt).pack(side=tk.LEFT, padx=5)
paned_window = ttk.PanedWindow(parent, orient=tk.VERTICAL)
paned_window.pack(fill=tk.BOTH, expand=True, padx=10, pady=(0, 10))
template_frame = ttk.LabelFrame(paned_window, text="模板显示")
paned_window.add(template_frame, weight=1)
source_frame = ttk.LabelFrame(paned_window, text="源文件显示(XML原始格式)")
paned_window.add(source_frame, weight=1)
def create_rawdata_tab(self, parent):
"""创建RawdataConfig标签页"""
# 顶部按钮区域
btn_frame = ttk.Frame(parent)
btn_frame.pack(fill=tk.X, padx=10, pady=10)
# RawdataConfig 按钮
ttk.Button(btn_frame, text="1.加载模板文件", command=self.load_rawdata_template).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="2.加载源文件", command=self.load_rawdata_source).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="3.新增ID属性", command=self.add_id_to_rawdata).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="4.筛选模板Variable", command=self.filter_template_vars).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="5.筛选源文件Variable", command=self.filter_source_vars).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="6.对比", command=self.compare_vars).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="7.导出标红内容", command=self.export_highlighted).pack(side=tk.LEFT, padx=5)
#ttk.Button(btn_frame, text="8.加载映射表", command=self.fill_ids).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="8.填充ID属性", command=self.fill_ids).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="9.删除空ID节点", command=self.filter_empty_id_nodes).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="10.导出文件", command=self.export_rawdata).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="11.拆分文件并导出", command=self.split_export).pack(side=tk.LEFT, padx=5)
# 创建分割面板
paned_window = ttk.PanedWindow(parent, orient=tk.VERTICAL)
paned_window.pack(fill=tk.BOTH, expand=True, padx=10, pady=(0, 10))
# 上半部分 - 模板显示
template_frame = ttk.LabelFrame(paned_window, text="模板显示")
paned_window.add(template_frame, weight=1)
# 模板表格
self.create_template_table(template_frame)
# 下半部分 - 源文件显示(XML原始格式)
source_frame = ttk.LabelFrame(paned_window, text="源文件显示(XML原始格式)")
paned_window.add(source_frame, weight=1)
# XML文本显示区域
self.rawdata_xml_text = scrolledtext.ScrolledText(
source_frame,
wrap=tk.WORD,
font=("Consolas", 10),
bg="#f8f8f8",
padx=10,
pady=10
)
self.rawdata_xml_text.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
self.rawdata_xml_text.config(state=tk.DISABLED) # 初始为只读
# 底部筛选区域
filter_frame = ttk.Frame(parent)
filter_frame.pack(fill=tk.X, padx=10, pady=(0, 10))
# 模板Variable筛选
ttk.Label(filter_frame, text="模板Variable筛选:").pack(side=tk.LEFT, padx=(0, 5))
self.template_filter_var = tk.StringVar()
self.template_filter_box = tk.Listbox(filter_frame, listvariable=self.template_filter_var,
height=6, width=30, selectmode=tk.EXTENDED)
self.template_filter_box.pack(side=tk.LEFT, padx=5, pady=5, fill=tk.BOTH, expand=True)
# 源文件Variable筛选
ttk.Label(filter_frame, text="源文件Variable筛选:").pack(side=tk.LEFT, padx=(20, 5))
self.source_filter_var = tk.StringVar()
self.source_filter_box = tk.Listbox(filter_frame, listvariable=self.source_filter_var,
height=6, width=30, selectmode=tk.EXTENDED)
self.source_filter_box.pack(side=tk.LEFT, padx=5, pady=5, fill=tk.BOTH, expand=True)
# 对比结果区域
self.compare_result = tk.Text(filter_frame, height=6, width=30, state=tk.DISABLED)
self.compare_result.pack(side=tk.LEFT, padx=5, pady=5, fill=tk.BOTH, expand=True)
def create_event_tab(self, parent):
"""创建EventConfig标签页"""
# 顶部按钮区域
btn_frame = ttk.Frame(parent)
btn_frame.pack(fill=tk.X, padx=10, pady=10)
# EventConfig 按钮
ttk.Button(btn_frame, text="1.加载模板文件", command=self.load_event_template).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="2.加载源文件", command=self.load_event_source).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="3.新增ID属性", command=self.add_id_to_event).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="4.填充ID属性", command=self.fill_event_attributes).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="5.导出文件", command=self.export_event).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="6.拆分文件并导出", command=self.split_export_event).pack(side=tk.LEFT, padx=5)
# 创建分割面板
paned_window = ttk.PanedWindow(parent, orient=tk.VERTICAL)
paned_window.pack(fill=tk.BOTH, expand=True, padx=10, pady=(0, 10))
# 上半部分 - 模板显示
template_frame = ttk.LabelFrame(paned_window, text="模板显示")
paned_window.add(template_frame, weight=1)
# 模板表格
self.create_event_template_table(template_frame)
# 下半部分 - 源文件显示(XML原始格式)
source_frame = ttk.LabelFrame(paned_window, text="源文件显示(XML原始格式)")
paned_window.add(source_frame, weight=1)
# XML文本显示区域
self.event_xml_text = scrolledtext.ScrolledText(
source_frame,
wrap=tk.WORD,
font=("Consolas", 10),
bg="#f8f8f8",
padx=10,
pady=10
)
self.event_xml_text.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
self.event_xml_text.config(state=tk.DISABLED) # 初始为只读
def create_template_table(self, parent):
"""创建Rawdata模板表格"""
# 创建滚动条
scroll_y = ttk.Scrollbar(parent, orient=tk.VERTICAL)
scroll_x = ttk.Scrollbar(parent, orient=tk.HORIZONTAL)
# 创建Treeview表格
columns = ("variable", "id", "mapping")
self.template_table = ttk.Treeview(
parent,
columns=columns,
show="headings",
yscrollcommand=scroll_y.set,
xscrollcommand=scroll_x.set,
selectmode="extended"
)
# 配置列标题
# self.template_table.heading("name", text="Name", anchor=tk.W)
# self.template_table.heading("type", text="Type", anchor=tk.W)
self.template_table.heading("variable", text="Variable", anchor=tk.W)
self.template_table.heading("id", text="ID", anchor=tk.W)
self.template_table.heading("mapping", text="Mapping", anchor=tk.W)
# 配置列宽度
#self.template_table.column("name", width=150, anchor=tk.W)
#self.template_table.column("type", width=120, anchor=tk.W)
self.template_table.column("variable", width=200, anchor=tk.W)
self.template_table.column("id", width=100, anchor=tk.W)
self.template_table.column("mapping", width=300, anchor=tk.W)
# 配置滚动条
scroll_y.config(command=self.template_table.yview)
scroll_x.config(command=self.template_table.xview)
# 布局
self.template_table.grid(row=0, column=0, sticky="nsew")
scroll_y.grid(row=0, column=1, sticky="ns")
scroll_x.grid(row=1, column=0, sticky="ew")
# 配置网格权重
parent.grid_rowconfigure(0, weight=1)
parent.grid_columnconfigure(0, weight=1)
def create_event_template_table(self, parent):
"""创建Event模板表格"""
# 创建滚动条
scroll_y = ttk.Scrollbar(parent, orient=tk.VERTICAL)
scroll_x = ttk.Scrollbar(parent, orient=tk.HORIZONTAL)
# 创建Treeview表格
columns = ("name", "id", "type", "mapping")
self.event_template_table = ttk.Treeview(
parent,
columns=columns,
show="headings",
yscrollcommand=scroll_y.set,
xscrollcommand=scroll_x.set,
selectmode="extended"
)
# 配置列标题
self.event_template_table.heading("name", text="Name", anchor=tk.W)
self.event_template_table.heading("id", text="ID", anchor=tk.W)
self.event_template_table.heading("type", text="Type", anchor=tk.W)
self.event_template_table.heading("mapping", text="Maping", anchor=tk.W)
# 配置列宽度
self.event_template_table.column("name", width=100, anchor=tk.W)
self.event_template_table.column("id", width=100, anchor=tk.W)
self.event_template_table.column("type", width=100, anchor=tk.W)
self.event_template_table.column("mapping", width=100, anchor=tk.W)
# 配置滚动条
scroll_y.config(command=self.event_template_table.yview)
scroll_x.config(command=self.event_template_table.xview)
# 布局
self.event_template_table.grid(row=0, column=0, sticky="nsew")
scroll_y.grid(row=0, column=1, sticky="ns")
scroll_x.grid(row=1, column=0, sticky="ew")
# 配置网格权重
parent.grid_rowconfigure(0, weight=1)
parent.grid_columnconfigure(0, weight=1)
def display_xml_content(self, xml_tree, text_widget):
"""在文本框中显示格式化的XML内容"""
try:
# 将XML树转换为字符串
xml_str = ET.tostring(xml_tree.getroot(), encoding='utf-8').decode('utf-8')
# 使用minidom进行格式化
dom = minidom.parseString(xml_str)
pretty_xml = dom.toprettyxml(indent=" ")
# 移除多余的换行
pretty_xml = "\n".join([line for line in pretty_xml.split("\n") if line.strip()])
# 更新文本框
text_widget.config(state=tk.NORMAL)
text_widget.delete(1.0, tk.END)
text_widget.insert(tk.END, pretty_xml)
text_widget.config(state=tk.DISABLED)
# 高亮空ID节点(可选)
self.highlight_empty_id_nodes(text_widget, pretty_xml)
except Exception as e:
messagebox.showerror("显示错误", f"格式化XML显示失败: {str(e)}")
def highlight_empty_id_nodes(self, text_widget, xml_content):
"""高亮显示id为空的data节点"""
if not xml_content:
return
# 查找所有id属性为空的data节点
pattern = r'(<data\b[^>]*\bid="")'
matches = re.finditer(pattern, xml_content)
# 设置高亮样式
text_widget.tag_configure("empty_id", background="#ffe6e6")
# 应用高亮
for match in matches:
start_index = f"1.0 + {match.start()} chars"
end_index = f"1.0 + {match.end()} chars"
text_widget.tag_add("empty_id", start_index, end_index)
# ================ TemplateConfig 功能 ================
def load_rawdata_template_txt(self):
file_path = filedialog.askopenfilename(
title="选择Template模板文件",
filetypes=[("Text files", "*.txt"), ("All files", "*.*")]
)
if not file_path:
return
try:
with open(file_path, 'r', encoding='utf-8') as file:
lines = file.readlines()
column_names = [
'path', 'type', 'variable', 'id', 'data_type_id',
'subsystem_id', 'parts', 'parts_id', 'attribute',
'attribute_id', 'mapping'
]
except Exception as e:
messagebox.showerror("加载错误", f"加载Template模板文件失败: {str(e)}")
# ================ RawdataConfig 功能 ================
def load_rawdata_template(self):
"""加载Rawdata模板文件(.txt)"""
file_path = filedialog.askopenfilename(
title="选择Rawdata模板文件",
filetypes=[("Text files", "*.txt"), ("All files", "*.*")]
)
if not file_path:
return
try:
with open(file_path, 'r', encoding='utf-8') as file:
lines = file.readlines()
self.rawdata_template = []
self.variable_mapping = {}
# 清空表格
for item in self.template_table.get_children():
self.template_table.delete(item)
# 解析模板文件
for line in lines:
line = line.strip()
if not line:
continue
# 分割行数据
parts = line.split()
if len(parts) < 2:
continue
# 提取前四列
#name = parts[0]
#var_type = parts[1]
variable = parts[0]
id = parts[1] if len(parts) > 1 else ""
mapping_info = parts[2] if len(parts) > 2 else None
self.rawdata_template.append({
"variable": variable,
"id": id,
"mapping": mapping_info
})
if mapping_info:
mapping_parts = mapping_info.split(';')
for map in mapping_parts:
if map in self.variable_mapping:
messagebox.showwarning("信息有误","请确认模板文件中mapping列是否有重复信息"+map)
return
else:
self.variable_mapping[map] = variable
# 添加到表格
self.template_table.insert("", tk.END, values=(variable, id, mapping_info))
self.status_var.set(f"已加载Rawdata模板: {os.path.basename(file_path)} - {len(self.rawdata_template)} 条记录")
except Exception as e:
messagebox.showerror("加载错误", f"加载Rawdata模板文件失败: {str(e)}")
def load_rawdata_source(self):
"""加载Rawdata源文件(.xml)"""
file_path = filedialog.askopenfilename(
title="选择Rawdata源文件",
filetypes=[("XML files", "*.xml"), ("All files", "*.*")]
)
if not file_path:
return
try:
self.rawdata_tree = ET.parse(file_path)
self.rawdata_root = self.rawdata_tree.getroot()
self.rawdata_source = self.rawdata_tree
# 在文本框中显示XML内容
self.display_xml_content(self.rawdata_tree, self.rawdata_xml_text)
self.status_var.set(f"已加载Rawdata源文件: {os.path.basename(file_path)}")
except Exception as e:
messagebox.showerror("加载错误", f"加载Rawdata源文件失败: {str(e)}")
def add_id_to_rawdata(self):
"""为Rawdata源文件添加ID属性"""
if not self.rawdata_source:
messagebox.showwarning("无数据", "请先加载Rawdata源文件")
return
# 添加ID属性
count = 0
for data in self.rawdata_root.findall('.//data'):
if 'id' not in data.attrib:
# 在属性开头位置添加id属性
new_attrib = OrderedDict()
new_attrib['id'] = ''
for key, value in data.attrib.items():
new_attrib[key] = value
#data.attrib = new_attrib
data.attrib.clear()
for key, value in new_attrib.items():
data.set(key, value)
count += 1
# 更新XML显示
self.display_xml_content(self.rawdata_tree, self.rawdata_xml_text)
self.status_var.set(f"已为{count}个data标签添加id属性")
def filter_template_vars(self):
"""筛选模板Variable"""
if not self.rawdata_template:
messagebox.showwarning("无数据", "请先加载Rawdata模板文件")
return
# 提取Variable后半部分并去重
var_parts = set()
for item in self.rawdata_template:
variable = item["variable"]
parts = variable.split('_', 1) # 只分割第一个下划线
if len(parts) > 1:
var_parts.add(parts[1])
# 更新列表
self.template_filter_var.set(tuple(sorted(var_parts)))
self.status_var.set(f"已筛选出 {len(var_parts)} 个模板Variable")
def filter_source_vars(self):
"""筛选源文件Variable"""
if not self.rawdata_source:
messagebox.showwarning("无数据", "请先加载Rawdata源文件")
return
# 提取Variable后半部分并去重
var_parts = set()
for data in self.rawdata_root.findall('.//data'):
variable = data.get('variable', '')
if variable:
parts = variable.split('_', 1) # 只分割第一个下划线
if len(parts) > 1:
var_parts.add(parts[1])
# 更新列表
self.source_filter_var.set(tuple(sorted(var_parts)))
self.status_var.set(f"已筛选出 {len(var_parts)} 个源文件Variable")
def compare_vars(self):
"""对比模板和源文件Variable"""
template_vars = self.template_filter_box.get(0, tk.END)
source_vars = self.source_filter_box.get(0, tk.END)
template_mapping_vars = self.variable_mapping.values();
if not template_vars or not source_vars:
messagebox.showwarning("无数据", "请先筛选模板和源文件Variable")
return
# 清空对比结果
self.compare_result.config(state=tk.NORMAL)
self.compare_result.delete(1.0, tk.END)
# 查找源文件中有但模板中没有的Variable
missing_in_template = set(source_vars) - set(template_vars) - set(template_mapping_vars)
# 更新源文件列表,标红缺失项
self.source_filter_box.delete(0, tk.END)
for var in sorted(source_vars):
self.source_filter_box.insert(tk.END, var)
if var in missing_in_template:
self.source_filter_box.itemconfig(tk.END, fg='red')
# 显示对比结果
self.compare_result.insert(tk.END, "对比结果:\n")
self.compare_result.insert(tk.END, f"模板Variable数量: {len(template_vars)}\n")
self.compare_result.insert(tk.END, f"源文件Variable数量: {len(source_vars)}\n")
self.compare_result.insert(tk.END, f"源文件中有但模板中缺失的数量: {len(missing_in_template)}\n\n")
if missing_in_template:
self.compare_result.insert(tk.END, "缺失的Variable:\n")
for var in sorted(missing_in_template):
self.compare_result.insert(tk.END, f" - {var}\n")
self.compare_result.config(state=tk.DISABLED)
self.status_var.set(f"对比完成: 发现 {len(missing_in_template)} 个缺失项")
def export_highlighted(self):
"""导出标红内容"""
# 获取标红的项
highlighted_items = []
for i in range(self.source_filter_box.size()):
if self.source_filter_box.itemcget(i, "fg") == "red":
highlighted_items.append(self.source_filter_box.get(i))
if not highlighted_items:
messagebox.showinfo("无数据", "没有标红的项可导出")
return
# 选择保存位置
file_path = filedialog.asksaveasfilename(
title="保存标红内容",
defaultextension=".txt",
filetypes=[("Text files", "*.txt"), ("All files", "*.*")]
)
if not file_path:
return
# 写入文件
try:
with open(file_path, 'w', encoding='utf-8') as file:
file.write("标红的Variable项:\n")
for item in highlighted_items:
file.write(f"{item}\n")
self.status_var.set(f"已导出 {len(highlighted_items)} 个标红项到 {os.path.basename(file_path)}")
messagebox.showinfo("导出成功", "标红项已成功导出")
except Exception as e:
messagebox.showerror("导出错误", f"导出文件失败: {str(e)}")
def fill_ids(self):
"""填充ID属性(占位)"""
if not self.rawdata_source:
messagebox.showwarning("无数据", "请先加载Rawdata源文件")
return
if not self.rawdata_root:
messagebox.showwarning("无数据", "请先加载Rawdata源文件")
return
if not self.rawdata_template:
messagebox.showwarning("无数据", "请先加载模板文件")
return
# 自动加载映射表,如果不存在就不加载
#self.init_variable_mapping()
fill_count = 0
not_exist = []
not_exist_all = []
for data_elem in self.rawdata_tree.findall('.//data'):
variable = data_elem.get('variable')
parts = variable.split('_', 1)
if len(parts) < 2 or variable in self.special_mapping_id:
if variable in self.special_mapping_id and variable in self.special_mapping_name:
temp_var = self.special_mapping_name[variable]
temp_id = self.special_mapping_id[variable]
else:
continue
else:
module = parts[0]
var = parts[1]
temp_var, temp_id = self.get_id(module, var)
if temp_var and temp_id:
data_elem.set('variable', temp_var)
data_elem.set('id', temp_id)
fill_count += 1
else:
if temp_id is None and var not in not_exist:
not_exist.append(var)
if temp_id is None:
not_exist_all.append(variable)
# 更新XML显示
self.display_xml_content(self.rawdata_tree, self.rawdata_xml_text)
self.status_var.set(f"已为{fill_count}个data标签添加id属性,剩余{len(not_exist)}无对应值。总共剩余{len(not_exist_all)}个未设置")
#messagebox.showinfo("功能待实现", "填充ID属性功能将在后续版本实现")
def filter_empty_id_nodes(self):
"""删除id属性为空的data节点并刷新显示"""
if not self.rawdata_source:
messagebox.showwarning("无数据", "请先加载Rawdata源文件")
return
# 获取XML根节点
root = self.rawdata_tree.getroot() # 确保获取根节点[^5]
# 查找所有id属性为空的data节点
empty_id_nodes = []
for data_node in root.iter('data'):
if data_node.get('id', '') == '':
empty_id_nodes.append(data_node)
if not empty_id_nodes:
messagebox.showinfo("无操作", "未找到id为空的data节点")
return
# 删除这些节点(使用替代方法获取父节点)
for node in empty_id_nodes:
# 替代 getparent() 的方法
for parent in root.iter():
if node in list(parent): # 检查节点是否是当前父节点的直接子节点
parent.remove(node)
break
# 刷新XML显示
self.display_xml_content(self.rawdata_tree, self.rawdata_xml_text)
# 更新状态
self.status_var.set(f"已删除 {len(empty_id_nodes)} 个id为空的data节点")
def export_rawdata(self):
"""导出Rawdata源文件"""
if not self.rawdata_source:
messagebox.showwarning("无数据", "没有可导出的数据")
return
file_path = filedialog.asksaveasfilename(
title="保存Rawdata文件",
defaultextension=".xml",
filetypes=[("XML files", "*.xml"), ("All files", "*.*")]
)
if not file_path:
return
try:
# 使用minidom美化输出
'''
xml_str = ET.tostring(self.rawdata_root, encoding='utf-8').decode('utf-8')
parsed = minidom.parseString(xml_str)
pretty_xml = parsed.toprettyxml(indent=" ")
# 写入文件
with open(file_path, 'w', encoding='utf-8') as file:
file.write(pretty_xml)
'''
self.rawdata_tree.write(file_path, encoding='utf-8', xml_declaration=True)
self.status_var.set(f"Rawdata文件已成功导出到: {os.path.basename(file_path)}")
messagebox.showinfo("导出成功", "Rawdata配置文件已成功导出")
except Exception as e:
messagebox.showerror("导出错误", f"导出文件失败: {str(e)}")
def init_variable_mapping(self):
with open('SV_mapping.txt', 'r') as file:
for line in file.readlines():
parts = line.split()
if len(parts) == 2:
self.variable_mapping[parts[0]] = parts[1]
def init_special_mapping(self):
self.special_mapping_id['LP1_BypassReadID'] = '201210000'
self.special_mapping_name['LP1_BypassReadID'] = 'EFEM_LP1BypassReadID'
self.special_mapping_id['LP1_LoadPortTout'] = '201210001'
self.special_mapping_name['LP1_LoadPortTout'] = 'EFEM_LP1LoadPortTout'
self.special_mapping_id['LP2_BypassReadID'] = '201211000'
self.special_mapping_name['LP2_BypassReadID'] = 'EFEM_LP2BypassReadID'
self.special_mapping_id['LP2_LoadPortTout'] = '201211001'
self.special_mapping_name['LP2_LoadPortTout'] = 'EFEM_LP2LoadPortTout'
self.special_mapping_id['LP3_BypassReadID'] = '201212000'
self.special_mapping_name['LP3_BypassReadID'] = 'EFEM_LP3BypassReadID'
self.special_mapping_id['LP3_LoadPortTout'] = '201212001'
self.special_mapping_name['LP3_LoadPortTout'] = 'EFEM_LP3LoadPortTout'
self.special_mapping_id['CJobSubstProcStatusList'] = '100000004'
self.special_mapping_name['CJobSubstProcStatusList'] = 'CJobSubstProcStatusList'
self.special_mapping_id['ToolState'] = '100000000'
self.special_mapping_name['ToolState'] = 'ToolState'
self.special_mapping_id['Aligner_AngleLA'] = '201209000'
self.special_mapping_name['Aligner_AngleLA'] = 'EFEM_AlignerAngleLA'
self.special_mapping_id['Aligner_AngleLB'] = '201209001'
self.special_mapping_name['Aligner_AngleLB'] = 'EFEM_AlignerAngleLB'
self.special_mapping_id['Aligner_AngleX'] = '201209002'
self.special_mapping_name['Aligner_AngleX'] = 'EFEM_AlignerAngleX'
self.special_mapping_id['Aligner_NotchSupport'] = '201209003'
self.special_mapping_name['Aligner_NotchSupport'] = 'EFEM_AlignerNotchSupport'
self.special_mapping_id['Aligner_Bypass'] = '201209004'
self.special_mapping_name['Aligner_Bypass'] = 'EFEM_AlignerBypass'
self.special_mapping_id['CryoPump_CompressorPressure'] = '101122000'
self.special_mapping_name['CryoPump_CompressorPressure'] = 'System_CryoPumpCompressorPressure'
self.special_mapping_id['CryoPump_CompressorDiffPressure'] = '101122001'
self.special_mapping_name['CryoPump_CompressorDiffPressure'] = 'System_CryoPumpCompressorDiffPressure'
self.special_mapping_id['CryoPump_CompressorSupplyPressure'] = '101122002'
self.special_mapping_name['CryoPump_CompressorSupplyPressure'] = 'System_CryoPumpCompressorSupplyPressure'
self.special_mapping_id['HeatExchanger_RS'] = '100409000'
self.special_mapping_name['HeatExchanger_RS'] = 'System_HeatExchangerRS'
def get_id(self, module_name, var):
if var in self.variable_mapping: #来自mapping,含有前缀CHXXX
temp_var = self.variable_mapping[var]
variable = temp_var.replace('CHXXX', module_name) # Ch1_LotID
else:
temp_var = "CHXXX_" + var #来自配置,不含有前缀CHXXX
variable = module_name + '_' + var # Ch1_LotID
module_id = self.get_module_id(module_name)
temp_id = self.get_id_by_variable(temp_var)
if temp_id and module_id:
if 'XX' in temp_id:
id = temp_id.replace('XX', str(module_id))
return variable.replace('CHXXX', module_name), id
else:
return None, None
def get_id_by_variable(self, variable):
for item in self.rawdata_template:
if item['variable'] == variable:
return item['id']
def split_export(self):
if not self.rawdata_source:
messagebox.showwarning("无数据", "没有可拆分的数据")
return
# 创建分组字典,前缀为data节点列表
groups = defaultdict(list)
# 遍历所有data节点
for data in self.rawdata_root.findall('.//data'):
variable = data.get('variable','')
if '_' in variable:
prefix = variable.split('_', 1)[0]
groups[prefix].append(data)
# 为每个分组创建新的xml文件
for prefix, data in groups.items():
# 创建新根节点(复制原始根节点标签和属性)
new_root = ET.Element(self.rawdata_root.tag, attrib=self.rawdata_root.attrib)
# 复制原始根节点的命名空间
# 复制原始根节点的命名空间
for ns, uri in self.rawdata_root.nsmap.items():
if ns:
ET.register_namespace(ns, uri)
# 添加原始非 data 节点
for child in self.rawdata_root:
if child.tag != 'data':
new_root.append(child)
# 添加分组中的 data 节点
for node in data:
new_root.append(node)
# 创建 XML 树并写入文件
new_tree = ET.ElementTree(new_root)
filename = f"RawData_{prefix}.xml"
new_tree.write(filename,
encoding='utf-8',
xml_declaration=True)
return
# ================ EventConfig 功能 ================
def load_event_template(self):
"""加载Event模板文件(.txt)"""
file_path = filedialog.askopenfilename(
title="选择Event模板文件",
filetypes=[("Text files", "*.txt"), ("All files", "*.*")]
)
if not file_path:
return
try:
with open(file_path, 'r', encoding='utf-8') as file:
lines = file.readlines()
self.event_template = []
self.event_mapping = {}
# 清空表格
for item in self.event_template_table.get_children():
self.event_template_table.delete(item)
# 解析模板文件
for line in lines:
line = line.strip()
if not line:
continue
# 分割行数据
parts = line.split()
if len(parts) < 2:
continue
# 提取前两列
name = parts[0]
id = parts[1] if len(parts) > 1 else ""
mapping = parts[2] if len(parts) > 2 else None
# 提取type
name_parts = name.split('_',1)
if len(name_parts) < 2:
continue
type = name_parts[1]
self.event_categories.append(type)
if mapping:
mapping_parts = mapping.split(';')
for map in mapping_parts:
if map in self.event_mapping:
messagebox.showwarning("数据有误","请确认Event模板数据中mapping列是否有重复数据")
else:
self.event_mapping[map] = name
self.event_template.append({
"name": name,
"id": id,
"type": type,
"mapping": mapping
})
# 添加到表格
self.event_template_table.insert("", tk.END, values=(name, id, type, mapping))
self.event_categories = sorted(self.event_categories, key=len, reverse=True)
self.status_var.set(f"已加载Event模板: {os.path.basename(file_path)} - {len(self.event_template)} 条记录")
except Exception as e:
messagebox.showerror("加载错误", f"加载Event模板文件失败: {str(e)}")
def load_event_source(self):
"""加载Event源文件(.xml)"""
file_path = filedialog.askopenfilename(
title="选择Event源文件",
filetypes=[("XML files", "*.xml"), ("All files", "*.*")]
)
if not file_path:
return
try:
self.event_tree = ET.parse(file_path)
self.event_root = self.event_tree.getroot()
self.event_source = self.event_tree
# 在文本框中显示XML内容
self.display_xml_content(self.event_tree, self.event_xml_text)
self.status_var.set(f"已加载Event源文件: {os.path.basename(file_path)}")
except Exception as e:
messagebox.showerror("加载错误", f"加载Event源文件失败: {str(e)}")
def add_id_to_event(self):
"""为Event源文件添加ID属性"""
if not self.event_source:
messagebox.showwarning("无数据", "请先加载Event源文件")
return
# 添加ID属性
count = 0
for event in self.event_root.findall('.//event'):
if 'id' not in event.attrib:
# 在属性开头位置添加id属性
new_attrib = OrderedDict()
new_attrib['id'] = ''
for key, value in event.attrib.items():
new_attrib[key] = value
# data.attrib = new_attrib
event.attrib.clear()
for key, value in new_attrib.items():
event.set(key, value)
count += 1
# 更新XML显示
self.display_xml_content(self.event_tree, self.event_xml_text)
self.status_var.set(f"已为{count}个event元素添加ID属性")
def get_id_from_event_template(self, event):
for item in self.event_template:
if item['name'] == event:
return item['id']
def get_id_event(self, module, cat):
if cat in self.event_mapping:
temp_name = self.event_mapping[cat]
else:
temp_name = "CHXXX_" + cat
module_id = self.get_module_id(module)
temp_id = self.get_id_from_event_template(temp_name)
name = module + '_' + cat
if temp_id and module_id:
id = temp_id.replace('XX', str(module_id))
return name, id
else:
return None, None
def split_by_type(self, event_name):
if not self.event_categories:
return
for cat in self.event_categories:
if event_name.endswith(cat):
print('split_by_type:' + cat +'orign:' + event_name)
module = event_name[:-len(cat)]
return module, cat
def fill_event_attributes(self):
"""填充Event属性(占位)"""
# messagebox.showinfo("功能待实现", "填充属性功能将在后续版本实现")
# 加载映射表 待实现
if not self.event_source:
messagebox.showwarning("无数据", "请先加载EventConfig源文件")
return
if not self.event_template:
messagebox.showwarning("无数据", "请先加载EventConfig模板文件")
return
fill_count = 0
not_exist = []
not_exist_all = []
for data_elem in self.event_tree.findall('.//event'):
name = data_elem.get('name')
module, cat = self.split_by_type(name)
print('module:'+module+'cat:'+cat)
temp_name, temp_id = self.get_id_event(module, cat)
#print('temp_name:'+temp_name+' temp_id:'+temp_id)
if temp_name and temp_id:
data_elem.set('name', temp_name)
data_elem.set('id', temp_id)
fill_count += 1
else:
if temp_id is None and cat not in not_exist:
not_exist.append(cat)
if temp_id is None:
not_exist_all.append(name)
self.display_xml_content(self.event_tree, self.event_xml_text)
self.status_var.set(f"已为{fill_count}个event补充id属性,剩余{len(not_exist)}个不在模板中,总共剩余{len(not_exist_all)}个")
def export_event(self):
"""导出Event源文件"""
if not self.event_source:
messagebox.showwarning("无数据", "没有可导出的数据")
return
file_path = filedialog.asksaveasfilename(
title="保存Event文件",
defaultextension=".xml",
filetypes=[("XML files", "*.xml"), ("All files", "*.*")]
)
if not file_path:
return
try:
self.event_tree.write(file_path, encoding='utf-8', xml_declaration=True)
self.status_var.set(f"Event文件已成功导出到: {os.path.basename(file_path)}")
messagebox.showinfo("导出成功", "Event配置文件已成功导出")
except Exception as e:
messagebox.showerror("导出错误", f"导出文件失败: {str(e)}")
def split_export_event(self):
return
if __name__ == "__main__":
root = tk.Tk()
app = ConfigUpdaterApp(root)
root.mainloop()
RawDataConfig.py内容:import sys
import xml.etree.ElementTree as ET
from PyQt5.QtWidgets import (QApplication, QMainWindow, QTableWidget, QTableWidgetItem,
QPushButton, QFileDialog, QLineEdit, QLabel, QMessageBox,
QHBoxLayout, QVBoxLayout, QWidget, QHeaderView, QAbstractItemView,
QComboBox, QSizePolicy, QStyledItemDelegate)
from PyQt5.QtCore import Qt, QSize
from PyQt5.QtGui import QBrush, QColor, QFont
import os
class ComboBoxDelegate(QStyledItemDelegate):
def __init__(self, parent=None, options=None):
super().__init__(parent)
self.options = options or []
def createEditor(self, parent, option, index):
editor = QComboBox(parent)
editor.setEditable(True)
editor.addItems(self.options)
return editor
def setEditorData(self, editor, index):
value = index.data(Qt.DisplayRole)
if value:
editor.setCurrentText(value)
def setModelData(self, editor, model, index):
model.setData(index, editor.currentText(), Qt.EditRole)
class XMLDataManager(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("RawDataConfig编辑器")
self.setGeometry(100, 100, 1400, 800)
self.current_file = None
self.original_data = []
self.display_data = []
self.temp_data = []
self.row_counter = 1
self.type_options = set()
self.data_type_id_options = set()
self.is_searching = False
self.search_results_indices = []
self.search_text = ""
self.block_updates = False # 用于阻止递归更新
# 定义字体
self.normal_font = QFont()
self.bold_font = QFont()
self.bold_font.setBold(True)
self.column_names = [
"path", "type", "variable", "id", "data_type_id",
"subsystem_id", "parts", "parts_id", "attribute",
"attribute_id", "mapping"
]
self.required_columns = [col for col in self.column_names if col != "mapping"]
self.init_ui()
def init_ui(self):
central_widget = QWidget()
self.setCentralWidget(central_widget)
self.load_btn = QPushButton("加载文件")
self.add_btn = QPushButton("添加记录")
self.delete_btn = QPushButton("删除记录")
self.export_btn = QPushButton("导出文件")
self.search_btn = QPushButton("搜索")
self.clear_btn = QPushButton("清空搜索")
button_style = """
QPushButton {
background-color: rgb(65, 105, 225);
color: white;
border: none;
padding: 8px 16px;
text-align: center;
font-size: 14px;
margin: 4px 2px;
border-radius: 4px;
}
QPushButton:hover {
background-color: rgb(55, 95, 215);
}
QPushButton:pressed {
background-color: rgb(45, 85, 205);
}
"""
for btn in [self.load_btn, self.export_btn, self.add_btn,
self.delete_btn, self.search_btn, self.clear_btn]:
btn.setStyleSheet(button_style)
self.search_box = QLineEdit()
self.search_box.setPlaceholderText("输入搜索内容...")
self.search_box.setMinimumWidth(300)
self.search_box.setStyleSheet("""
QLineEdit {
padding: 8px;
border: 1px solid #ccc;
border-radius: 4px;
font-size: 14px;
}
""")
self.column_combo = QComboBox()
self.column_combo.setMinimumWidth(120)
self.column_combo.addItem("所有列")
self.column_combo.addItems(self.column_names)
self.column_combo.setCurrentIndex(0)
self.column_combo.setStyleSheet("""
QComboBox {
padding: 6px;
border: 1px solid #ccc;
border-radius: 4px;
font-size: 14px;
}
""")
self.table = QTableWidget()
self.table.setColumnCount(len(self.column_names) + 1)
headers = ["序号"] + self.column_names
self.table.setHorizontalHeaderLabels(headers)
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Interactive)
self.table.horizontalHeader().setStretchLastSection(True)
self.table.setSelectionBehavior(QTableWidget.SelectRows)
self.table.setSelectionMode(QAbstractItemView.ExtendedSelection)
# 使用cellChanged信号处理单元格编辑
self.table.cellChanged.connect(self.handle_cell_change)
self.table.setStyleSheet("""
QTableWidget {
gridline-color: #ddd;
font-size: 12px;
}
QHeaderView::section {
background-color: #f2f2f2;
padding: 4px;
border: 1px solid #ddd;
font-weight: bold;
}
QTableCornerButton::section {
background-color: #f2f2f2;
border: 1px solid #ddd;
}
""")
self.table.setColumnWidth(0, 60)
self.table.verticalHeader().setVisible(False)
self.table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
top_layout = QHBoxLayout()
top_layout.addWidget(self.load_btn)
top_layout.addWidget(self.add_btn)
top_layout.addWidget(self.delete_btn)
top_layout.addWidget(self.export_btn)
top_layout.addStretch()
search_col_label = QLabel("搜索列:")
search_col_label.setStyleSheet("font-size: 14px;")
top_layout.addWidget(search_col_label)
top_layout.addWidget(self.column_combo)
search_col_label1 = QLabel("搜索内容:")
search_col_label1.setStyleSheet("font-size: 14px;")
top_layout.addWidget(search_col_label1)
top_layout.addWidget(self.search_box)
top_layout.addWidget(self.search_btn)
top_layout.addWidget(self.clear_btn)
main_layout = QVBoxLayout()
main_layout.addLayout(top_layout)
main_layout.addWidget(self.table)
central_widget.setLayout(main_layout)
self.load_btn.clicked.connect(self.load_xml)
self.export_btn.clicked.connect(self.export_xml)
self.add_btn.clicked.connect(self.add_record)
self.delete_btn.clicked.connect(self.delete_record)
self.search_btn.clicked.connect(self.search_records)
self.clear_btn.clicked.connect(self.clear_search)
self.statusBar = self.statusBar()
self.statusBar.setStyleSheet("background-color: #f0f0f0; padding: 4px;")
def handle_cell_change(self, row, col):
"""处理单元格内容改变"""
if self.block_updates or col == 0: # 忽略序号列的修改
return
try:
# 临时断开信号连接,避免递归调用
self.table.cellChanged.disconnect()
self.block_updates = True
col_idx = col - 1
if col_idx < 0 or col_idx >= len(self.column_names):
return
col_name = self.column_names[col_idx]
item = self.table.item(row, col)
new_value = item.text()
# 更新数据
if self.is_searching:
# 在搜索模式下,需要找到原始数据中的对应位置
if row < len(self.search_results_indices):
original_idx = self.search_results_indices[row]
if original_idx < len(self.temp_data):
self.temp_data[original_idx][col_name] = new_value
# 同步更新显示数据
if row < len(self.display_data):
self.display_data[row][col_name] = new_value
else:
# 非搜索模式直接更新
if row < len(self.temp_data):
self.temp_data[row][col_name] = new_value
if row < len(self.display_data):
self.display_data[row][col_name] = new_value
# 重新应用样式
self.apply_cell_style(item, col_name, new_value)
except Exception as e:
QMessageBox.critical(self, "错误", f"修改数据时发生错误:\n{str(e)}")
finally:
# 恢复信号连接
self.block_updates = False
self.table.cellChanged.connect(self.handle_cell_change)
def apply_cell_style(self, item, col_name, cell_text):
"""应用单元格样式"""
# 重置样式
item.setFont(self.normal_font)
item.setBackground(QColor(255, 255, 255))
# 检查必填项
if col_name in self.required_columns and not cell_text.strip():
item.setBackground(QColor(255, 200, 200))
# 如果是搜索状态且单元格文本包含搜索词,则加粗
if self.is_searching and self.search_text:
lower_text = cell_text.lower()
if self.search_text in lower_text:
item.setFont(self.bold_font)
def load_xml(self):
file_path, _ = QFileDialog.getOpenFileName(
self, "选择XML文件", "", "XML文件 (*.xml)"
)
if not file_path:
return
try:
tree = ET.parse(file_path)
root = tree.getroot()
self.current_file = file_path
file_name = os.path.basename(file_path)
self.setWindowTitle(f"RawDataConfig编辑器 - {file_name}")
self.table.setRowCount(0)
self.original_data = []
self.display_data = []
self.temp_data = []
self.row_counter = 1
self.type_options = set()
self.data_type_id_options = set()
self.is_searching = False
self.search_results_indices = []
self.search_text = ""
for record in root.findall('Record'):
row_data = {}
for col_name in self.column_names:
value = record.get(col_name, '')
row_data[col_name] = value
if col_name == 'type' and value:
self.type_options.add(value)
elif col_name == 'data_type_id' and value:
self.data_type_id_options.add(value)
self.original_data.append(row_data)
self.temp_data = [row.copy() for row in self.original_data]
self.display_data = self.temp_data.copy()
self.populate_table()
self.adjust_column_widths()
self.statusBar.showMessage(f"成功加载文件: {file_path}", 3000)
except Exception as e:
QMessageBox.critical(self, "错误", f"加载XML文件失败:\n{str(e)}")
def populate_table(self, data=None, indices=None):
if data is None:
data = self.display_data
try:
self.table.cellChanged.disconnect()
except:
pass
self.table.setRowCount(len(data))
type_col_index = self.column_names.index('type') + 1
data_type_id_col_index = self.column_names.index('data_type_id') + 1
type_delegate = ComboBoxDelegate(self.table, sorted(self.type_options))
data_type_id_delegate = ComboBoxDelegate(self.table, sorted(self.data_type_id_options))
self.table.setItemDelegateForColumn(type_col_index, type_delegate)
self.table.setItemDelegateForColumn(data_type_id_col_index, data_type_id_delegate)
for row_idx, record in enumerate(data):
# 保留原始序号
if indices and row_idx < len(indices):
original_idx = indices[row_idx]
seq_item = QTableWidgetItem(str(original_idx + 1))
else:
# 在非搜索模式下,使用当前行号
seq_item = QTableWidgetItem(str(row_idx + 1))
seq_item.setTextAlignment(Qt.AlignCenter)
seq_item.setFlags(seq_item.flags() & ~Qt.ItemIsEditable)
seq_item.setFont(self.normal_font)
self.table.setItem(row_idx, 0, seq_item)
for col_idx, col_name in enumerate(self.column_names):
value = record.get(col_name, '')
item = QTableWidgetItem(value)
self.apply_cell_style(item, col_name, value)
if col_name in ['type', 'data_type_id']:
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.table.setItem(row_idx, col_idx + 1, item)
self.table.cellChanged.connect(self.handle_cell_change)
def adjust_column_widths(self):
self.table.setColumnWidth(0, 60)
for col in range(1, self.table.columnCount()):
self.table.resizeColumnToContents(col)
if self.table.columnWidth(col) < 100:
self.table.setColumnWidth(col, 100)
def export_xml(self):
if not self.temp_data:
QMessageBox.warning(self, "警告", "没有数据可导出")
return
# 检查必填字段
empty_fields = []
for idx, record in enumerate(self.temp_data):
for col_name in self.required_columns:
if not record.get(col_name, '').strip():
# 行号为idx+1
empty_fields.append(f"行 {idx+1} 的 '{col_name}' 列")
if empty_fields:
error_msg = "以下必填项为空,请填写完整后导出:\n"
error_msg += "\n".join(empty_fields[:10]) # 最多显示10条
if len(empty_fields) > 10:
error_msg += f"\n...(共{len(empty_fields)}个错误)"
QMessageBox.warning(self, "导出失败", error_msg)
return
file_path, _ = QFileDialog.getSaveFileName(
self, "导出XML文件", "", "XML文件 (*.xml)"
)
if not file_path:
return
try:
with open(file_path, 'wb') as f:
f.write(b'<?xml version="1.0" ?>\n')
f.write(b'<DataRecords>\n')
for record in self.temp_data:
attrs = ' '.join([f'{k}="{v}"' for k, v in record.items()])
f.write(f' <Record {attrs}/>\n'.encode('utf-8'))
f.write(b'</DataRecords>')
self.statusBar.showMessage(f"成功导出到: {file_path}", 3000)
except Exception as e:
QMessageBox.critical(self, "错误", f"导出XML文件失败:\n{str(e)}")
def add_record(self):
selected_rows = set(index.row() for index in self.table.selectedIndexes())
insert_row = self.table.rowCount()
if selected_rows:
insert_row = min(selected_rows) + 1
self.table.insertRow(insert_row)
new_record = {col_name: "" for col_name in self.column_names}
# 根据当前状态添加到不同的数据列表
if self.is_searching:
# 在搜索状态下添加记录到临时数据和显示数据
self.display_data.insert(insert_row, new_record)
# 找到合适的原始索引位置插入
if insert_row < len(self.search_results_indices):
insert_original_pos = self.search_results_indices[insert_row]
else:
insert_original_pos = len(self.temp_data)
self.temp_data.insert(insert_original_pos, new_record)
# 更新后续的搜索结果索引
self.search_results_indices = [x if x < insert_original_pos else x + 1 for x in self.search_results_indices]
self.search_results_indices.insert(insert_row, insert_original_pos)
else:
self.display_data.insert(insert_row, new_record)
self.temp_data.insert(insert_row, new_record)
# 序号将在populate_table中设置
self.populate_table()
self.table.scrollToItem(self.table.item(insert_row, 0))
self.table.selectRow(insert_row)
self.statusBar.showMessage("已添加新记录", 2000)
def delete_record(self):
selected_rows = set(index.row() for index in self.table.selectedIndexes())
if not selected_rows:
QMessageBox.warning(self, "警告", "请先选择要删除的记录")
return
reply = QMessageBox.question(self, "确认删除",
f"确定要删除选中的 {len(selected_rows)} 条记录吗?",
QMessageBox.Yes | QMessageBox.No)
if reply != QMessageBox.Yes:
return
# 按降序删除以避免索引问题
for row in sorted(selected_rows, reverse=True):
self.table.removeRow(row)
if row < len(self.display_data):
del self.display_data[row]
if self.is_searching and row < len(self.search_results_indices):
# 如果是搜索状态,需要从原始数据中删除
original_idx = self.search_results_indices[row]
if original_idx < len(self.temp_data):
del self.temp_data[original_idx]
# 更新搜索结果索引
self.search_results_indices = [x if x < original_idx else x - 1 for x in self.search_results_indices]
self.search_results_indices.pop(row)
elif not self.is_searching and row < len(self.temp_data):
del self.temp_data[row]
self.populate_table()
self.statusBar.showMessage(f"已删除 {len(selected_rows)} 条记录", 3000)
def search_records(self):
search_text = self.search_box.text().strip()
selected_column = self.column_combo.currentText()
if not search_text:
QMessageBox.warning(self, "警告", "请输入搜索内容")
return
self.is_searching = True
self.search_text = search_text.lower()
self.search_results_indices = []
matched_rows = []
# 搜索基于临时数据(包含所有修改)
for original_idx, record in enumerate(self.temp_data):
match_found = False
if selected_column == "所有列":
for col_name in self.column_names:
value = record.get(col_name, '').lower()
if self.search_text in value:
match_found = True
break
else:
value = record.get(selected_column, '').lower()
if self.search_text in value:
match_found = True
if match_found:
self.search_results_indices.append(original_idx)
matched_rows.append(record)
if matched_rows:
self.display_data = matched_rows
# 传递原始索引用于显示正确的序号
self.populate_table(self.display_data, self.search_results_indices)
self.adjust_column_widths()
self.statusBar.showMessage(f"找到 {len(matched_rows)} 条匹配记录", 3000)
else:
QMessageBox.information(self, "搜索结果", "未找到匹配记录")
self.statusBar.showMessage("未找到匹配记录", 2000)
def clear_search(self):
self.display_data = [row.copy() for row in self.temp_data]
self.is_searching = False
self.search_text = ""
self.search_box.clear()
self.search_results_indices = []
self.populate_table()
self.adjust_column_widths()
self.statusBar.showMessage("已显示所有记录", 2000)
if __name__ == "__main__":
app = QApplication(sys.argv)
window = XMLDataManager()
window.show()
sys.exit(app.exec_())
将第二个程序合并到第一个程序中,作为第一个程序的第一个子页面,输出完整程序