如何在tkinter中显示加载信息？

Question

我是新来的tkinter。我做了所需的对话框。我的一个函数需要一些时间来处理。所以我想在函数开始执行之前显示一个 "loading ... 所以我想在该函数开始执行之前显示一个 "正在加载... "的信息。

b1 = Button(text = "Compare",command = compare)
b1.pack()

当这个按钮被点击时，比较()函数开始执行，我想在该函数开始执行前显示一个加载信息。我试着使用一个标签，这样我就可以在比较()函数开始时给它设置一个值，但它只有在函数执行完毕后才会生效。

我怎么做呢，请帮帮我。

Answer 1

请看一下 小部件手册. w.wait_visibility(window) 等到小组件可见为止，"正常 "的做法（在所有的GUI工具箱中）是将所有的绘图命令，如你的标签，放在等待列表中，当有时间时再进行实际的绘图，优先考虑其他事件。正常 "的做法（在所有的GUI工具包中）是把所有的绘图命令，比如你的标签，放在一个等待列表中，当有时间的时候再进行实际的绘图，优先考虑其他事件）。从页面上。

等待给定的小组件变成可见。这通常用于等待一个新的toplevel窗口出现在屏幕上。和wait_variable一样，这个方法也会进入一个本地事件循环，所以应用程序的其他部分仍然会照常工作。

一个使用 wait_visibility 来自 测试_widgets.py 代码，在这里setup会等待widget真正显示。

class WidgetTest(unittest.TestCase):
    """Tests methods available in every ttk widget."""

    def setUp(self):
        support.root_deiconify()
        self.widget = ttk.Button(width=0, text="Text")
        self.widget.pack()
        self.widget.wait_visibility()

当然，在这段代码中 compare 功能确实需要一些可观的时间--否则标签可能会在屏幕上看到之前就消失。你的屏幕每秒重绘60次，所以如果比较时间少于16毫秒，你可能什么也看不到。

EDIT: 一个更好的方法是实际使用 update_idletasks. 这里有一些代码。

import tkinter as tk
import time

class SampleApp(tk.Tk):
    def __init__(self, *args, **kwargs):
        tk.Tk.__init__(self, *args, **kwargs)
        self.frame = tk.Frame(self)
        self.frame.pack(side="top", fill = "both", expand=True)

        self.label = tk.Label(self, text = "Hello, world")
        button1 = tk.Button(self, text = "Start to do something",
                                  command = self.do_something)
        self.label.pack(in_=self.frame)
        button1.pack(in_=self.frame)

    def do_something(self):
        self.label.config(text = "Wait till I'm done...")
        self.label.update_idletasks()
        time.sleep(2)
        print ("end sleep")
        self.label.config(text = "I'm done doing...")

def main():
    app = SampleApp()
    app.mainloop()  
    return 0

if __name__ == '__main__':
    main()

这个 time.sleep 在 do_something 模拟你想做的任何事情。点击按钮开始进程。

Answer 2

这将使一个带有不确定进度条的弹出式窗口出现，只要给定的函数在运行，就会出现给定的信息。

from tkinter import *
import tkinter.ttk as ttk
import threading


# the given message with a bouncing progress bar will appear for as long as func is running, returns same as if func was run normally
# a pb_length of None will result in the progress bar filling the window whose width is set by the length of msg
# Ex:  run_func_with_loading_popup(lambda: task('joe'), photo_img)  
def run_func_with_loading_popup(func, msg, window_title = None, bounce_speed = 8, pb_length = None):
    func_return_l = []

    class Main_Frame(object):
        def __init__(self, top, window_title, bounce_speed, pb_length):
            print('top of Main_Frame')
            self.func = func
            # save root reference
            self.top = top
            # set title bar
            self.top.title(window_title)

            self.bounce_speed = bounce_speed
            self.pb_length = pb_length

            self.msg_lbl = Label(top, text=msg)
            self.msg_lbl.pack(padx = 10, pady = 5)

            # the progress bar will be referenced in the "bar handling" and "work" threads
            self.load_bar = ttk.Progressbar(top)
            self.load_bar.pack(padx = 10, pady = (0,10))

            self.bar_init()


        def bar_init(self):
            # first layer of isolation, note var being passed along to the self.start_bar function
            # target is the function being started on a new thread, so the "bar handler" thread
            self.start_bar_thread = threading.Thread(target=self.start_bar, args=())
            # start the bar handling thread
            self.start_bar_thread.start()

        def start_bar(self):
            # the load_bar needs to be configured for indeterminate amount of bouncing
            self.load_bar.config(mode='indeterminate', maximum=100, value=0, length = self.pb_length)
            # 8 here is for speed of bounce
            self.load_bar.start(self.bounce_speed)            
#             self.load_bar.start(8)            

            self.work_thread = threading.Thread(target=self.work_task, args=())
            self.work_thread.start()

            # close the work thread
            self.work_thread.join()


            self.top.destroy()
#             # stop the indeterminate bouncing
#             self.load_bar.stop()
#             # reconfigure the bar so it appears reset
#             self.load_bar.config(value=0, maximum=0)

        def work_task(self):
            func_return_l.append(func())


    # create root window
    root = Tk()

    # call Main_Frame class with reference to root as top
    Main_Frame(root, window_title, bounce_speed, pb_length)
    root.mainloop() 
    return func_return_l[0]

if __name__ == '__main__':
    import time
    def task(i):
        # The window will stay open until this function call ends.
        for x in range(10):
            print('hi: ' + i)
            time.sleep(.5) # Replace this with the code you want to run
        return "this is the func return"

    msg = 'running func...'        

    bounc_speed = 9
    pb_length = 200
    window_title = "Wait"

    r = run_func_with_loading_popup(lambda: task('joe'), msg, window_title, bounc_speed, pb_length)

    print('return of test: ', r)