Ticket #173: xi-events-v4.patch

xpra/log.py

@@ -264 +264 @@
                 ])),
     ("X11", OrderedDict([
                 ("x11"          , "All X11 code"),
+                ("xinput"       , "XInput bindings"),
                 ("bindings"     , "X11 Cython bindings"),
                 ("core"         , "X11 core bindings"),
                 ("randr"        , "X11 RandR bindings"),

xpra/platform/features.py

@@ -15 +15 @@
 SYSTEM_TRAY_SUPPORTED = False
 REINIT_WINDOWS = False
 
+INPUT_DEVICES = ["auto"]
+
 CLIPBOARDS = []
 CLIPBOARD_WANT_TARGETS = envbool("XPRA_CLIPBOARD_WANT_TARGETS")
 CLIPBOARD_GREEDY = envbool("XPRA_CLIPBOARD_GREEDY")
@@ -62 +64 @@
                    "CLIPBOARD_NATIVE_CLASS",
                    "UI_THREAD_POLLING",
                    "CLIENT_MODULES",
+                   "INPUT_DEVICES",
                    ]
 from xpra.platform import platform_import
 platform_import(globals(), "features", False,

xpra/platform/xposix/features.py

@@ -21 +21 @@
 
 DEFAULT_SSH_CMD = "ssh"
 CLIPBOARDS=["CLIPBOARD", "PRIMARY", "SECONDARY"]
+
+INPUT_DEVICES = ["auto", "xi"]

xpra/platform/xposix/gui.py

@@ -499 +499 @@
     _toggle_wm_state(window, "_NET_WM_STATE_SHADED", shaded)
 
 
+
+WINDOW_ENHANCERS = []
+def add_window_hooks(window):
+    global WINDOW_ENHANCERS
+    for x in WINDOW_ENHANCERS:
+        x(window)
+    log.warn("add_window_hooks(%s) added %s", window, WINDOW_ENHANCERS)
+
+
 def get_info():
     from xpra.platform.gui import get_info_base
     i = get_info_base()
@@ -516 +525 @@
     return i
 
 
+class XI2_Window(object):
+    def __init__(self, xi2, window):
+        log.warn("XI2_Window(%s, %s)", xi2, window)
+        self.xi2 = xi2
+        self.window = window
+        window.do_motion_notify_event = self.do_motion_notify_event
+
+    def do_motion_notify_event(self, event):
+        log("do_motion_notify_event(%s)", event)
+        #find the motion events in the xi2 event list:
+        events = self.xi2.find_events("XI_Motion")
+        log.warn("events=%s", events)
+        self.xi2.reset_events()
+
+
+
 class ClientExtras(object):
     def __init__(self, client, opts):
         self.client = client
@@ -528 +553 @@
         self.x11_filter = None
         if client.xsettings_enabled:
             self.setup_xprops()
+        if client.input_devices=="xi":
+            self.setup_xi()
         self.setup_dbus_signals()
 
     def ready(self):
@@ -565 +592 @@
                 bus._clean_up_signal_match(self.upower_sleeping_match)
             if self.login1_match:
                 bus._clean_up_signal_match(self.login1_match)
+        global WINDOW_METHOD_OVERRIDES
+        WINDOW_METHOD_OVERRIDES = {}
 
     def resuming_callback(self, *args):
         eventlog("resuming_callback%s", args)
@@ -647 +676 @@
         except ImportError as e:
             log.error("failed to load X11 properties/settings bindings: %s - root window properties will not be propagated", e)
 
+    def setup_xi(self):
+        from xpra.gtk_common.error import xsync
+        def enable_xi2():
+            try:
+                with xsync:
+                    self.init_x11_filter()
+                    xi2.select_xi2_events()
+            except Exception as e:
+                log("enable_xi2()", exc_info=True)
+                log.error("Error: cannot enable XI2 events")
+                log.error(" %s", e)
+            else:
+                #register our enhanced event handlers:
+                self.add_xi2_method_overrides(xi2)
+        with xsync:
+            try:
+                from xpra.x11.bindings.xi2_bindings import X11XI2Bindings   #@UnresolvedImport
+                xi2 = X11XI2Bindings()
+                xi2.gdk_inject()
+                #this would trigger warnings with our temporary opengl windows:
+                #only enable it after we have connected:
+                self.client.after_handshake(enable_xi2)
+            except Exception as e:
+                log("setup_xi()", exc_info=True)
+                log.error("Error: failed to load the XI2 bindings")
+                log.error(" %s", e)
+
+    def add_xi2_method_overrides(self, xi2):
+        global WINDOW_ENHANCERS
+        def add_xi2_to_window(window):
+            XI2_Window(xi2, window)
+        WINDOW_ENHANCERS = [add_xi2_to_window]
+
+
     def _get_xsettings(self):
         try:
             return self._xsettings_watcher.get_settings()

xpra/scripts/config.py

@@ -489 +489 @@
                     "dbus-launch"       : str,
                     "webcam"            : str,
                     "mousewheel"        : str,
+                    "input-devices"     : str,
                     #ssl options:
                     "ssl"               : str,
                     "ssl-key"           : str,
@@ -619 +620 @@
                   "quality", "min-quality", "speed", "min-speed",
                   "compression_level",
                   "dpi", "video-scaling", "auto-refresh-delay",
-                  "webcam", "mousewheel", "pings",
+                  "webcam", "mousewheel", "input-devices", "pings",
                   "tray", "keyboard-sync", "cursors", "bell", "notifications",
                   "xsettings", "system-tray", "sharing",
                   "delay-tray", "windows", "readonly",
@@ -811 +812 @@
                     "dbus-launch"       : "dbus-launch --close-stderr",
                     "webcam"            : ["auto", "no"][OSX],
                     "mousewheel"        : "on",
+                    "input-devices"     : "auto",
                     #ssl options:
                     "ssl"               : "auto",
                     "ssl-key"           : "",

xpra/scripts/main.py

@@ -562 +562 @@
     group.add_option("--mousewheel", action="store",
                       dest="mousewheel", default=defaults.mousewheel,
                       help="Mouse wheel forwarding, can be used to disable the device or invert some axes. Default: %s." % defaults.webcam)
+    from xpra.platform.features import INPUT_DEVICES
+    if len(INPUT_DEVICES)>1:
+        group.add_option("--input-devices", action="store", metavar="APINAME",
+                          dest="input_devices", default=defaults.input_devices,
+                          help="Which API to use for input devices. Default: %s." % defaults.input_devices)
+    else:
+        ignore({"input-devices" : INPUT_DEVICES[0]})
     legacy_bool_parse("global-menus")
     group.add_option("--global-menus", action="store",
                       dest="global_menus", default=defaults.global_menus, metavar="yes|no",

xpra/x11/bindings/core_bindings.pyx

@@ -33 +33 @@
     ctypedef int Bool
 
     Atom XInternAtom(Display * display, char * atom_name, Bool only_if_exists)
+    char *XGetAtomName(Display *display, Atom atom)
 
     int XFree(void * data)
 
@@ -83 +84 @@
     def get_xatom(self, str_or_int):
         return self.xatom(str_or_int)
 
+    def XGetAtomName(self, Atom atom):
+        v = XGetAtomName(self.display, atom)
+        return v[:]
+
+
     def get_error_text(self, code):
         assert self.display!=NULL, "display is closed"
         if type(code)!=int:

xpra/x11/bindings/window_bindings.pyx

@@ -81 +81 @@
         pass
 
     Atom XInternAtom(Display * display, char * atom_name, Bool only_if_exists)
-    char *XGetAtomName(Display *display, Atom atom)
 
     Window XDefaultRootWindow(Display * display)
 
@@ -461 +460 @@
         return XDefaultRootWindow(self.display)
 
 
-    cpdef XGetAtomName(self, Atom atom):
-        v = XGetAtomName(self.display, atom)
-        return v[:]
-
     def MapWindow(self, Window xwindow):
         XMapWindow(self.display, xwindow)
 

xpra/x11/bindings/xi2_bindings.pyx

@@ +1 @@
+# This file is part of Xpra.
+# Copyright (C) 2017 Antoine Martin <antoine@devloop.org.uk>
+# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
+# later version. See the file COPYING for details.
+
+import os
+import time
+import collections
+
+from xpra.log import Logger
+log = Logger("x11", "bindings", "xinput")
+
+from xpra.x11.gtk2.common import X11Event
+
+from libc.stdint cimport uintptr_t
+
+
+###################################
+# Headers, python magic
+###################################
+cdef extern from "string.h":
+    void* memset(void * ptr, int value, size_t num)
+
+cdef extern from "X11/Xutil.h":
+    pass
+
+######
+# Xlib primitives and constants
+######
+
+include "constants.pxi"
+ctypedef unsigned long CARD32
+
+cdef extern from "X11/Xlib.h":
+    ctypedef struct Display:
+        pass
+
+    ctypedef CARD32 XID
+    ctypedef int Bool
+    ctypedef int Status
+    ctypedef CARD32 Atom
+    ctypedef XID Window
+    ctypedef CARD32 Time
+
+    ctypedef struct XGenericEventCookie:
+        int            type     # of event. Always GenericEvent
+        unsigned long  serial
+        Bool           send_event
+        Display        *display
+        int            extension    #major opcode of extension that caused the event
+        int            evtype       #actual event type
+        unsigned int   cookie
+        void           *data
+
+    Atom XInternAtom(Display * display, char * atom_name, Bool only_if_exists)
+    int XFree(void * data)
+
+    Bool XQueryExtension(Display * display, char *name,
+                         int *major_opcode_return, int *first_event_return, int *first_error_return)
+
+    Bool XGetEventData(Display *display, XGenericEventCookie *cookie)
+    void XFreeEventData(Display *display, XGenericEventCookie *cookie)
+
+    Window XDefaultRootWindow(Display * display)
+
+    Bool XQueryPointer(Display *display, Window w, Window *root_return, Window *child_return, int *root_x_return, int *root_y_return,
+                       int *win_x_return, int *win_y_return, unsigned int *mask_return)
+    int XFlush(Display *dpy)
+
+cdef extern from "X11/extensions/XInput2.h":
+    int XI_LASTEVENT
+    int XI_DeviceChanged
+    int XI_KeyPress
+    int XI_KeyRelease
+    int XI_ButtonPress
+    int XI_ButtonRelease
+    int XI_Motion
+    int XI_Enter
+    int XI_Leave
+    int XI_FocusIn
+    int XI_FocusOut
+    int XI_HierarchyChanged
+    int XI_PropertyEvent
+    int XI_RawKeyPress
+    int XI_RawKeyRelease
+    int XI_RawButtonPress
+    int XI_RawButtonRelease
+    int XI_RawMotion
+    int XI_TouchBegin
+    int XI_TouchUpdate
+    int XI_TouchEnd
+    int XI_TouchOwnership
+    int XI_RawTouchBegin
+    int XI_RawTouchUpdate
+    int XI_RawTouchEnd
+
+    int XIMasterPointer
+    int XIMasterKeyboard
+    int XISlavePointer
+    int XISlaveKeyboard
+    int XIFloatingSlave
+
+    int XIButtonClass
+    int XIKeyClass
+    int XIValuatorClass
+    int XIScrollClass
+    int XITouchClass   
+
+    int XIAllDevices
+    int XIAllMasterDevices
+
+    ctypedef struct XIValuatorState:
+        int           mask_len
+        unsigned char *mask
+        double        *values
+
+    ctypedef struct XIEvent:
+        int           type
+        unsigned long serial
+        Bool          send_event
+        Display       *display
+        int           extension
+        int           evtype
+        Time          time
+
+    ctypedef struct XIRawEvent:
+        int           type      #GenericEvent
+        unsigned long serial
+        Bool          send_event
+        Display       *display
+        int           extension #XI extension offset
+        int           evtype    #XI_RawKeyPress, XI_RawKeyRelease, etc
+        Time          time
+        int           deviceid
+        int           sourceid
+        int           detail
+        int           flags
+        XIValuatorState valuators
+        double        *raw_values
+
+    ctypedef struct XIButtonState:
+        int           mask_len
+        unsigned char *mask
+
+    ctypedef struct XIModifierState:
+        int    base
+        int    latched
+        int    locked
+        int    effective
+
+    ctypedef XIModifierState XIGroupState
+
+    ctypedef struct XIDeviceEvent:
+        int           type
+        unsigned long serial
+        Bool          send_event
+        Display       *display
+        int           extension
+        int           evtype
+        Time          time
+        int           deviceid
+        int           sourceid
+        int           detail
+        Window        root
+        Window        event
+        Window        child
+        double        root_x
+        double        root_y
+        double        event_x
+        double        event_y
+        int           flags
+        XIButtonState       buttons
+        XIValuatorState     valuators
+        XIModifierState     mods
+        XIGroupState        group
+
+    ctypedef struct XIHierarchyInfo:
+        int           deviceid
+        int           attachment
+        int           use
+        Bool          enabled
+        int           flags
+
+    ctypedef struct XIHierarchyEvent:
+        int           type
+        unsigned long serial
+        Bool          send_event
+        Display       *display
+        int           extension
+        int           evtype            #XI_HierarchyChanged
+        Time          time
+        int           flags
+        int           num_info
+        XIHierarchyInfo *info
+
+    ctypedef struct XIEventMask:
+        int                 deviceid
+        int                 mask_len
+        unsigned char*      mask
+
+    ctypedef struct XIAnyClassInfo:
+        int         type
+        int         sourceid
+
+    ctypedef struct XIDeviceInfo:
+        int                 deviceid
+        char                *name
+        int                 use
+        int                 attachment
+        Bool                enabled
+        int                 num_classes
+        XIAnyClassInfo      **classes
+
+    ctypedef struct XIButtonClassInfo:
+        int         type
+        int         sourceid
+        int         num_buttons
+        Atom        *labels
+        XIButtonState state
+
+    ctypedef struct XIKeyClassInfo:
+        int         type
+        int         sourceid
+        int         num_keycodes
+        int         *keycodes
+
+    ctypedef struct XIValuatorClassInfo:
+        int         type
+        int         sourceid
+        int         number
+        Atom        label
+        double      min
+        double      max
+        double      value
+        int         resolution
+        int         mode
+
+    ctypedef struct XIScrollClassInfo:
+        int         type
+        int         sourceid
+        int         number
+        int         scroll_type
+        double      increment
+        int         flags
+
+    ctypedef struct XITouchClassInfo:
+        int         type
+        int         sourceid
+        int         mode
+        int         num_touches
+
+    Status XIQueryVersion(Display *display, int *major_version_inout, int *minor_version_inout)
+    Status XISelectEvents(Display *display, Window win, XIEventMask *masks, int num_masks)
+    XIDeviceInfo* XIQueryDevice(Display *display, int deviceid, int *ndevices_return)
+    void XIFreeDeviceInfo(XIDeviceInfo *info)
+    Atom *XIListProperties(Display *display, int deviceid, int *num_props_return)
+    Status XIGetProperty(Display *display, int deviceid, Atom property, long offset, long length,
+                         Bool delete_property, Atom type, Atom *type_return,
+                         int *format_return, unsigned long *num_items_return,
+                         unsigned long *bytes_after_return, unsigned char **data)
+
+
+DEF MAX_XI_EVENTS = 64
+DEF XI_EVENT_MASK_SIZE = (MAX_XI_EVENTS+7)//8
+
+XI_EVENT_NAMES = {
+    XI_DeviceChanged    : "XI_DeviceChanged",
+    XI_KeyPress         : "XI_KeyPress",
+    XI_KeyRelease       : "XI_KeyRelease",
+    XI_ButtonPress      : "XI_ButtonPress",
+    XI_ButtonRelease    : "XI_ButtonRelease",
+    XI_Motion           : "XI_Motion",
+    XI_Enter            : "XI_Enter",
+    XI_Leave            : "XI_Leave",
+    XI_FocusIn          : "XI_FocusIn",
+    XI_FocusOut         : "XI_FocusOut",
+    XI_HierarchyChanged : "XI_HierarchyChanged",
+    XI_PropertyEvent    : "XI_PropertyEvent",
+    XI_RawKeyPress      : "XI_RawKeyPress",
+    XI_RawKeyRelease    : "XI_RawKeyRelease",
+    XI_RawButtonPress   : "XI_RawButtonPress",
+    XI_RawButtonRelease : "XI_RawButtonRelease",
+    XI_RawMotion        : "XI_RawMotion",
+    XI_TouchBegin       : "XI_TouchBegin",
+    XI_TouchUpdate      : "XI_TouchUpdate",
+    XI_TouchEnd         : "XI_TouchEnd",
+    XI_TouchOwnership   : "XI_TouchOwnership",
+    XI_RawTouchBegin    : "XI_RawTouchBegin",
+    XI_RawTouchUpdate   : "XI_RawTouchUpdate",
+    XI_RawTouchEnd      : "XI_RawTouchEnd",
+    }
+
+XI_USE = {
+    XIMasterPointer     : "master pointer",
+    XIMasterKeyboard    : "master keyboard",
+    XISlavePointer      : "slave pointer",
+    XISlaveKeyboard     : "slave keyboard",
+    XIFloatingSlave     : "floating slave",
+    }
+
+CLASS_INFO = {
+    XIButtonClass       : "button",
+    XIKeyClass          : "key",
+    XIValuatorClass     : "valuator",
+    XIScrollClass       : "scroll",
+    XITouchClass        : "touch",
+    }
+
+
+from core_bindings cimport _X11CoreBindings
+
+cdef _X11XI2Bindings singleton = None
+def X11XI2Bindings():
+    global singleton
+    if singleton is None:
+        singleton = _X11XI2Bindings()
+    return singleton
+
+cdef class _X11XI2Bindings(_X11CoreBindings):
+
+    cdef int opcode
+    cdef object events
+
+    def __init__(self):
+        self.opcode = -1
+        self.reset_events()
+
+    def __repr__(self):
+        return "X11XI2Bindings(%s)" % self.display_name
+
+    def reset_events(self):
+        self.events = collections.deque(maxlen=100)
+
+    def find_events(self, event_name):
+        found = 0
+        matches = []
+        for x in reversed(self.events):
+            if x.name==event_name and (found==0 or found==x.window):
+                matches.append(x)
+                found = x.window
+            elif found:
+                break
+        return matches
+
+    cdef int get_xi_opcode(self, int major=2, int minor=2):
+        if self.opcode!=-1:
+            return self.opcode
+        cdef int opcode, event, error
+        if not XQueryExtension(self.display, "XInputExtension", &opcode, &event, &error):
+            log.warn("Warning: XI2 events are not supported")
+            self.opcode = 0
+            return 0
+        cdef int rmajor = major, rminor = minor
+        cdef int rc = XIQueryVersion(self.display, &rmajor, &rminor)
+        if rc == BadRequest:
+            log.warn("Warning: no XI2 %i.%i support,", major, minor)
+            log.warn(" server supports version %i.%i only", rmajor, rminor)
+            self.opcode = 0
+            return 0
+        elif rc:
+            log.warn("Warning: Xlib bug querying XI2, code %i", rc)
+            self.opcode = 0
+            return 0
+        self.opcode = opcode
+        log("get_xi_opcode%s=%i", (major, minor), opcode)
+        return opcode
+
+    cdef register_parser(self):
+        log("register_parser()")
+        if self.opcode>0:
+            from xpra.x11.gtk2.gdk_bindings import add_x_event_parser
+            add_x_event_parser(self.opcode, self.parse_xi_event)
+
+    cdef register_gdk_events(self):
+        log("register_gdk_events()")
+        if self.opcode<=0:
+            return
+        global XI_EVENT_NAMES
+        from xpra.x11.gtk2.gdk_bindings import add_x_event_signal, add_x_event_type_name
+        for e, xi_event_name in {
+            XI_DeviceChanged    : "device-changed",
+            XI_KeyPress         : "key-press",
+            XI_KeyRelease       : "key-release",
+            XI_ButtonPress      : "button-press",
+            XI_ButtonRelease    : "button-release",
+            XI_Motion           : "motion",
+            XI_Enter            : "enter",
+            XI_Leave            : "leave",
+            XI_FocusIn          : "focus-in",
+            XI_FocusOut         : "focus-out",
+            XI_HierarchyChanged : "focus-changed",
+            XI_PropertyEvent    : "property-event",
+            XI_RawKeyPress      : "raw-key-press",
+            XI_RawKeyRelease    : "raw-key-release",
+            XI_RawButtonPress   : "raw-button-press",
+            XI_RawButtonRelease : "raw-button-release",
+            XI_RawMotion        : "raw-motion",
+            XI_TouchBegin       : "touch-begin",
+            XI_TouchUpdate      : "touch-update",
+            XI_TouchEnd         : "touch-end",
+            XI_TouchOwnership   : "touch-ownership",
+            XI_RawTouchBegin    : "raw-touch-begin",
+            XI_RawTouchUpdate   : "raw-touch-update",
+            XI_RawTouchEnd      : "raw-touch-end",
+            }.items():
+            event = self.opcode+e
+            add_x_event_signal(event, ("xi-%s" % xi_event_name, None))
+            name = XI_EVENT_NAMES[e]
+            add_x_event_type_name(event, name)
+
+    def select_xi2_events(self):
+        cdef Window win = XDefaultRootWindow(self.display)
+        log("select_xi2_events() root window=%#x", win)
+        assert XI_LASTEVENT<MAX_XI_EVENTS, "bug: source needs to be updated, XI_LASTEVENT=%i" % XI_LASTEVENT
+        cdef XIEventMask evmasks[1]
+        cdef unsigned char mask1[XI_EVENT_MASK_SIZE]
+        memset(mask1, 0, XI_EVENT_MASK_SIZE)
+        #define XISetMask(ptr, event)   (((unsigned char*)(ptr))[(event)>>3] |=  (1 << ((event) & 7)))
+        #XISetMask(mask1, XI_RawMotion)
+        for e in (
+            XI_KeyPress, XI_KeyRelease,
+            XI_Motion,
+            XI_HierarchyChanged,
+            XI_ButtonPress, XI_ButtonRelease,
+            XI_TouchBegin, XI_TouchUpdate, XI_TouchEnd,
+            ):
+            mask1[e>>3] |= (1<< (e & 0x7))
+        evmasks[0].deviceid = XIAllDevices  #XIAllMasterDevices    #XIAllDevices
+        evmasks[0].mask_len = XI_EVENT_MASK_SIZE
+        evmasks[0].mask = mask1
+        XISelectEvents(self.display, win, evmasks, 1)
+        XFlush(self.display)
+
+    def parse_xi_event(self, display, uintptr_t _cookie):
+        log("parse_xi_event(%s)", _cookie)
+        cdef XGenericEventCookie *cookie = <XGenericEventCookie*> _cookie
+        cdef XIDeviceEvent *device_e
+        cdef XIHierarchyEvent * hierarchy_e
+        cdef XIEvent *xie
+        cdef XIRawEvent *raw
+        cdef int i = 0, j = 0
+        if not XGetEventData(self.display, cookie):
+            return None
+        xie = <XIEvent*> cookie.data
+        device_e = <XIDeviceEvent*> cookie.data
+        cdef int xi_type = cookie.evtype
+        etype = self.opcode+xi_type
+        global XI_EVENT_NAMES
+        event_name = XI_EVENT_NAMES.get(xi_type)
+        if not event_name:
+            log("unknown XI2 event code: %i", xi_type)
+            return None
+
+        pyev = X11Event(event_name)
+        pyev.type = etype
+        pyev.display = display
+        pyev.send_event = bool(xie.send_event)
+        pyev.serial = xie.serial
+        pyev.time = int(xie.time)
+        pyev.window = XDefaultRootWindow(self.display)
+
+        if xi_type in (XI_KeyPress, XI_KeyRelease,
+                       XI_ButtonPress, XI_ButtonRelease,
+                       XI_Motion,
+                       XI_TouchBegin, XI_TouchUpdate, XI_TouchEnd):
+            device = <XIDeviceEvent*> cookie.data
+            #pyev.source = device.sourceid    #always 0
+            pyev.device = device.deviceid
+            pyev.detail = device.detail
+            pyev.flags = device.flags
+            pyev.window = int(device.child or device.event or device.root)
+            pyev.root_x = device.root_x
+            pyev.root_y = device.root_y
+            pyev.x = device.event_x
+            pyev.y = device.event_y
+            #mask = []
+            #values = []
+            #raw_values = []
+            #if False:
+            #    for i in range(device.valuators.mask_len):
+            #        if device.valuators.mask[i//8] & (1 << (i & 0x7)):
+            #            mask.append(i)
+            #            values.append(j)
+            #            raw_values.append(device.valuators.values[j])
+            #            j += 1
+            #pyev.valuators = {
+            #    "mask"      : mask,
+            #    "values"    : values,
+            #    }
+        elif xi_type == XI_HierarchyChanged:
+            pass
+            #hierarchy_e = <XIHierarchyEvent*> cookie.data
+            #pyev.flags = hierarchy_e.flags
+            #info = {}
+            #for i in range(hierarchy_e.num_info):
+            #
+        XFreeEventData(self.display, cookie)
+        self.events.append(pyev)
+        return pyev
+
+    def get_devices(self, show_all=False, show_disabled=False):
+        global XI_USE
+        cdef int ndevices, i, j
+        cdef XIDeviceInfo *devices
+        cdef XIDeviceInfo *device
+        cdef XIAnyClassInfo *clazz
+        if show_all:
+            device_types = XIAllDevices
+        else:
+            device_types = XIAllMasterDevices
+        devices = XIQueryDevice(self.display, device_types, &ndevices)
+        dinfo = {}
+        for i in range(ndevices):
+            device = &devices[i]
+            if not device.enabled and not show_disabled:
+                continue
+            info = {
+                "name"          : device.name,
+                "id"            : device.deviceid,
+                "use"           : XI_USE.get(device.use, "unknown use: %i" % device.use),
+                "attachment"    : device.attachment,
+                "enabled"       : device.enabled,
+                }
+            classes = {}
+            for j in range(device.num_classes):
+                clazz = device.classes[j]
+                classes[j] = self.get_class_info(clazz)
+            info["classes"] = classes
+            dinfo[i] = info
+        XIFreeDeviceInfo(devices)
+        return dinfo
+
+    cdef get_class_info(self, XIAnyClassInfo *class_info):
+        cdef int i
+        cdef XIButtonClassInfo *button
+        cdef XIKeyClassInfo *key
+        cdef XIValuatorClassInfo *valuator
+        cdef XIScrollClassInfo *scroll
+        cdef XITouchClassInfo *touch
+        info = {
+            "type"      : CLASS_INFO.get(class_info.type, "unknown type: %i" % class_info.type),
+            "sourceid"  : class_info.sourceid,
+            }
+        if class_info.type==XIButtonClass:
+            button = <XIButtonClassInfo*> class_info
+            buttons = []
+            for i in range(button.num_buttons):
+                if button.labels[i]>0:
+                    buttons.append(self.XGetAtomName(button.labels[i]))
+            info["buttons"] = buttons
+            #XIButtonState state
+        elif class_info.type==XIKeyClass:
+            key = <XIKeyClassInfo*> class_info
+            keys = []
+            for i in range(key.num_keycodes):
+                keys.append(key.keycodes[i])
+        elif class_info.type==XIValuatorClass:
+            valuator = <XIValuatorClassInfo*> class_info
+            info.update({
+                "number"    : valuator.number,
+                "min"       : valuator.min,
+                "max"       : valuator.max,
+                "value"     : valuator.value,
+                "resolution": valuator.resolution,
+                "mode"      : valuator.mode,
+                })
+            if valuator.label:
+                info["label"] = self.XGetAtomName(valuator.label)
+        elif class_info.type==XIScrollClass:
+            scroll = <XIScrollClassInfo*> class_info
+            info.update({
+                "number"        : scroll.number,
+                "scroll-type"   : scroll.scroll_type,
+                "increment"     : scroll.increment,
+                "flags"         : scroll.flags,
+                })
+        elif class_info.type==XITouchClass:
+            touch = <XITouchClassInfo*> class_info
+            info.update({
+                "mode"          : touch.mode,
+                "num-touches"   : touch.num_touches,
+                })
+        return info
+
+
+    def gdk_inject(self):
+        self.get_xi_opcode()
+        log.info("XInput Devices:")
+        from xpra.util import print_nested_dict
+        print_nested_dict(self.get_devices(), print_fn=log.info)
+        self.register_parser()
+        self.register_gdk_events()
+        #self.select_xi2_events()