Tkinter GUI问题求助：Entry框异常显示、保存功能失效、按钮位置调整及验证方式修改

我用Python写了一个Tkinter GUI，它会读取如下格式的配置文件：

[job1]
EXEC_PATH = /usr/path
RUNIT = echo job1
TYPES = ['schedule' , 'tumbling']  
[job2]
EXEC_PATH = /usr/path
RUNIT = echo job2
PARENTS = job1
TYPES = [ 'tumbling']
[job3]
EXEC_PATH = /usr/path
RUNIT = echo job3
PARENTS = job2

这个GUI会根据配置文件里的PARENTS选项展示作业的执行顺序，但目前遇到了几个棘手的问题：

• 问题1：每个作业节点上都有一个选项菜单，当我连续点击“Show job details”和“Edit job details”，甚至有时候单点击菜单时，右侧的tk.Entry框里会显示出类似.!panedwindow.!frame.!frame2.!frame.!entry这样的控件路径字符串，而不是作业的具体参数。
• 问题2：编辑完作业参数后，点击右侧的“Save”按钮，修改后的信息没法保存到磁盘上的配置文件里，文件内容还是原来的样子。
• 问题3：现在“Validate”按钮在右侧面板的顶部区域，能不能把它移动到作业参数展示区域的下方，布局更合理一些？
• 问题4：现在验证输入文件是用弹出对话框提示结果，能不能改成用固定标签显示，验证成功时用绿色文字，失败时用红色文字，不用每次弹框？

我的代码 #

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from argparse import ArgumentParser
import configparser
import os
import subprocess

def parse():
    parser = ArgumentParser()
    parser.add_argument("-input_file", help="Input input file.", required=False)
    parser.add_argument("-type", help="Filter sections by types.", choices=['schedule', 'tumbling'], required=False)

    args = parser.parse_args()

    return args

class JobLevels:
    def __init__(self, input_file=None, type_filter=None):
        self.input_file = input_file
        self.type_filter = type_filter
        self.deps_dict = {}
        self.level_dict = {}
        self.visited_files = set()
        self.sections = {}

    def parse_input_file(self, input_file):
        if input_file in self.visited_files:
            return
        self.visited_files.add(input_file)

        config = configparser.ConfigParser(allow_no_value=True)
        config.optionxform = str  # Preserve case sensitivity
        config.read(input_file)

        for section in config.sections():
            if section == 'include':
                for include_file in config.options(section):
                    include_file_path = os.path.join(os.path.dirname(input_file), include_file)
                    self.parse_input_file(include_file_path)
            else:
                self.sections[section] = {}
                self.sections[section]['EXEC_PATH'] = config.get(section, 'EXEC_PATH', fallback=None)
                self.sections[section]['RUNIT'] = config.get(section, 'RUNIT', fallback=None)
                self.sections[section]['PARENTS'] = config.get(section, 'PARENTS', fallback=None)
                self.sections[section]['TYPES'] = config.get(section, 'TYPES', fallback=None)
                self.sections[section]['RATING'] = config.get(section, 'RATING', fallback='0')

    def filter_sections_by_type(self):
        if not self.type_filter:
            return

        filtered_sections = {}
        for section, attributes in self.sections.items():
            types = attributes['TYPES']
            if types:
                types_list = [type.strip() for type in types.strip('[]').split(',')]
                if self.type_filter in types_list:
                    filtered_sections[section] = attributes
            else:
                # If TYPES key is not present
                filtered_sections[section] = attributes

        self.sections = filtered_sections

    def build_deps_dict(self):
        for section, attributes in self.sections.items():
            deps = attributes['PARENTS']
            if deps:
                deps_list = [dep.strip() for dep in deps.split(',')]
                self.deps_dict[section] = deps_list

    def assign_level(self, section):
        if section not in self.level_dict:
            if section not in self.deps_dict or not self.deps_dict[section]:
                self.level_dict[section] = 0
            else:
                levels = []
                for dep_section in self.deps_dict[section]:
                    temp_level = self.assign_level(dep_section)
                    levels.append(temp_level)
                self.level_dict[section] = max(levels) + 1
        return self.level_dict[section]

    def start_proc(self):
        if self.input_file:
            self.visited_files.clear()
            self.sections.clear()
            self.deps_dict.clear()
            self.level_dict.clear()
            self.parse_input_file(self.input_file)
            self.filter_sections_by_type()
            self.build_deps_dict()
            for section in self.deps_dict:
                self.assign_level(section)

