pyxhook.py

#!/usr/bin/python
#
# pyxhook -- an extension to emulate some of the PyHook library on linux.
#
#    Copyright (C) 2008 Tim Alexander <dragonfyre13@gmail.com>
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#    Thanks to Alex Badea <vamposdecampos@gmail.com> for writing the Record
#    demo for the xlib libraries. It helped me immensely working with these
#    in this library.
#
#    Thanks to the python-xlib team. This wouldn't have been possible without
#    your code.
#
#    This requires:
#    at least python-xlib 1.4
#    xwindows must have the "record" extension present, and active.
#
#    This file has now been somewhat extensively modified by
#    Daniel Folkinshteyn <nanotube@users.sf.net>
#    So if there are any bugs, they are probably my fault. :)
from __future__ import print_function

import sys
import re
import time
import threading

from Xlib import X, XK, display
from Xlib.ext import record
from Xlib.protocol import rq


#######################################################################
# #######################START CLASS DEF###############################
#######################################################################

class HookManager(threading.Thread):
    """ This is the main class. Instantiate it, and you can hand it KeyDown
        and KeyUp (functions in your own code) which execute to parse the
        pyxhookkeyevent class that is returned.

        This simply takes these two values for now:
        KeyDown : The function to execute when a key is pressed, if it
                  returns anything. It hands the function an argument that
                  is the pyxhookkeyevent class.
        KeyUp   : The function to execute when a key is released, if it
                  returns anything. It hands the function an argument that is
                  the pyxhookkeyevent class.
    """

    def __init__(self, parameters=False):
        threading.Thread.__init__(self)
        self.ctx = None
        self.finished = threading.Event()

        # Give these some initial values
        self.mouse_position_x = 0
        self.mouse_position_y = 0
        self.ison = {"shift": False, "caps": False}

        # Compile our regex statements.
        self.isshift = re.compile('^Shift')
        self.iscaps = re.compile('^Caps_Lock')
        self.shiftablechar = re.compile('|'.join((
            '^[a-z0-9]$',
            '^minus$',
            '^equal$',
            '^bracketleft$',
            '^bracketright$',
            '^semicolon$',
            '^backslash$',
            '^apostrophe$',
            '^comma$',
            '^period$',
            '^slash$',
            '^grave$'
        )))
        self.logrelease = re.compile('.*')
        self.isspace = re.compile('^space$')
        self.lookuptable = self.create_lookup_dict()
        # Choose which type of function use
        self.parameters = parameters
        if parameters:
            self.lambda_function = lambda x, y: True
        else:
            self.lambda_function = lambda x: True
        # Assign default function actions (do nothing).
        self.KeyDown = self.lambda_function
        self.KeyUp = self.lambda_function
        self.MouseAllButtonsDown = self.lambda_function
        self.MouseAllButtonsUp = self.lambda_function
        self.MouseMovement = self.lambda_function
        self.KeyDownParameters = {}
        self.KeyUpParameters = {}
        self.MouseAllButtonsDownParameters = {}
        self.MouseAllButtonsUpParameters = {}
        self.MouseMovementParameters = {}
        self.contextEventMask = [X.KeyPress, X.MotionNotify]
        # Hook to our display.
        self.local_dpy = display.Display()
        self.record_dpy = display.Display()

    def create_lookup_dict(self):
        return {getattr(XK, name): name[3:] \
            for name in dir(XK) \
            if name.startswith("XK_")}

    def run(self):
        # Check if the extension is present
        if not self.record_dpy.has_extension("RECORD"):
            print("RECORD extension not found", file=sys.stderr)
            sys.exit(1)
        # r = self.record_dpy.record_get_version(0, 0)
        # print("RECORD extension version {major}.{minor}".format(
        #     major=r.major_version,
        #     minor=r.minor_version
        # ))

        # Create a recording context; we only want key and mouse events
        self.ctx = self.record_dpy.record_create_context(
            0,
            [record.AllClients],
            [{
                'core_requests': (0, 0),
                'core_replies': (0, 0),
                'ext_requests': (0, 0, 0, 0),
                'ext_replies': (0, 0, 0, 0),
                'delivered_events': (0, 0),
                #                (X.KeyPress, X.ButtonPress),
                'device_events': tuple(self.contextEventMask),
                'errors': (0, 0),
                'client_started': False,
                'client_died': False,
            }])

        # Enable the context; this only returns after a call to
        # record_disable_context, while calling the callback function in the
        # meantime
        self.record_dpy.record_enable_context(self.ctx, self.process_events)
        # Finally free the context
        self.record_dpy.record_free_context(self.ctx)

    def cancel(self):
        self.finished.set()
        self.local_dpy.record_disable_context(self.ctx)
        self.local_dpy.flush()

    def process_hook_events(self, action_type, action_parameters, events):
        # In order to avoid duplicate code, i wrote a function that takes the
        # input value of the action function and, depending on the initialization,
        # launches it or only with the event or passes the parameter
        if self.parameters:
            action_type(events, action_parameters)
        else:
            action_type(events)

    def process_events(self, reply):
        if reply.category != record.FromServer:
            return
        if reply.client_swapped:
            print("* received swapped protocol data, cowardly ignored")
            return
        try:
            # Get int value, python2.
            interval = ord(reply.data[0])
        except TypeError:
            # Already bytes/ints, python3.
            interval = reply.data[0]
        if (not reply.data) or (interval < 2):
            # not an event
            return
        data = reply.data
        while len(data):
            event, data = rq.EventField(None).parse_binary_value(
                data,
                self.record_dpy.display,
                None,
                None
            )
            if event.type == X.KeyPress:
                hook_event = self.keypressevent(event)
                self.process_hook_events(self.KeyDown, self.KeyDownParameters, hook_event)
            elif event.type == X.KeyRelease:
                hook_event = self.key_release_event(event)
                self.process_hook_events(self.KeyUp, self.KeyUpParameters, hook_event)
            elif event.type == X.ButtonPress:
                hook_event = self.button_press_event(event)
                self.process_hook_events(self.MouseAllButtonsDown, self.MouseAllButtonsDownParameters, hook_event)
            elif event.type == X.ButtonRelease:
                hook_event = self.button_release_event(event)
                self.process_hook_events(self.MouseAllButtonsUp, self.MouseAllButtonsUpParameters, hook_event)
            elif event.type == X.MotionNotify:
                # use mouse moves to record mouse position, since press and
                # release events do not give mouse position info
                # (event.root_x and event.root_y have bogus info).
                hook_event = self.mouse_move_event(event)
                self.process_hook_events(self.MouseMovement, self.MouseMovementParameters, hook_event)

        # print("processing events...", event.type)

    def keypressevent(self, event):
        matchto = self.lookup_keysym(
            self.local_dpy.keycode_to_keysym(event.detail, 0)
        )
        if self.shiftablechar.match(
                self.lookup_keysym(
                    self.local_dpy.keycode_to_keysym(event.detail, 0))):
            # This is a character that can be typed.
            if not self.ison["shift"]:
                keysym = self.local_dpy.keycode_to_keysym(event.detail, 0)
                return self.makekeyhookevent(keysym, event)
            else:
                keysym = self.local_dpy.keycode_to_keysym(event.detail, 1)
                return self.makekeyhookevent(keysym, event)
        else:
            # Not a typable character.
            keysym = self.local_dpy.keycode_to_keysym(event.detail, 0)
            if self.isshift.match(matchto):
                self.ison["shift"] = self.ison["shift"] + 1
            elif self.iscaps.match(matchto):
                if not self.ison["caps"]:
                    self.ison["shift"] = self.ison["shift"] + 1
                    self.ison["caps"] = True
                if self.ison["caps"]:
                    self.ison["shift"] = self.ison["shift"] - 1
                    self.ison["caps"] = False
            return self.makekeyhookevent(keysym, event)

    def key_release_event(self, event):
        if self.shiftablechar.match(
                self.lookup_keysym(
                    self.local_dpy.keycode_to_keysym(event.detail, 0))):
            if not self.ison["shift"]:
                keysym = self.local_dpy.keycode_to_keysym(event.detail, 0)
            else:
                keysym = self.local_dpy.keycode_to_keysym(event.detail, 1)
        else:
            keysym = self.local_dpy.keycode_to_keysym(event.detail, 0)
        matchto = self.lookup_keysym(keysym)
        if self.isshift.match(matchto):
            self.ison["shift"] = self.ison["shift"] - 1
        return self.makekeyhookevent(keysym, event)

    def button_press_event(self, event):
        # self.clickx = self.rootx
        # self.clicky = self.rooty
        return self.makemousehookevent(event)

    def button_release_event(self, event):
        # if (self.clickx == self.rootx) and (self.clicky == self.rooty):
        #     # print("ButtonClock {detail} x={s.rootx y={s.rooty}}".format(
        #     #    detail=event.detail,
        #     #    s=self,
        #     # ))
        #     if event.detail in (1, 2, 3):
        #         self.captureclick()
        # else:
        #     pass
        #     print("ButtonDown {detail} x={s.clickx} y={s.clicky}".format(
        #         detail=event.detail,
        #         s=self
        #     ))
        #     print("ButtonUp {detail} x={s.rootx} y={s.rooty}".format(
        #         detail=event.detail,
        #         s=self
        #     ))
        return self.makemousehookevent(event)

    def mouse_move_event(self, event):
        self.mouse_position_x = event.root_x
        self.mouse_position_y = event.root_y
        return self.makemousehookevent(event)

    # need the following because XK.keysym_to_string() only does printable
    # chars rather than being the correct inverse of XK.string_to_keysym()
    def lookup_keysym(self, keysym):
        return self.lookuptable[keysym] \
            if keysym in self.lookuptable \
            else "[{}]".format(keysym)

    def asciivalue(self, keysym):
        number = XK.string_to_keysym(self.lookup_keysym(keysym))
        return number if number < 256 else 0

    def makekeyhookevent(self, keysym, event):
        storewm = self.xwindowinfo()
        if event.type == X.KeyPress:
            MessageName = "key down"
        elif event.type == X.KeyRelease:
            MessageName = "key up"
        return pyxhookkeyevent(
            storewm["handle"],
            storewm["name"],
            storewm["class"],
            self.lookup_keysym(keysym),
            self.asciivalue(keysym),
            False,
            event.detail,
            MessageName
        )

    def makemousehookevent(self, event):
        storewm = self.x_window_on_pointer()
        if event.detail == 1:
            MessageName = "mouse left "
        elif event.detail == 3:
            MessageName = "mouse right "
        elif event.detail == 2:
            MessageName = "mouse middle "
        elif event.detail == 5:
            MessageName = "mouse wheel down "
        elif event.detail == 4:
            MessageName = "mouse wheel up "
        else:
            MessageName = "mouse {} ".format(event.detail)

        if event.type == X.ButtonPress:
            MessageName = "{} down".format(MessageName)
        elif event.type == X.ButtonRelease:
            MessageName = "{} up".format(MessageName)
        else:
            MessageName = "mouse moved"
        return pyxhookmouseevent(
            storewm["id"],
            storewm["name"],
            storewm["class"],
            (self.mouse_position_x, self.mouse_position_y),
            MessageName,
            event.detail
        )

    def x_find_window(self, window, root, direction):
        """
        direction:  true search parent  |  false search children
            in first call , should be True
        """
        if window == root:
            return window
        tree = window.query_tree()
        if direction:
            w = tree.parent
            if w == root:
                # if root , search in children
                return self.x_find_window(window, root, False)
            if w.get_wm_state():
                return w
        else:
            for ch in tree.children:
                if ch.get_wm_state():
                    return ch
                return self.x_find_window(ch, root, False)

    def x_window_on_pointer(self):
        for screen_index in range(self.local_dpy.screen_count()):
            screen = self.local_dpy.screen(screen_index)
            window = self.x_find_window(screen.root.query_pointer().child, screen.root, True)
            if not window:
                window = screen.root
            wm_name = window.get_wm_name()
            wm_class = window.get_wm_class()
            wm_id = window.id
            return {"name": wm_name, "class": wm_class, "id": wm_id}

    def xwindowinfo(self):
        try:
            # ss = window.get_wm_name()
            # ss = window.get_wm_class()
            # print(f"鼠标所在id:{window.id}   class:, {ss}")
            windowvar = self.local_dpy.get_input_focus().focus
            wmname = windowvar.get_wm_name()
            wmclass = windowvar.get_wm_class()
            wm_id = windowvar.id
        except BaseException as e:
            print(e)
            # This is to keep things running smoothly.
            # It almost never happens, but still...
            return {"name": None, "class": None, "id": None}
        if (wmname is None) and (wmclass is None):
            try:
                windowvar = windowvar.query_tree().parent
                wmname = windowvar.get_wm_name()
                wmclass = windowvar.get_wm_class()
                wm_id = windowvar.id
            except:
                # This is to keep things running smoothly.
                # It almost never happens, but still...
                return {"name": None, "class": None, "id": None}
        if wmclass is None:
            return {"name": wmname, "class": wmclass, "id": wm_id}
        else:
            return {"name": wmname, "class": wmclass[0], "id": wm_id}


