python - Tkinter 窗口事件

Question

如果窗口可见性发生变化，我会尝试获取一个事件。我发现有一个事件叫做“可见性”。操作系统是 Windows 64 位。所以我通过以下方式实现:

root.bind('<Visibility>', visibilityChanged)

但是无论上面是否有窗口，我总是得到“VisibilityUnobscured”状态。这个事件的正常行为是什么？我怎样才能实现这样的功能？

示例程序:

import tkinter as tk

class GUI:
    def __init__(self, master):
        self.master = master
        master.title("Test GUI")
        self.master.bind('<Visibility>', self.visibilityChanged)
        self.label = tk.Label(master, text="GUI")
        self.label.pack()

        self.close_button = tk.Button(master, text="Close", command=master.quit)
        self.close_button.pack()

    def visibilityChanged(self, event):
        if (str(event.type) == "Visibility"):
            print(event.state)

root = tk.Tk()
my_gui = GUI(root)
root.mainloop()

Answer 1

What is the normal behaviour of this event?

docs 中对其进行了详细描述:
X 服务器在任何窗口的可见性更改状态时生成 VisibilityNotify 事件。

How can I implement a feature like that?

这取决于您要实现自己的愿望多远，因为这不是一项微不足道的任务。因此，不要将该答案视为完整的解决方案，而应将其视为问题概述和一组建议。

事件问题

Windows 操作系统 使用消息传递模型 - 系统通过消息与您的应用程序窗口通信，其中每条消息都是指定特定事件的数字代码。应用程序窗口有一个关联的窗口过程——一个处理(响应或忽略)所有发送的消息的函数。

最通用的解决方案是设置一个钩子(Hook)来捕获某些事件/消息，这可以通过 SetWindowsHookEx 来实现。或 pyHook .

主要问题是获取事件，因为Windows WM 没有VisibilityNotify 这样的消息。正如我在评论部分所说 - 我们可以依赖的一个选项是 z-order (有可能检查窗口的可见性，只要这个窗口改变它在 z-order 中的位置)。
因此我们的目标消息是 WM_WINDOWPOSCHANGING或 WM_WINDOWPOSCHANGED .

一个简单的实现:

import ctypes
import ctypes.wintypes as wintypes
import tkinter as tk


class CWPRETSTRUCT(ctypes.Structure):
    ''' a class to represent CWPRETSTRUCT structure
    https://msdn.microsoft.com/en-us/library/windows/desktop/ms644963(v=vs.85).aspx '''

    _fields_ = [('lResult', wintypes.LPARAM),
                ('lParam', wintypes.LPARAM),
                ('wParam', wintypes.WPARAM),
                ('message', wintypes.UINT),
                ('hwnd', wintypes.HWND)]


class WINDOWPOS(ctypes.Structure):
    ''' a class to represent WINDOWPOS structure
    https://msdn.microsoft.com/en-gb/library/windows/desktop/ms632612(v=vs.85).aspx '''

    _fields_ = [('hwnd', wintypes.HWND),
                ('hwndInsertAfter', wintypes.HWND),
                ('x', wintypes.INT),
                ('y', wintypes.INT),
                ('cx', wintypes.INT),
                ('cy', wintypes.INT),
                ('flags', wintypes.UINT)]


class App(tk.Tk):
    ''' generic tk app with win api interaction '''

    wm_windowposschanged = 71
    wh_callwndprocret = 12
    swp_noownerzorder = 512
    set_hook = ctypes.windll.user32.SetWindowsHookExW
    call_next_hook = ctypes.windll.user32.CallNextHookEx
    un_hook = ctypes.windll.user32.UnhookWindowsHookEx
    get_thread = ctypes.windll.kernel32.GetCurrentThreadId
    get_error = ctypes.windll.kernel32.GetLastError
    get_parent = ctypes.windll.user32.GetParent
    wnd_ret_proc = ctypes.WINFUNCTYPE(ctypes.c_long, wintypes.INT, wintypes.WPARAM, wintypes.LPARAM)

    def __init__(self):
        ''' generic __init__ '''

        super().__init__()
        self.minsize(350, 200)
        self.hook = self.setup_hook()
        self.protocol('WM_DELETE_WINDOW', self.on_closing)

    def setup_hook(self):
        ''' setting up the hook '''

        thread = self.get_thread()
        hook = self.set_hook(self.wh_callwndprocret, self.call_wnd_ret_proc, wintypes.HINSTANCE(0), thread)

        if not hook:
            raise ctypes.WinError(self.get_error())

        return hook

    def on_closing(self):
        ''' releasing the hook '''
        if self.hook:
            self.un_hook(self.hook)
        self.destroy()

    @staticmethod
    @wnd_ret_proc
    def call_wnd_ret_proc(nCode, wParam, lParam):
        ''' an implementation of the CallWndRetProc callback
        https://msdn.microsoft.com/en-us/library/windows/desktop/ms644976(v=vs.85).aspx'''

        #   get a message
        msg = ctypes.cast(lParam, ctypes.POINTER(CWPRETSTRUCT)).contents
        if msg.message == App.wm_windowposschanged and msg.hwnd == App.get_parent(app.winfo_id()):
            #   if message, which belongs to owner hwnd, is signaling that windows position is changed - check z-order
            wnd_pos = ctypes.cast(msg.lParam, ctypes.POINTER(WINDOWPOS)).contents
            print('z-order changed: %r' % ((wnd_pos.flags & App.swp_noownerzorder) != App.swp_noownerzorder))

        return App.call_next_hook(None, nCode, wParam, lParam)


