Ticket #59: xpra-splitxkb.patch

setup.py

@@ -55 +55 @@
                     ".".join([str(part) for part in NEEDED_CYTHON])))
 
     ext_modules = [
+      Extension("xpra.xposix.xkb_bindings",
+                ["xpra/xposix/xkb_bindings.pyx"],
+                **pkgconfig("pygobject-2.0", "gdk-x11-2.0", "gtk+-x11-2.0",
+                            "x11")
+                ),
       Extension("wimpiggy.lowlevel.bindings",
                 ["wimpiggy/lowlevel/bindings.pyx"],
                 **pkgconfig("pygobject-2.0", "gdk-x11-2.0", "gtk+-x11-2.0",

xpra/xposix/xkb_bindings.pyx

@@ +1 @@
+# This file is part of Parti.
+# Copyright (C) 2010-2012 Antoine Martin <antoine@devloop.org.uk>
+# Copyright (C) 2008, 2009 Nathaniel Smith <njs@pobox.com>
+# Parti is released under the terms of the GNU GPL v2, or, at your option, any
+# later version. See the file COPYING for details.
+
+# This file duplicates the code from wimpiggy/lowlevel/bindings.pyx
+# TODO: As noted in said file, the proper solution is to split it up
+
+import struct
+
+import gobject
+import gtk
+import gtk.gdk
+
+from wimpiggy.log import Logger
+log = Logger("wimpiggy.bell_bindings")
+
+###################################
+# Headers, python magic
+###################################
+cdef extern from "gdk/gdk.h":
+    pass
+cdef extern from "gdk/gdkx.h":
+    pass
+
+# Serious black magic happens here (I owe these guys beers):
+cdef extern from "pygobject.h":
+    void init_pygobject()
+init_pygobject()
+
+cdef extern from "pygtk/pygtk.h":
+    void init_pygtk()
+init_pygtk()
+# Now all the macros in those header files will work.
+
+###################################
+# GObject
+###################################
+
+cdef extern from "glib-2.0/glib-object.h":
+    ctypedef struct cGObject "GObject":
+        pass
+
+cdef extern from "pygtk-2.0/pygobject.h":
+    cGObject * pygobject_get(object box)
+    ctypedef void** const_void_pp "const void**"
+
+    # I am naughty; the exposed accessor for PyGBoxed objects is a macro that
+    # takes a type name as one of its arguments, and thus is impossible to
+    # wrap from Pyrex; so I just peek into the object directly:
+    ctypedef struct PyGBoxed:
+        void * boxed
+
+cdef cGObject * unwrap(box, pyclass) except? NULL:
+    # Extract a raw GObject* from a PyGObject wrapper.
+    assert issubclass(pyclass, gobject.GObject)
+    if not isinstance(box, pyclass):
+        raise TypeError, ("object %r is not a %r" % (box, pyclass))
+    return pygobject_get(box)
+
+###################################
+# Raw Xlib and GDK
+###################################
+
+include "../../wimpiggy/lowlevel/constants.pxi"
+ctypedef unsigned long CARD32
+
+cdef extern from "X11/Xlib.h":
+    ctypedef struct Display:
+        pass
+    ctypedef CARD32 XID
+    ctypedef int Bool
+    ctypedef XID Window
+    ctypedef CARD32 Atom
+
+# gdk_region_get_rectangles (pygtk bug #517099)
+cdef extern from "gtk-2.0/gdk/gdktypes.h":
+    ctypedef struct cGdkWindow "GdkWindow":
+        pass
+    Window GDK_WINDOW_XID(cGdkWindow *)
+
+    ctypedef struct cGdkDisplay "GdkDisplay":
+        pass
+    Display * GDK_DISPLAY_XDISPLAY(cGdkDisplay *)
+
+    ctypedef void * GdkAtom
+    GdkAtom PyGdkAtom_Get(object)
+    Atom gdk_x11_atom_to_xatom_for_display(cGdkDisplay *, GdkAtom)
+
+def get_xwindow(pywindow):
+    return GDK_WINDOW_XID(<cGdkWindow*>unwrap(pywindow, gtk.gdk.Window))
+
+def get_display_for(obj):
+    if isinstance(obj, gtk.gdk.Display):
+        return obj
+    elif isinstance(obj, (gtk.gdk.Drawable,
+                          gtk.Widget,
+                          gtk.Clipboard)):
+        return obj.get_display()
+    else:
+        raise TypeError, "Don't know how to get a display from %r" % (obj,)
+
+def get_xatom(display_source, str_or_xatom):
+    """Returns the X atom corresponding to the given Python string or Python
+    integer (assumed to already be an X atom)."""
+    if isinstance(str_or_xatom, (int, long)):
+        return str_or_xatom
+    assert isinstance(str_or_xatom, str)
+    gdkatom = gtk.gdk.atom_intern(str_or_xatom)
+    return gdk_x11_atom_to_xatom_for_display(
+        get_raw_display_for(display_source),
+        PyGdkAtom_Get(gdkatom),
+        )
+
+cdef cGdkDisplay * get_raw_display_for(obj) except? NULL:
+    return <cGdkDisplay*> unwrap(get_display_for(obj), gtk.gdk.Display)
+
+cdef Display * get_xdisplay_for(obj) except? NULL:
+    return GDK_DISPLAY_XDISPLAY(get_raw_display_for(obj))
+
+cdef extern from "X11/XKBlib.h":
+    Bool XkbDeviceBell(Display *, Window w, int deviceSpec, int bellClass, int bellID, int percent, Atom name)
+    Bool XkbGetAutoRepeatRate(Display *, unsigned int deviceSpec, unsigned int *delayRtrn, unsigned int *intervalRtrn)
+
+cdef extern from "X11/extensions/XKB.h":
+    unsigned int XkbUseCoreKbd
+
+def get_key_repeat_rate():
+    cdef Display * display
+    cdef unsigned int deviceSpec = XkbUseCoreKbd
+    cdef unsigned int delay = 0
+    cdef unsigned int interval = 0
+    display = get_xdisplay_for(gtk.gdk.get_default_root_window())
+    if not XkbGetAutoRepeatRate(display, deviceSpec, &delay, &interval):
+        return None
+    return (delay, interval)
+
+def device_bell(pywindow, deviceSpec, bellClass, bellID, percent, name):
+    cdef Display * display
+    cdef Window window
+    display = get_xdisplay_for(pywindow)
+    window = get_xwindow(pywindow)
+    name_atom = get_xatom(pywindow, name)
+    return XkbDeviceBell(display, window, deviceSpec, bellClass, bellID,  percent, name_atom)

xpra/xposix/gui.py

@@ -187 +187 @@
     def setup_x11_bell(self):
         self.has_x11_bell = False
         try:
-            from wimpiggy.lowlevel.bindings import device_bell
+            from xpra.xposix.xkb_bindings import device_bell
             self.has_x11_bell = device_bell is not None
+            log.info("has_x11_bell=%s, xkb_bindings=%s" % (self.has_x11_bell, device_bell))
         except ImportError, e:
             log.error("cannot import x11 bell bindings (will use gtk fallback) : %s", e)
 
@@ -222 +223 @@
             self.client.send(["server-settings", {self.ROOT_PROPS[prop]: value.encode("utf-8")}])
 
     def system_bell(self, window, device, percent, pitch, duration, bell_class, bell_id, bell_name):
+        log.info("system_bell(%s,%s,%s,%s,%s,%s,%s,%s)", window, device, percent, pitch, duration, bell_class, bell_id, bell_name)
         if not self.has_x11_bell:
             import gtk.gdk
             gtk.gdk.beep()
             return
-        from wimpiggy.lowlevel.bindings import device_bell      #@UnresolvedImport
+        from xpra.xposix.xkb_bindings import device_bell      #@UnresolvedImport
         device_bell(window, device, bell_class, bell_id, percent, bell_name)
 
     def can_notify(self):
@@ -313 +315 @@
 
     def get_keyboard_repeat(self):
         try:
-            from wimpiggy.lowlevel import get_key_repeat_rate   #@UnresolvedImport
+            from xpra.xposix.xkb_bindings import get_key_repeat_rate   #@UnresolvedImport
             delay, interval = get_key_repeat_rate()
+            log.info("=(%s,%s)" % (delay, interval))
             return delay,interval
         except Exception, e:
             log.error("failed to get keyboard repeat rate: %s", e)