class pyxhookkeyevent:
    """ This is the class that is returned with each key event.f
        It simply creates the variables below in the class.

        Window         : The handle of the window.
        WindowName     : The name of the window.
        WindowProcName : The backend process for the window.
        Key            : The key pressed, shifted to the correct caps value.
        Ascii          : An ascii representation of the key. It returns 0 if
                         the ascii value is not between 31 and 256.
        KeyID          : This is just False for now. Under windows, it is the
                         Virtual Key Code, but that's a windows-only thing.
        ScanCode       : Please don't use this. It differs for pretty much
                         every type of keyboard. X11 abstracts this
                         information anyway.
        MessageName    : "key down", "key up".
    """

    def __init__(
            self, Window, WindowName, WindowProcName, Key, Ascii, KeyID,
            ScanCode, MessageName):
        self.Window = Window
        self.WindowName = WindowName
        self.WindowProcName = WindowProcName
        self.Key = Key
        self.Ascii = Ascii
        self.KeyID = KeyID
        self.ScanCode = ScanCode
        self.MessageName = MessageName

    def __str__(self):
        return '\n'.join((
            'Window Handle: {s.Window}',
            'Window Name: {s.WindowName}',
            'Window\'s Process Name: {s.WindowProcName}',
            'Key Pressed: {s.Key}',
            'Ascii Value: {s.Ascii}',
            'KeyID: {s.KeyID}',
            'ScanCode: {s.ScanCode}',
            'MessageName: {s.MessageName}',
        )).format(s=self)


class pyxhookmouseevent:
    """This is the class that is returned with each key event.f
    It simply creates the variables below in the class.

        Window         : The handle of the window.
        WindowName     : The name of the window.
        WindowProcName : The backend process for the window.
        Position       : 2-tuple (x,y) coordinates of the mouse click.
        MessageName    : "mouse left|right|middle down",
                         "mouse left|right|middle up".

        Button         : look up event.detail
    """

    def __init__(
            self, WindowId, WindowName, WindowProcName, Position, MessageName, Button):
        self.Window = WindowId
        self.WindowName = WindowName
        self.WindowProcName = WindowProcName
        self.Position = Position
        self.MessageName = MessageName
        self.Button = Button

    def __str__(self):
        return '\n'.join((
            'Window: {s.Window}',
            'Window\'s Process Name: {s.WindowProcName}',
            'Window: {s.WindowName}',
            'Position: {s.Position}',
            'MessageName: {s.MessageName}',
        )).format(s=self)


#######################################################################
# ########################END CLASS DEF################################
#######################################################################

if __name__ == '__main__':
    hm = HookManager()
    hm.start()
    time.sleep(10)
    hm.cancel()