获取创建的窗口的 hwnd 处理程序

Question

我正在尝试创建一个窗口，然后获取创建的窗口的 hwnd。

目前，我调用subprocess.run("run.exe")创建窗口，然后继续调用wg.GetForegroundWindow()获取前景窗口的hwnd，这应该是新创建的窗口。然而，这并不能很好地工作，因为程序必须在它被检测为前景之前完成打开，同时用户可以改变焦点。

有没有更一致的方式来获取hwnd？

编辑： 以下是我在下面的 cmets 的帮助下正在做的事情：

def create_window():
    user32 = ctypes.windll.user32
    ole32 = ctypes.windll.ole32

    EVENT_OBJECT_CREATE = 0x8000
    def callback(hWinEventHook, event, hwnd, idObject, idChild, dwEventThread, dwmsEventTime):
        if is_real_window(hwnd):
            print(get_text(hwnd), "HOOKED")
            user32.UnhookWinEvent(hWinEventHook)
            return hwnd

    WinEventProcType = ctypes.WINFUNCTYPE(
        None, 
        ctypes.wintypes.HANDLE,
        ctypes.wintypes.DWORD,
        ctypes.wintypes.HWND,
        ctypes.wintypes.LONG,
        ctypes.wintypes.LONG,
        ctypes.wintypes.DWORD,
        ctypes.wintypes.DWORD
    )

    WinEventProc = WinEventProcType(callback)

    user32.SetWinEventHook.restype = ctypes.wintypes.HANDLE
    hook = user32.SetWinEventHook(
        EVENT_OBJECT_CREATE,
        EVENT_OBJECT_CREATE,
        0,
        WinEventProc,
        0,
        0,
        0
    )
    if hook == 0:
        print('SetWinEventHook failed')
        sys.exit(1)

    msg = ctypes.wintypes.MSG()

    x = subprocess.Popen("C:\\cygwin64\\bin\\mintty.exe")

    m = user32.GetMessageW(ctypes.byref(msg), 0, 0, 0)

但是，这面临两个问题。首先，虽然我可以在回调函数中访问 hwnd，但似乎没有办法让 create_window 返回这个值。其次，GetMessage 窗口继续运行，即使在调用 UnhookWinEvent 之后也是如此。

我能做些什么来解决这些问题？

Answer 1

1. 分配回调中收到的hwnd 是一个范围问题。 回调函数是异步调用的，所以不可能返回值； 相反，您可以将值分配给另一个范围内的变量，例如到一个 全局变量：

   def callback((hWinEventHook, event, hwnd, ...):
       global HWND
       HWND = hwnd
       ....
   

2. 虽然GetMessage 似乎永远运行，但实际上它正在等待消息 发布到它的消息队列。 正如Microsoft Docs for the GetMessage function 中所述：

   从调用线程的消息队列中检索消息。该函数分派传入的已发送消息，直到发布的消息可供检索。

   在调用 GetMessage 之前记得存储线程 id，例如在全局变量中：

   def create_window(..):
       global THREAD_ID
       THREAD_ID = win32api.GetCurrentThreadId()
   
       ...
       m = user32.GetMessageW(ctypes.byref(msg), 0, 0, 0)
   

   所以任何发布到安装钩子的线程的消息都会使 GetMessage 停止“运行”并返回一个值：

   def callback(...):
       ...
       win32gui.PostThreadMessage(THREAD_ID, win32con.WM_QUIT, 0, 0)
       # also valid:
       # win32gui.PostThreadMessage(THREAD_ID, win32con.WM_MOVE, 0, 0)  
   

3. 为了脱钩，首先需要 GetMessage 循环退出。自然的 调用UnhookWinEvent 的地方在GetMessage 之后，所以当后者 退出，下一步将完成脱钩：

   def create_window(hWinEventHook, event, hwnd, ...):
       ...
       m = user32.GetMessage(ctypes.byref(msg), 0, 0, 0)
       user32.UnhookWinEvent( hWinEventHook )
       return HWND
   

4. 为了轻松地将回调中收到的hwnd 与它的可执行文件相匹配， 有一个有用的getProcessFileaname 函数，它返回完整路径 到可执行文件（感谢这个要点的作者 keturn/trackwindow.py)

   """
   Much credit to Eric Blade for this:
   https://mail.python.org/pipermail/python-win32/2009-July/009381.html
   and David Heffernan:
   http://stackoverflow.com/a/15898768/9585
   """
   import win32con
   import ctypes
   import ctypes.wintypes
   
   user32 = ctypes.windll.user32
   kernel32 = ctypes.windll.kernel32
   
   
   # limited information would be sufficient, but our platform doesn't have it.
   processFlag = getattr(win32con, 'PROCESS_QUERY_LIMITED_INFORMATION',
                         win32con.PROCESS_QUERY_INFORMATION)
   
   threadFlag = getattr(win32con, 'THREAD_QUERY_LIMITED_INFORMATION',
                        win32con.THREAD_QUERY_INFORMATION)
   
   
   def getProcessID(dwEventThread, hwnd):
       # It's possible to have a window we can get a PID out of when the thread
       # isn't accessible, but it's also possible to get called with no window,
       # so we have two approaches.
   
       hThread = kernel32.OpenThread(threadFlag, 0, dwEventThread)
   
       if hThread:
           try:
               processID = kernel32.GetProcessIdOfThread(hThread)
               if not processID:
                   print("Couldn't get process for thread %s: %s" %
                            (hThread, ctypes.WinError()))
           finally:
               kernel32.CloseHandle(hThread)
       else:
           errors = ["No thread handle for %s: %s" %
                     (dwEventThread, ctypes.WinError(),)]
   
           if hwnd:
               processID = ctypes.wintypes.DWORD()
               threadID = user32.GetWindowThreadProcessId(
                   hwnd, ctypes.byref(processID))
               if threadID != dwEventThread:
                   print("Window thread != event thread? %s != %s" %
                            (threadID, dwEventThread))
               if processID:
                   processID = processID.value
               else:
                   errors.append(
                       "GetWindowThreadProcessID(%s) didn't work either: %s" % (
                       hwnd, ctypes.WinError()))
                   processID = None
           else:
               processID = None
   
           if not processID:
               for err in errors:
                   print(err)
   
       return processID
   
   
   def getProcessFilename(processID):
       hProcess = kernel32.OpenProcess(processFlag, 0, processID)
       if not hProcess:
           print("OpenProcess(%s) failed: %s" % (processID, ctypes.WinError()))
           return None
   
       try:
           filenameBufferSize = ctypes.wintypes.DWORD(4096)
           filename = ctypes.create_unicode_buffer(filenameBufferSize.value)
           kernel32.QueryFullProcessImageNameW(hProcess, 0, ctypes.byref(filename),
                                               ctypes.byref(filenameBufferSize))
   
           return filename.value
       finally:
           kernel32.CloseHandle(hProcess)