使用wxPython为单独的程序提供右键单击上下文菜单

Question

I was having trouble formatting the title of this question, because I wasn't sure I'm going about this the right way, so let me explain.

I want to try and add a right-click context menu to an existing program for which I don't have the source code. wxPython is generally my framework of choice. I figured there was a couple ways of doing this:

1) Create a transparent wx.Frame which is tied to and sits on top of the existing program, intercepting mouse events. If I did this, I wasn't sure if the mouse events could then be passed to the underlying window. I like this option, because it would allow adding more useful information in the overlay.

2) Create a headless program which globally intercepts right-click events, and spawns the context menu at the pointer location when certain conditions are met. Based on the research I've done so far, this didn't seem possible without continuously polling for mouse position.

What am I missing? Is there a more elegant solution for this? Is this even possible using Python?

edit: I have a partial proof-of-concept working which looks like this:

import wx
import win32gui
import win32api
import win32con

class POC_Frame(wx.Frame):

    def __init__(self, parent):
        wx.Frame.__init__(self, parent, id=wx.ID_ANY, title='POC', pos=(0,0), size=wx.Size(500, 500), style=wx.DEFAULT_FRAME_STYLE)
        self.ToggleWindowStyle(wx.STAY_ON_TOP)

        extendedStyleSettings = win32gui.GetWindowLong(self.GetHandle(), win32con.GWL_EXSTYLE)
        win32gui.SetWindowLong(self.GetHandle(), win32con.GWL_EXSTYLE,
                               extendedStyleSettings | win32con.WS_EX_LAYERED | win32con.WS_EX_TRANSPARENT)
        win32gui.SetLayeredWindowAttributes(self.GetHandle(), win32api.RGB(0,0,0), 100, win32con.LWA_ALPHA)

        self.Bind(wx.EVT_RIGHT_DOWN, self.onRightDown)
        self.Bind(wx.EVT_RIGHT_UP, self.onRightUp)

        self.CaptureMouse()

    def onRightDown(self, event):
        print(event)

    def onRightUp(self, event):
        print(event)

app = wx.App(False)
MainFrame = POC_Frame(None)
MainFrame.Show()
app.MainLoop()

This seems to work OK, as it passes the right click events to the underlying window, while still recognizing them, but it only does it exactly once. As soon as it loses focus, it stops working and nothing I've tried to return focus to it seems to work.

Answer 1

I've always had better luck hooking global mouse and keyboard events with pyHook rather than wx. Here is a simple example:

import pyHook
import pyHook.cpyHook  # ensure its included by cx-freeze


class ClickCatcher:
    def __init__(self):

        self.hm = None

        self._is_running = True
        self._is_cleaned_up = False
        self._is_quitting = False

        self.set_hooks()

    # this is only necessary when not using wx
    # def send_quit_message(self):
    #     import ctypes
    #     win32con_WM_QUIT = 18
    #     ctypes.windll.user32.PostThreadMessageW(self.pump_message_thread.ident, win32con_WM_QUIT, 0, 0)

    def __del__(self):
        self.quit()

    def quit(self):
        if not self._is_running:
            return
        self._is_quitting = True
        self._is_running = False
        if self.hm:
            # self.hm.UnhookKeyboard()
            self.hm.UnhookMouse()
        # self.send_quit_message()
        self._is_cleaned_up = True

    def set_hooks(self):
        self._is_running = True
        self._is_cleaned_up = False
        self.hm = pyHook.HookManager()
        self.hm.MouseRightUp = self.on_right_click
        # self.hm.HookKeyboard()
        self.hm.HookMouse()


    def on_right_click(self):
        # create your menu here
        pass

If you weren't using wx , you'd have to use pythoncom.PumpMessages to push mouse and keyboard events to you program, but App.Mainloop() accomplishes the same thing (if you use PumpMessages and Mainloop together about half of the events won't be push to your program).

Creating a wx.Menu is easy enough. You can find the mouse coordinates using wx.GetMousePosition()