class Viewer:
    def __init__(self, root, node_order_finder):
        self.root = root
        self.node_order_finder = node_order_finder

        self.main_paned_window = ttk.PanedWindow(root, orient=tk.HORIZONTAL)
        self.main_paned_window.pack(fill=tk.BOTH, expand=True)

        self.left_paned_window = ttk.PanedWindow(self.main_paned_window, orient=tk.VERTICAL)
        self.main_paned_window.add(self.left_paned_window, weight=3)

        self.right_panel = tk.Frame(self.main_paned_window, width=200, bg="lightgray")
        self.main_paned_window.add(self.right_panel, weight=1)

        self.top_frame = tk.Frame(self.left_paned_window)
        self.left_paned_window.add(self.top_frame, weight=3)

        self.bottom_panel = tk.Frame(self.left_paned_window, height=200, bg="lightgray")
        self.left_paned_window.add(self.bottom_panel, weight=1)

        self.canvas = tk.Canvas(self.top_frame, bg="white")
        self.h_scrollbar = tk.Scrollbar(self.top_frame, orient=tk.HORIZONTAL, command=self.canvas.xview)
        self.v_scrollbar = tk.Scrollbar(self.top_frame, orient=tk.VERTICAL, command=self.canvas.yview)
        self.scrollable_frame = tk.Frame(self.canvas)

        self.scrollable_frame.bind(
            "<Configure>",
            lambda e: self.canvas.configure(
                scrollregion=self.canvas.bbox("all")
            )
        )

        self.canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
        self.canvas.configure(xscrollcommand=self.h_scrollbar.set, yscrollcommand=self.v_scrollbar.set)

        self.h_scrollbar.pack(side=tk.BOTTOM, fill=tk.X)
        self.v_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

        self.type_var = tk.StringVar(value="All")
        self.create_widgets()
        self.draw_graph()

    def create_widgets(self):
        control_frame = tk.Frame(self.right_panel)
        control_frame.pack(side=tk.TOP, fill=tk.X)

        type_label = tk.Label(control_frame, text="Event:")
        type_label.pack(side=tk.LEFT, padx=5, pady=5)

        type_options = ["All", "schedule", "tumbling"]
        type_menu = ttk.Combobox(control_frame, textvariable=self.type_var, values=type_options)
        type_menu.pack(side=tk.LEFT, padx=5, pady=5)
        type_menu.bind("<<ComboboxSelected>>", self.on_type_change)

        browse_button = tk.Button(control_frame, text="Browse input File", command=self.browse_file)
        browse_button.pack(side=tk.LEFT, padx=5, pady=5)

        save_button = tk.Button(control_frame, text="Save", command=self.save_input_file)
        save_button.pack(side=tk.LEFT, padx=5, pady=5)

        self.stage_params_frame = tk.Frame(self.right_panel)
        self.stage_params_frame.pack(side=tk.TOP, fill=tk.BOTH, expand=True)

        self.validate_button = tk.Button(self.right_panel, text="Validate", command=self.validate_input)
        self.validate_button.pack(side=tk.TOP, padx=5, pady=5)

    def browse_file(self):
        input_file = filedialog.askopenfilename(filetypes=[("input files", "*.input")])
        if input_file:
            self.node_order_finder.input_file = input_file
            self.node_order_finder.start_proc()
            self.draw_graph()

    def save_input_file(self):
        save_file = filedialog.asksaveasfilename(defaultextension=".input", filetypes=[("input files", "*.input")])
        if save_file:
            config = configparser.ConfigParser()
            for section, attributes in self.node_order_finder.sections.items():
                config[section] = {k: v.get() if isinstance(v, tk.Entry) else v for k, v in attributes.items()}
            with open(save_file, 'w') as configfile:
                config.write(configfile)
            self.node_order_finder.input_file = save_file
            self.node_order_finder.start_proc()
            self.draw_graph()

    def validate_input(self):
        try:
            result = subprocess.run(['ls', self.node_order_finder.input_file], capture_output=True, text=True)
            if result.returncode == 0:
                messagebox.showinfo("Validation", "Validation successful")
            else:
                messagebox.showerror("Validation", f"Error: {result.stderr}")
        except Exception as e:
            messagebox.showerror("Validation", f"Error: {str(e)}")

    def on_type_change(self, type):
        self.node_order_finder.type_filter = self.type_var.get() if self.type_var.get() != "All" else None
        self.node_order_finder.start_proc()
        self.draw_graph()

    def draw_graph(self):
        for widget in self.scrollable_frame.winfo_children():
            widget.destroy()
        # 此处原代码截断，保留现有内容

针对问题的解决方案 #

1. Entry框显示控件路径的问题

这个问题肯定是你在处理菜单点击事件时，不小心把Entry控件对象本身当成文本内容设置到了框里，而不是控件的文本值。比如你可能写了类似entry = tk.Entry(...)然后直接把entry赋值给了显示内容，而不是调用entry.get()或者用entry.insert()设置正确的参数值。

