Never getting past PumpMessages

Question

I'm writing a script that interacts through a program's WM_COPYDATA api, but am stuck on the PumpMessage functionality.

import win32con, win32api, win32gui
import ctypes, ctypes.wintypes

FindWindow = ctypes.windll.user32.FindWindowW
SendMessage = ctypes.windll.user32.SendMessageW

class COPYDATASTRUCT(ctypes.Structure):
    _fields_ = [
        ('dwData', ctypes.wintypes.LPARAM),
        ('cbData', ctypes.wintypes.DWORD),
        ('lpData', ctypes.c_char_p)
        #formally lpData is c_void_p, but we do it this way for convenience
]

PCOPYDATASTRUCT = ctypes.POINTER(COPYDATASTRUCT)

class Stickies:

    def __init__(self):
        message_map = {
            win32con.WM_COPYDATA: self.OnCopyData
        }
        wc = win32gui.WNDCLASS()
        wc.lpfnWndProc = message_map
        wc.lpszClassName = 'MyWindowClass'
        hinst = wc.hInstance = win32api.GetModuleHandle(None)
        classAtom = win32gui.RegisterClass(wc)
        self.hwnd = win32gui.CreateWindow (
            classAtom,
            "win32gui test",
            0,
            0, 
            0,
            win32con.CW_USEDEFAULT, 
            win32con.CW_USEDEFAULT,
            0, 
            0,
            hinst, 
            None
        )
        self.send_message("api do register")

    def __enter__(self):
        return self

    def __exit__(self):
        self.send_message("api do deregister")

    def send_message(self, msg):
        hwnd = FindWindow(None, "ZhornSoftwareStickiesMain")
        cds = COPYDATASTRUCT()
        cds.dwData = 0
        str = msg.encode("ascii")
        cds.cbData = ctypes.sizeof(ctypes.create_string_buffer(str))
        cds.lpData = ctypes.c_char_p(str)
        SendMessage(hwnd, win32con.WM_COPYDATA, self.hwnd, ctypes.byref(cds))

    def OnCopyData(self, hwnd, msg, wparam, lparam):
        pCDS = ctypes.cast(lparam, PCOPYDATASTRUCT)
        msg = pCDS.contents.lpData.decode("ascii", "ignore")

        if msg != None:
            print(msg)

        return 1

s = Stickies()
win32gui.PumpMessages()

# Never gets past previous line
print("Hello, world!")

In my code, I can successfully send and receive messages, but I'm not sure as to how I can allow my scripts to do other things. My goal is use this as a base class, and then incorporate it into other scripts.

I'm not sure how to:

1. get past the pumpmessage() function
2. handle the messages outside of the class.

Any help would be greatly appreciated.

Answer 1

SendMessage is synchronous. Send WM_COPYDATA to the other application and your code will wait in a Windows-internal message loop until you get a reply.

This means that your code can respond to messages from the other application while it is waiting. This might be needed if the protocol involves an exchange of messages.

You only need a message loop if you are responding to unsolicited messages.

I don't know exactly what you are doing, but most likely you can remove the call to win32gui.PumpMessages altogether.

Answer 2

PumpMessages freezes the current thread. If you want to do something after PumpMessages, consider making a new thread and running that using the threading module:

import threading
import win32gui

def otherCodeToRun(x, y, z):
    print("Hello World!")

t = threading.Thread(target=otherCodeToRun, args=(x, y, z, )) // You can leave out args if you don't have any parameters.
t.start()

win32gui.PumpMessages()