Tkinter在不同小部件之间生成和调用虚拟事件

Question

在tkinter中编写一些简单的图形用户界面应用程序时，我遇到了一些小问题。假设我有自定义菜单小部件（派生自tk.menu）和自定义画布小部件（派生自tk.canvas）。

我想从菜单回调函数生成事件并在画布小部件中调用它。我需要这样做，因为它的未来，我想添加更多的小部件，应作出反应，点击位置在菜单上。

我试着那样做：

自定义菜单：

class MainMenu(tk.Menu):

    def __init__(self, parent):
       tk.Menu.__init__(self, parent)
       self.add_comand(label='foo', self._handler)
       return

    def _handler(self, *args):
        print('handling menu')       
        self.event_generate('<<abc>>')
        return

自定义画布：

class CustomCanvas(tk.Canvas): 
    def __init__(self, parent, name=''):
        tk.Canvas.__init__(self, parent)
        self.bind('<<abc>>', self.on_event)
        return

    def on_event(self, event):
       print(event)
       return

当我单击菜单中的“位置”时，会正确调用“处理程序回调”并生成“事件”<；gt；，但不会调用“打开事件回调”。我试图添加when='tail'参数、add self.update（）等，但没有任何结果。有人知道怎么做吗？

Answer 1

下面是创建自定义虚拟事件的示例代码。我创建此代码是为了模拟调用服务器，这些服务器需要很长时间才能响应数据：

#Custom Virtual Event

try:
    from Tkinter import *
    import tkMessageBox
except ImportError:
    try:
        from tkinter import *
        from tkinter import messagebox
    except Exception:
        pass

import time
from threading import Thread

VirtualEvents=["<<APP_DATA>>","<<POO_Event>>"]

def TS_decorator(func):
    def stub(*args, **kwargs):
        func(*args, **kwargs)

    def hook(*args,**kwargs):
        Thread(target=stub, args=args).start()

    return hook

class myApp:
    def __init__(self):
        self.root = Tk()
        self.makeWidgets(self.root)
        self.makeVirtualEvents()
        self.state=False
        self.root.mainloop()

    def makeWidgets(self,parent):
        self.lbl=Label(parent)
        self.lbl.pack()
        Button(parent,text="Get Data",command=self.getData).pack()

    def onVirtualEvent(self,event):
        print("Virtual Event Data: {}".format(event.VirtualEventData))
        self.lbl.config(text=event.VirtualEventData)

    def makeVirtualEvents(self):
        for e in VirtualEvents:
            self.root.event_add(e,'None') #Can add a trigger sequence here in place of 'None' if desired
            self.root.bind(e, self.onVirtualEvent,"%d")

    def FireVirtualEvent(self,vEvent,data):
        Event.VirtualEventData=data
        self.root.event_generate(vEvent)


    def getData(self):
        if not self.state:
            VirtualServer(self)
        else:
            pooPooServer(self)

        self.state = not self.state


@TS_decorator
def VirtualServer(m):
    time.sleep(3)
    m.FireVirtualEvent(VirtualEvents[0],"Hello From Virtual Server")

@TS_decorator
def pooPooServer(m):
    time.sleep(3)
    m.FireVirtualEvent(VirtualEvents[1],"Hello From Poo Poo Server")


if __name__=="__main__":
    app=myApp()

在这个代码示例中，我正在创建自定义虚拟事件，在模拟服务器完成数据检索后调用这些事件。事件处理程序onVirtualEvent绑定到根级别的自定义虚拟事件。

单击按钮时，模拟服务器将在单独的执行线程中运行。我使用一个定制的decorator，TS_decorator，来创建调用模拟服务器将运行的执行线程。

我的方法真正有趣的部分是，我可以通过调用firevirtualent方法将从模拟服务器检索到的数据提供给事件处理程序。在这个方法中，我将向事件类添加一个自定义属性，该属性将保存要传输的数据。然后，我的事件处理程序将使用此自定义属性从服务器中提取数据。

虽然在概念上很简单，但是这个示例代码也减轻了在处理需要长时间执行的代码时GUI元素不更新的问题。因为所有的工作代码都是在一个单独的执行线程中执行的，所以对函数的调用会很快返回，这就允许GUI元素进行更新。请注意，我还将对myApp类的引用传递给模拟服务器，以便它们可以在数据可用时调用其FireVirtualEvent方法。

Answer 2

最后，我使用了Bryan的解决方案，并进行了一些改进（我希望在模块之间保持一些分隔，以便并行地开发它们）。

总体思路：

• 添加方法以保存特定虚拟事件的“侦听器”小部件列表

• 在根/应用程序设置过程中，使用自定义方法在小部件之间配置“绑定网络”；

• 在“listener”小部件中添加特定虚拟事件的绑定
• 当应该生成虚拟事件时，“generator”小部件会为所有注册的“listener”小部件触发带有when='tail'参数的事件，以避免立即调用。

配置绑定网络：

virt_event = '<<open file menu>>'

class mainApp:
    def __init__(self):
        self.root = tk.Tk()
        self.menu = myMenu(self.root)
        self.canvas1 = myCanvas(self.root)
        self.canvas2 = myCanvas(self.root)
        return

    ''' some init and setup widgets etc. '''

    def root_bindings():
        listeners_list = [self.canvas1, self.canvas2]
        self.menu.add_evt_listeners(virt_event, listeners_list)
        return

在小部件中绑定虚拟事件：

class myCanvas(tk.Canvas):
    def __init__(self, parent):
        tk.Canvas.__init__(self, parent)
        self._event_bindigs()
        return

   def _event_bindings(self):
       self.bind(virt_event, self.on_open_file)
       return

   def on_open_file(self, event):
       print('open file event')
       return

向“generator”小部件添加方法以保存“listener”小部件的列表：

class myMenu(tk.Menu):
    def __init__(self, parent):
        tk.Menu.__init__(self, parent)
        self.listeners = {} #dict to keep listeners
        return

    def add_event_listeners(self, event, listeners):
        if not isinstance(listeners, list):
            listeners = [listeners]
        if(event in self.events_listeners.keys()):
            self.events_listeners[event] += listeners
        else:
            self.events_listeners[event] = listeners
        return

    ''' some menu components setup including internal events'''

    def open_file(self, filename):
        ''' some internal handling menu '''
        self.open_file_handler(filename)

        ''' broadcast event to registered widgets '''
        for listener in self.event_listeners[virt_event]:
            listener.event_generate(virt_event, when='tail')
        return

Answer 3

您需要将绑定添加到获取事件的小部件。在您的例子中，您是在菜单上生成事件的，因此需要绑定到菜单。

您还可以在画布上生成事件，并将绑定保留在画布上。或者，将事件与根窗口关联，并绑定到根窗口。

tkinter本身在某些情况下使用的一种常见技术是在根窗口上生成事件，然后在根窗口上（或者对于所有具有bind_all的窗口）为该事件创建一个绑定。然后，单个绑定必须通过某种方式确定要影响哪个窗口（通常，例如，通过键盘焦点获取窗口）。

当然，如果有方法确定哪个小部件获得绑定，那么可以在生成事件时使用该方法直接在相应的小部件上生成事件。

有关更多信息，请参见http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm，特别是文档中标题为“实例和类绑定”的部分。