app = App()
app.mainloop()

如您所见，此实现具有与“损坏的”Visibility 事件类似的行为。

这个问题源于这样一个事实，即您只能捕获线程指定的消息，因此应用程序不知道堆栈中的变化。这只是我的假设，但我认为 Visibility 损坏的原因是相同的。

当然，我们可以为所有消息设置一个全局钩子(Hook)，而不管线程，但这种方法需要 DLL 注入(inject)，这肯定是另一回事。

可见性问题

确定窗口的遮挡不是问题，因为我们可以依赖 Graphical Device Interface .

逻辑很简单:

• 将窗口(以及在 z-order 中较高的每个可见窗口)表示为一个矩形。
• 从主矩形中减去每个矩形并存储结果。

如果最后的几何减法是:

• ... 一个空矩形 — return 'VisibilityFullyObscured'
• ...一组矩形 — return 'VisibilityPartiallyObscured'
• ... 单个矩形:
  • 如果结果和原始矩形之间的几何差异是:
    1. ... 一个空矩形 — return 'VisibilityUnobscured'
    2. ... 单个矩形 — return 'VisibilityPartiallyObscured'

一个简单的实现(带有自调度循环):

import ctypes
import ctypes.wintypes as wintypes
import tkinter as tk


class App(tk.Tk):
    ''' generic tk app with win api interaction '''
    enum_windows = ctypes.windll.user32.EnumWindows
    is_window_visible = ctypes.windll.user32.IsWindowVisible
    get_window_rect = ctypes.windll.user32.GetWindowRect
    create_rect_rgn = ctypes.windll.gdi32.CreateRectRgn
    combine_rgn = ctypes.windll.gdi32.CombineRgn
    del_rgn = ctypes.windll.gdi32.DeleteObject
    get_parent = ctypes.windll.user32.GetParent
    enum_windows_proc = ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM)

    def __init__(self):
        ''' generic __init__ '''
        super().__init__()
        self.minsize(350, 200)

        self.status_label = tk.Label(self)
        self.status_label.pack()

        self.after(100, self.continuous_check)
        self.state = ''

    def continuous_check(self):
        ''' continuous (self-scheduled) check '''
        state = self.determine_obscuration()

        if self.state != state:
            #   mimic the event - fire only when state changes
            print(state)
            self.status_label.config(text=state)
            self.state = state
        self.after(100, self.continuous_check)

    def enumerate_higher_windows(self, self_hwnd):
        ''' enumerate window, which has a higher position in z-order '''

        @self.enum_windows_proc
        def enum_func(hwnd, lParam):
            ''' clojure-callback for enumeration '''
            rect = wintypes.RECT()
            if hwnd == lParam:
                #   stop enumeration if hwnd is equal to lParam (self_hwnd)
                return False
            else:
                #   continue enumeration
                if self.is_window_visible(hwnd):
                    self.get_window_rect(hwnd, ctypes.byref(rect))
                    rgn = self.create_rect_rgn(rect.left, rect.top, rect.right, rect.bottom)
                    #   append region
                    rgns.append(rgn)
            return True

        rgns = []
        self.enum_windows(enum_func, self_hwnd)

        return rgns

    def determine_obscuration(self):
        ''' determine obscuration via CombineRgn '''
        hwnd = self.get_parent(self.winfo_id())
        results = {1: 'VisibilityFullyObscured', 2: 'VisibilityUnobscured', 3: 'VisibilityPartiallyObscured'}
        rgns = self.enumerate_higher_windows(hwnd)
        result = 2

        if len(rgns):
            rect = wintypes.RECT()
            self.get_window_rect(hwnd, ctypes.byref(rect))

            #   region of tk-window
            reference_rgn = self.create_rect_rgn(rect.left, rect.top, rect.right, rect.bottom)
            #   temp region for storing diff and xor rgn-results
            rgn = self.create_rect_rgn(0, 0, 0, 0)

            #   iterate over stored results
            for _ in range(len(rgns)):
                _rgn = rgn if _ != 0 else reference_rgn
                result = self.combine_rgn(rgn, _rgn, rgns[_], 4)
                self.del_rgn(rgns[_])

            if result != 2:
                #   if result isn't a single rectangle
                #   (NULLREGION - 'VisibilityFullyObscured' or COMPLEXREGION - 'VisibilityPartiallyObscured')
                pass
            elif self.combine_rgn(rgn, reference_rgn, rgn, 3) == 1:
                #   if result of XOR is NULLREGION - 'VisibilityUnobscured'
                result = 2
            else:
                #   'VisibilityPartiallyObscured'
                result = 3

            #   clear up regions to prevent memory leaking
            self.del_rgn(rgn)
            self.del_rgn(reference_rgn)

        return results[result]

app = App()
app.mainloop()

不幸的是，这种方法远非可行的解决方案，但从某种角度来看它是可以调整的。