你需要检查“Show job details”和“Edit job details”的事件处理代码，确保填充Entry时传入的是作业的具体参数字符串，比如：

# 正确示例：给EXEC_PATH的Entry设置值
exec_path_entry.delete(0, tk.END)
exec_path_entry.insert(0, self.node_order_finder.sections[selected_job]['EXEC_PATH'])

2. 保存功能失效的问题

看你当前的save_input_file方法，你试图判断属性是否是tk.Entry然后调用v.get()，但问题在于self.node_order_finder.sections里存储的是从配置文件读取的原始字符串，而不是GUI中创建的Entry控件对象。也就是说，你修改了GUI里的Entry，但这些修改没有同步回sections字典，所以保存的还是原来的内容。

解决方法是：在展示作业详情时，把Entry控件和对应的作业、参数关联起来，或者在保存时遍历stage_params_frame里的所有Entry，获取最新值并更新到sections中，再写入文件。修改后的save_input_file可以参考：

def save_input_file(self):
    save_file = filedialog.asksaveasfilename(defaultextension=".input", filetypes=[("input files", "*.input")])
    if save_file:
        # 先同步GUI中修改的值到sections字典
        for widget in self.stage_params_frame.winfo_children():
            if isinstance(widget, tk.Entry) and hasattr(widget, 'job_section') and hasattr(widget, 'param_key'):
                # 假设你在创建Entry时给它绑定了job_section和param_key属性
                section = widget.job_section
                key = widget.param_key
                if section in self.node_order_finder.sections:
                    self.node_order_finder.sections[section][key] = widget.get()
        
        # 写入配置文件，注意保留大小写
        config = configparser.ConfigParser()
        config.optionxform = str
        for section, attributes in self.node_order_finder.sections.items():
            config[section] = attributes
        
        with open(save_file, 'w') as configfile:
            config.write(configfile)
        
        self.node_order_finder.input_file = save_file
        self.node_order_finder.start_proc()
        self.draw_graph()

另外，创建Entry时记得绑定对应的作业和参数：

# 示例：创建EXEC_PATH的Entry时绑定属性
exec_entry = tk.Entry(self.stage_params_frame)
exec_entry.job_section = selected_job
exec_entry.param_key = 'EXEC_PATH'

3. 调整Validate按钮位置的问题

当前你的stage_params_frame设置了fill=tk.BOTH, expand=True，会占据右侧面板的大部分空间，而validate_button是在它之后pack的，所以只需要确保pack顺序正确就行。你现在的代码其实已经是先packstage_params_frame再pack按钮，但可能因为布局细节导致位置不对，你可以稍微调整pack的参数：

def create_widgets(self):
    # ... 其他代码不变 ...
    self.stage_params_frame = tk.Frame(self.right_panel)
    self.stage_params_frame.pack(side=tk.TOP, fill=tk.BOTH, expand=True, padx=5, pady=5)

    self.validate_button = tk.Button(self.right_panel, text="Validate", command=self.validate_input)
    self.validate_button.pack(side=tk.TOP, padx=5, pady=(0,5))

这样stage_params_frame会先填满上方的可扩展区域，按钮自然就会显示在它的下方了。

4. 用标签代替对话框显示验证结果

首先在create_widgets方法里添加一个用来显示验证结果的标签：

def create_widgets(self):
    # ... 其他代码不变 ...
    self.validate_button = tk.Button(self.right_panel, text="Validate", command=self.validate_input)
    self.validate_button.pack(side=tk.TOP, padx=5, pady=(0,5))
    
    # 添加验证结果标签
    self.validation_label = tk.Label(self.right_panel, text="", bg="lightgray")
    self.validation_label.pack(side=tk.TOP, padx=5, pady=(0,5))

然后修改validate_input方法，不再使用messagebox，而是更新这个标签的文本和颜色：

def validate_input(self):
    try:
        # 这里可以根据实际需求修改验证逻辑，比如检查配置格式是否正确
        if os.path.exists(self.node_order_finder.input_file):
            self.validation_label.config(text="验证成功！", fg="green")
        else:
            self.validation_label.config(text="错误：文件不存在", fg="red")
        
        # 如果需要保留原来的subprocess逻辑：
        # result = subprocess.run(['ls', self.node_order_finder.input_file], capture_output=True, text=True)
        # if result.returncode == 0:
        #     self.validation_label.config(text="验证成功！", fg="green")
        # else:
        #     self.validation_label.config(text=f"错误：{result.stderr}", fg="red")
    except Exception as e:
        self.validation_label.config(text=f"错误：{str(e)}", fg="red")

这样验证结果就会显示在按钮下方的标签里，成功时绿色文字，失败时红色文字，体验更流畅。

备注：内容来源于stack exchange，提问作者A.G.Progm.Enthusiast