svn merge https://vcxsrv.svn.sourceforge.net/svnroot/vcxsrv/branches/released .

1 files changed, 740 insertions, 663 deletions

diff --git a/xorg-server/Xi/exevents.c b/xorg-server/Xi/exevents.c
index 56e1d4439..edd775c3b 100644
--- a/xorg-server/Xi/exevents.c
+++ b/xorg-server/Xi/exevents.c
@@ -52,19 +52,19 @@ SOFTWARE.
  *
  */
 
-#define	 NEED_EVENTS
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #else
 #define XINPUT
 #endif
 
+#include "inputstr.h"
 #include <X11/X.h>
 #include <X11/Xproto.h>
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
+#include <X11/extensions/XI2proto.h>
 #include <X11/extensions/geproto.h>
-#include "inputstr.h"
 #include "windowstr.h"
 #include "miscstruct.h"
 #include "region.h"
@@ -76,12 +76,12 @@ SOFTWARE.
 #include "scrnintstr.h"
 #include "listdev.h" /* for CopySwapXXXClass */
 #include "xace.h"
+#include "xiquerydevice.h" /* For List*Info */
+#include "eventconvert.h"
+#include "eventstr.h"
 
-#ifdef XKB
 #include <X11/extensions/XKBproto.h>
 #include "xkbsrv.h"
-extern Bool XkbCopyKeymap(XkbDescPtr src, XkbDescPtr dst, Bool sendNotifies);
-#endif
 
 #define WID(w) ((w) ? ((w)->drawable.id) : 0)
 #define AllModifiersMask ( \
@@ -89,8 +89,6 @@ extern Bool XkbCopyKeymap(XkbDescPtr src, XkbDescPtr dst, Bool sendNotifies);
 	Mod3Mask | Mod4Mask | Mod5Mask )
 #define AllButtonsMask ( \
 	Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask )
-#define Motion_Filter(class) (DevicePointerMotionMask | \
-			      (class)->state | (class)->motionMask)
 
 Bool ShouldFreeInputMasks(WindowPtr /* pWin */ ,
 				 Bool	/* ignoreSelectedEvents */
@@ -101,6 +99,22 @@ static Bool MakeInputMasks(WindowPtr	/* pWin */
 /* Used to sture classes currently not in use by an MD */
 extern DevPrivateKey UnusedClassesPrivateKey;
 
+/*
+ * Only let the given client know of core events which will affect its
+ * interpretation of input events, if the client's ClientPointer (or the
+ * paired keyboard) is the current device.
+ */
+int
+XIShouldNotify(ClientPtr client, DeviceIntPtr dev)
+{
+    DeviceIntPtr current_ptr = PickPointer(client);
+    DeviceIntPtr current_kbd = GetPairedDevice(current_ptr);
+
+    if (dev == current_kbd || dev == current_ptr)
+        return 1;
+
+    return 0;
+}
 
 void
 RegisterOtherDevice(DeviceIntPtr device)
@@ -110,25 +124,17 @@ RegisterOtherDevice(DeviceIntPtr device)
 }
 
 Bool
-IsPointerEvent(xEvent* xE)
+IsPointerEvent(InternalEvent* event)
 {
-    switch(xE->u.u.type)
+    switch(event->any.type)
     {
-        case ButtonPress:
-        case ButtonRelease:
-        case MotionNotify:
-        case EnterNotify:
-        case LeaveNotify:
+        case ET_ButtonPress:
+        case ET_ButtonRelease:
+        case ET_Motion:
+            /* XXX: enter/leave ?? */
             return TRUE;
         default:
-            if (xE->u.u.type == DeviceButtonPress ||
-                xE->u.u.type == DeviceButtonRelease ||
-                xE->u.u.type == DeviceMotionNotify ||
-                xE->u.u.type == ProximityIn ||
-                xE->u.u.type == ProximityOut)
-            {
-                return TRUE;
-            }
+            break;
     }
     return FALSE;
 }
@@ -188,88 +194,23 @@ XIGetDevice(xEvent* xE)
  * This code is basically the old SwitchCoreKeyboard.
  */
 
-void
+static void
 CopyKeyClass(DeviceIntPtr device, DeviceIntPtr master)
 {
-    static DeviceIntPtr lastMapNotifyDevice = NULL;
-    KeyClassPtr mk, dk; /* master, device */
-    BOOL sendNotify = FALSE;
+    KeyClassPtr mk = master->key;
+    KeyClassPtr dk = device->key;
     int i;
 
     if (device == master)
         return;
 
-    dk = device->key;
-    mk = master->key;
+    mk->sourceid = device->id;
 
-    if (device != dixLookupPrivate(&master->devPrivates,
-                                   CoreDevicePrivateKey)) {
-        memcpy(mk->modifierMap, dk->modifierMap, MAP_LENGTH);
+    for (i = 0; i < 8; i++)
+        mk->modifierKeyCount[i] = dk->modifierKeyCount[i];
 
-        if (dk->maxKeysPerModifier)
-        {
-            mk->modifierKeyMap = xrealloc(mk->modifierKeyMap,
-                                          8 * dk->maxKeysPerModifier);
-            if (!mk->modifierKeyMap)
-                FatalError("[Xi] no memory for class shift.\n");
-            memcpy(mk->modifierKeyMap, dk->modifierKeyMap,
-                    (8 * dk->maxKeysPerModifier));
-        } else
-        {
-            xfree(mk->modifierKeyMap);
-            mk->modifierKeyMap = NULL;
-        }
-
-        mk->maxKeysPerModifier = dk->maxKeysPerModifier;
-        mk->curKeySyms.minKeyCode = dk->curKeySyms.minKeyCode;
-        mk->curKeySyms.maxKeyCode = dk->curKeySyms.maxKeyCode;
-        SetKeySymsMap(&mk->curKeySyms, &dk->curKeySyms);
-
-        /*
-         * Copy state from the extended keyboard to core.  If you omit this,
-         * holding Ctrl on keyboard one, and pressing Q on keyboard two, will
-         * cause your app to quit.  This feels wrong to me, hence the below
-         * code.
-         *
-         * XXX: If you synthesise core modifier events, the state will get
-         *      clobbered here.  You'll have to work out something sensible
-         *      to fix that.  Good luck.
-         */
-
-#define KEYBOARD_MASK (ShiftMask | LockMask | ControlMask | Mod1Mask | \
-        Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask)
-        mk->state &= ~(KEYBOARD_MASK);
-        mk->state |= (dk->state & KEYBOARD_MASK);
-#undef KEYBOARD_MASK
-        for (i = 0; i < 8; i++)
-            mk->modifierKeyCount[i] = dk->modifierKeyCount[i];
-
-#ifdef XKB
-        if (!noXkbExtension && dk->xkbInfo && dk->xkbInfo->desc) {
-            if (!mk->xkbInfo || !mk->xkbInfo->desc)
-            {
-                XkbInitDevice(master);
-                XkbFinishDeviceInit(master);
-            }
-            if (!XkbCopyKeymap(dk->xkbInfo->desc, mk->xkbInfo->desc, True))
-                FatalError("Couldn't pivot keymap from device to core!\n");
-        }
-#endif
-
-        dixSetPrivate(&master->devPrivates, CoreDevicePrivateKey, device);
-        sendNotify = TRUE;
-    } else if (lastMapNotifyDevice != master)
-        sendNotify = TRUE;
-
-    if (sendNotify)
-    {
-        SendMappingNotify(master, MappingKeyboard,
-                           mk->curKeySyms.minKeyCode,
-                          (mk->curKeySyms.maxKeyCode -
-                           mk->curKeySyms.minKeyCode),
-                          serverClient);
-        lastMapNotifyDevice = master;
-    }
+    if (!XkbCopyDeviceKeymap(master, device))
+        FatalError("Couldn't pivot keymap from device to core!\n");
 }
 
 /**
@@ -282,82 +223,6 @@ DeepCopyFeedbackClasses(DeviceIntPtr from, DeviceIntPtr to)
 {
     ClassesPtr classes;
 
-    if (from->kbdfeed)
-    {
-        KbdFeedbackPtr *k, it;
-
-        if (!to->kbdfeed)
-        {
-            classes = dixLookupPrivate(&to->devPrivates,
-                                       UnusedClassesPrivateKey);
-            to->kbdfeed = classes->kbdfeed;
-        }
-
-        k = &to->kbdfeed;
-        for(it = from->kbdfeed; it; it = it->next)
-        {
-            if (!(*k))
-            {
-                *k = xcalloc(1, sizeof(KbdFeedbackClassRec));
-                if (!*k)
-                {
-                    ErrorF("[Xi] Cannot alloc memory for class copy.");
-                    return;
-                }
-            }
-            (*k)->BellProc = it->BellProc;
-            (*k)->CtrlProc = it->CtrlProc;
-            (*k)->ctrl     = it->ctrl;
-#ifdef XKB
-            if ((*k)->xkb_sli)
-                XkbFreeSrvLedInfo((*k)->xkb_sli);
-            (*k)->xkb_sli = XkbCopySrvLedInfo(from, it->xkb_sli, *k, NULL);
-#endif
-
-            k = &(*k)->next;
-        }
-    } else if (to->kbdfeed && !from->kbdfeed)
-    {
-        ClassesPtr classes;
-        classes = dixLookupPrivate(&to->devPrivates, UnusedClassesPrivateKey);
-        classes->kbdfeed = to->kbdfeed;
-        to->kbdfeed      = NULL;
-    }
-
-    if (from->ptrfeed)
-    {
-        PtrFeedbackPtr *p, it;
-        if (!to->ptrfeed)
-        {
-            classes = dixLookupPrivate(&to->devPrivates,
-                                       UnusedClassesPrivateKey);
-            to->ptrfeed = classes->ptrfeed;
-        }
-
-        p = &to->ptrfeed;
-        for (it = from->ptrfeed; it; it = it->next)
-        {
-            if (!(*p))
-            {
-                *p = xcalloc(1, sizeof(PtrFeedbackClassRec));
-                if (!*p)
-                {
-                    ErrorF("[Xi] Cannot alloc memory for class copy.");
-                    return;
-                }
-            }
-            (*p)->CtrlProc = it->CtrlProc;
-            (*p)->ctrl     = it->ctrl;
-
-            p = &(*p)->next;
-        }
-    } else if (to->ptrfeed && !from->ptrfeed)
-    {
-        ClassesPtr classes;
-        classes = dixLookupPrivate(&to->devPrivates, UnusedClassesPrivateKey);
-        classes->ptrfeed = to->ptrfeed;
-        to->ptrfeed      = NULL;
-    }
 
     if (from->intfeed)
     {
@@ -493,11 +358,9 @@ DeepCopyFeedbackClasses(DeviceIntPtr from, DeviceIntPtr to)
             }
             (*l)->CtrlProc = it->CtrlProc;
             (*l)->ctrl     = it->ctrl;
-#ifdef XKB
             if ((*l)->xkb_sli)
                 XkbFreeSrvLedInfo((*l)->xkb_sli);
             (*l)->xkb_sli = XkbCopySrvLedInfo(from, it->xkb_sli, NULL, *l);
-#endif
 
             l = &(*l)->next;
         }
@@ -510,74 +373,161 @@ DeepCopyFeedbackClasses(DeviceIntPtr from, DeviceIntPtr to)
     }
 }
 
-/**
- * Copies the CONTENT of the classes of device from into the classes in device
- * to. From and to are identical after finishing.
- *
- * If to does not have classes from currenly has, the classes are stored in
- * to's devPrivates system. Later, we recover it again from there if needed.
- * Saves a few memory allocations.
- */
-
-void
-DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to)
+static void
+DeepCopyKeyboardClasses(DeviceIntPtr from, DeviceIntPtr to)
 {
     ClassesPtr classes;
 
     /* XkbInitDevice (->XkbInitIndicatorMap->XkbFindSrvLedInfo) relies on the
      * kbdfeed to be set up properly, so let's do the feedback classes first.
      */
-    DeepCopyFeedbackClasses(from, to);
+    if (from->kbdfeed)
+    {
+        KbdFeedbackPtr *k, it;
+
+        if (!to->kbdfeed)
+        {
+            classes = dixLookupPrivate(&to->devPrivates,
+                                       UnusedClassesPrivateKey);
+
+            to->kbdfeed = classes->kbdfeed;
+            if (!to->kbdfeed)
+                InitKeyboardDeviceStruct(to, NULL, NULL, NULL);
+        }
+
+        k = &to->kbdfeed;
+        for(it = from->kbdfeed; it; it = it->next)
+        {
+            if (!(*k))
+            {
+                *k = xcalloc(1, sizeof(KbdFeedbackClassRec));
+                if (!*k)
+                {
+                    ErrorF("[Xi] Cannot alloc memory for class copy.");
+                    return;
+                }
+            }
+            (*k)->BellProc = it->BellProc;
+            (*k)->CtrlProc = it->CtrlProc;
+            (*k)->ctrl     = it->ctrl;
+            if ((*k)->xkb_sli)
+                XkbFreeSrvLedInfo((*k)->xkb_sli);
+            (*k)->xkb_sli = XkbCopySrvLedInfo(from, it->xkb_sli, *k, NULL);
+
+            k = &(*k)->next;
+        }
+    } else if (to->kbdfeed && !from->kbdfeed)
+    {
+        ClassesPtr classes;
+        classes = dixLookupPrivate(&to->devPrivates, UnusedClassesPrivateKey);
+        classes->kbdfeed = to->kbdfeed;
+        to->kbdfeed      = NULL;
+    }
 
     if (from->key)
     {
-        KeyCode             *oldModKeyMap;
-        KeySym              *oldMap;
-#ifdef XKB
-        struct _XkbSrvInfo  *oldXkbInfo;
-#endif
         if (!to->key)
         {
             classes = dixLookupPrivate(&to->devPrivates,
-                                       UnusedClassesPrivateKey);
+                    UnusedClassesPrivateKey);
             to->key = classes->key;
             if (!to->key)
+                InitKeyboardDeviceStruct(to, NULL, NULL, NULL);
+            else
+                classes->key = NULL;
+        }
+
+        CopyKeyClass(from, to);
+    } else if (to->key && !from->key)
+    {
+        ClassesPtr classes;
+        classes = dixLookupPrivate(&to->devPrivates, UnusedClassesPrivateKey);
+        classes->key = to->key;
+        to->key      = NULL;
+    }
+
+    /* We can't just copy over the focus class. When an app sets the focus,
+     * it'll do so on the master device. Copying the SDs focus means losing
+     * the focus.
+     * So we only copy the focus class if the device didn't have one,
+     * otherwise we leave it as it is.
+     */
+    if (from->focus)
+    {
+        if (!to->focus)
+        {
+            WindowPtr *oldTrace;
+
+            classes = dixLookupPrivate(&to->devPrivates,
+                                       UnusedClassesPrivateKey);
+            to->focus = classes->focus;
+            if (!to->focus)
             {
-                to->key = xcalloc(1, sizeof(KeyClassRec));
-                if (!to->key)
+                to->focus = xcalloc(1, sizeof(FocusClassRec));
+                if (!to->focus)
                     FatalError("[Xi] no memory for class shift.\n");
             } else
-                classes->key = NULL;
+                classes->focus = NULL;
+
+            oldTrace = to->focus->trace;
+            memcpy(to->focus, from->focus, sizeof(FocusClassRec));
+            to->focus->trace = xrealloc(oldTrace,
+                                  to->focus->traceSize * sizeof(WindowPtr));
+            if (!to->focus->trace && to->focus->traceSize)
+                FatalError("[Xi] no memory for trace.\n");
+            memcpy(to->focus->trace, from->focus->trace,
+                    from->focus->traceSize * sizeof(WindowPtr));
+            to->focus->sourceid = from->id;
         }
+    } else if (to->focus)
+    {
+        ClassesPtr classes;
+        classes = dixLookupPrivate(&to->devPrivates, UnusedClassesPrivateKey);
+        classes->focus = to->focus;
+        to->focus      = NULL;
+    }
 
-        oldModKeyMap    = to->key->modifierKeyMap;
-        oldMap          = to->key->curKeySyms.map;
-#ifdef XKB
-        oldXkbInfo      = to->key->xkbInfo;
-#endif
+}
 
-        if (!oldMap) /* newly created key struct */
+static void
+DeepCopyPointerClasses(DeviceIntPtr from, DeviceIntPtr to)
+{
+    ClassesPtr classes;
+
+    /* Feedback classes must be copied first */
+    if (from->ptrfeed)
+    {
+        PtrFeedbackPtr *p, it;
+        if (!to->ptrfeed)
         {
-            int bytes = (to->key->curKeySyms.maxKeyCode -
-                         to->key->curKeySyms.minKeyCode + 1) *
-                         to->key->curKeySyms.mapWidth;
-            oldMap = (KeySym *)xcalloc(sizeof(KeySym), bytes);
-            memcpy(oldMap, from->key->curKeySyms.map, bytes);
+            classes = dixLookupPrivate(&to->devPrivates,
+                                       UnusedClassesPrivateKey);
+            to->ptrfeed = classes->ptrfeed;
         }
 
-        to->key->modifierKeyMap = oldModKeyMap;
-        to->key->curKeySyms.map = oldMap;
-#ifdef XKB
-        to->key->xkbInfo        = oldXkbInfo;
-#endif
+        p = &to->ptrfeed;
+        for (it = from->ptrfeed; it; it = it->next)
+        {
+            if (!(*p))
+            {
+                *p = xcalloc(1, sizeof(PtrFeedbackClassRec));
+                if (!*p)
+                {
+                    ErrorF("[Xi] Cannot alloc memory for class copy.");
+                    return;
+                }
+            }
+            (*p)->CtrlProc = it->CtrlProc;
+            (*p)->ctrl     = it->ctrl;
 
-        CopyKeyClass(from, to);
-    } else if (to->key && !from->key)
+            p = &(*p)->next;
+        }
+    } else if (to->ptrfeed && !from->ptrfeed)
     {
         ClassesPtr classes;
         classes = dixLookupPrivate(&to->devPrivates, UnusedClassesPrivateKey);
-        classes->key = to->key;
-        to->key      = NULL;
+        classes->ptrfeed = to->ptrfeed;
+        to->ptrfeed      = NULL;
     }
 
     if (from->valuator)
@@ -594,7 +544,7 @@ DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to)
 
         to->valuator = xrealloc(to->valuator, sizeof(ValuatorClassRec) +
                 from->valuator->numAxes * sizeof(AxisInfo) +
-                from->valuator->numAxes * sizeof(unsigned int));
+                from->valuator->numAxes * sizeof(double));
         v = to->valuator;
         if (!v)
             FatalError("[Xi] no memory for class shift.\n");
@@ -603,7 +553,9 @@ DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to)
         v->axes = (AxisInfoPtr)&v[1];
         memcpy(v->axes, from->valuator->axes, v->numAxes * sizeof(AxisInfo));
 
-        v->axisVal = (int*)(v->axes + from->valuator->numAxes);
+        v->axisVal = (double*)(v->axes + from->valuator->numAxes);
+        v->sourceid = from->id;
+        v->mode = from->valuator->mode;
     } else if (to->valuator && !from->valuator)
     {
         ClassesPtr classes;
@@ -628,7 +580,6 @@ DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to)
                 classes->button = NULL;
         }
 
-#ifdef XKB
         if (from->button->xkb_acts)
         {
             if (!to->button->xkb_acts)
@@ -641,7 +592,10 @@ DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to)
                     sizeof(XkbAction));
         } else
             xfree(to->button->xkb_acts);
-#endif
+
+         memcpy(to->button->labels, from->button->labels,
+                from->button->numButtons * sizeof(Atom));
+        to->button->sourceid = from->id;
     } else if (to->button && !from->button)
     {
         ClassesPtr classes;
@@ -650,47 +604,6 @@ DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to)
         to->button      = NULL;
     }
 
-
-    /* We can't just copy over the focus class. When an app sets the focus,
-     * it'll do so on the master device. Copying the SDs focus means losing
-     * the focus.
-     * So we only copy the focus class if the device didn't have one,
-     * otherwise we leave it as it is.
-     */
-    if (from->focus)
-    {
-        if (!to->focus)
-        {
-            WindowPtr *oldTrace;
-
-            classes = dixLookupPrivate(&to->devPrivates,
-                                       UnusedClassesPrivateKey);
-            to->focus = classes->focus;
-            if (!to->focus)
-            {
-                to->focus = xcalloc(1, sizeof(FocusClassRec));
-                if (!to->focus)
-                    FatalError("[Xi] no memory for class shift.\n");
-            } else
-                classes->focus = NULL;
-
-            oldTrace = to->focus->trace;
-            memcpy(to->focus, from->focus, sizeof(FocusClassRec));
-            to->focus->trace = xrealloc(oldTrace,
-                                  to->focus->traceSize * sizeof(WindowPtr));
-            if (!to->focus->trace && to->focus->traceSize)
-                FatalError("[Xi] no memory for trace.\n");
-            memcpy(to->focus->trace, from->focus->trace,
-                    from->focus->traceSize * sizeof(WindowPtr));
-        }
-    } else if (to->focus)
-    {
-        ClassesPtr classes;
-        classes = dixLookupPrivate(&to->devPrivates, UnusedClassesPrivateKey);
-        classes->focus = to->focus;
-        to->focus      = NULL;
-    }
-
     if (from->proximity)
     {
         if (!to->proximity)
@@ -707,6 +620,7 @@ DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to)
                 classes->proximity = NULL;
         }
         memcpy(to->proximity, from->proximity, sizeof(ProximityClassRec));
+        to->proximity->sourceid = from->id;
     } else if (to->proximity)
     {
         ClassesPtr classes;
@@ -731,6 +645,7 @@ DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to)
                 classes->absolute = NULL;
         }
         memcpy(to->absolute, from->absolute, sizeof(AbsoluteClassRec));
+        to->absolute->sourceid = from->id;
     } else if (to->absolute)
     {
         ClassesPtr classes;
@@ -740,6 +655,78 @@ DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to)
     }
 }
 
+/**
+ * Copies the CONTENT of the classes of device from into the classes in device
+ * to. From and to are identical after finishing.
+ *
+ * If to does not have classes from currenly has, the classes are stored in
+ * to's devPrivates system. Later, we recover it again from there if needed.
+ * Saves a few memory allocations.
+ */
+void
+DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to, DeviceChangedEvent *dce)
+{
+    /* generic feedback classes, not tied to pointer and/or keyboard */
+    DeepCopyFeedbackClasses(from, to);
+
+    if ((dce->flags & DEVCHANGE_KEYBOARD_EVENT))
+        DeepCopyKeyboardClasses(from, to);
+    if ((dce->flags & DEVCHANGE_POINTER_EVENT))
+        DeepCopyPointerClasses(from, to);
+}
+
+
+/**
+ * Send an XI2 DeviceChangedEvent to all interested clients.
+ */
+void
+XISendDeviceChangedEvent(DeviceIntPtr device, DeviceIntPtr master, DeviceChangedEvent *dce)
+{
+    xXIDeviceChangedEvent *dcce;
+    int rc;
+
+    rc = EventToXI2((InternalEvent*)dce, (xEvent**)&dcce);
+    if (rc != Success)
+    {
+        ErrorF("[Xi] event conversion from DCE failed with code %d\n", rc);
+        return;
+    }
+
+    /* we don't actually swap if there's a NullClient, swapping is done
+     * later when event is delivered. */
+    SendEventToAllWindows(master, XI_DeviceChangedMask, (xEvent*)dcce, 1);
+    xfree(dcce);
+}
+
+static void
+ChangeMasterDeviceClasses(DeviceIntPtr device, DeviceChangedEvent *dce)
+{
+    DeviceIntPtr slave;
+    int rc;
+
+    /* For now, we don't have devices that change physically. */
+    if (!IsMaster(device))
+        return;
+
+    rc = dixLookupDevice(&slave, dce->sourceid, serverClient, DixReadAccess);
+
+    if (rc != Success)
+        return; /* Device has disappeared */
+
+    if (!slave->u.master)
+        return; /* set floating since the event */
+
+    if (slave->u.master->id != dce->masterid)
+        return; /* not our slave anymore, don't care */
+
+    /* FIXME: we probably need to send a DCE for the new slave now */
+
+    device->public.devicePrivate = slave->public.devicePrivate;
+
+    /* FIXME: the classes may have changed since we generated the event. */
+    DeepCopyDeviceClasses(slave, device, dce);
+    XISendDeviceChangedEvent(slave, device, dce);
+}
 
 /**
  * Update the device state according to the data in the event.
@@ -747,147 +734,106 @@ DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to)
  * return values are
  *   DEFAULT ... process as normal
  *   DONT_PROCESS ... return immediately from caller
- *   IS_REPEAT .. event is a repeat event.
  */
 #define DEFAULT 0
 #define DONT_PROCESS 1
-#define IS_REPEAT 2
 int
-UpdateDeviceState(DeviceIntPtr device, xEvent* xE, int count)
+UpdateDeviceState(DeviceIntPtr device, DeviceEvent* event)
 {
     int i;
     int key = 0,
-        bit = 0;
+        bit = 0,
+        last_valuator;
 
     KeyClassPtr k       = NULL;
     ButtonClassPtr b    = NULL;
     ValuatorClassPtr v  = NULL;
-    deviceValuator *xV  = (deviceValuator *) xE;
     BYTE *kptr          = NULL;
-    CARD16 modifiers    = 0,
-           mask         = 0;
 
-    /* currently no other generic event modifies the device */
-    if (xE->u.u.type == GenericEvent)
-        return DEFAULT;
+    /* This event is always the first we get, before the actual events with
+     * the data. However, the way how the DDX is set up, "device" will
+     * actually be the slave device that caused the event.
+     */
+    switch(event->type)
+    {
+        case ET_DeviceChanged:
+            ChangeMasterDeviceClasses(device, (DeviceChangedEvent*)event);
+            return DONT_PROCESS; /* event has been sent already */
+        case ET_Motion:
+        case ET_ButtonPress:
+        case ET_ButtonRelease:
+        case ET_KeyPress:
+        case ET_KeyRelease:
+        case ET_ProximityIn:
+        case ET_ProximityOut:
+            break;
+        default:
+            /* other events don't update the device */
+            return DEFAULT;
+    }
 
     k = device->key;
     v = device->valuator;
     b = device->button;
 
+    key = event->detail.key;
+    bit = 1 << (key & 7);
 
-    if (xE->u.u.type != DeviceValuator)
+    /* Update device axis */
+    /* Check valuators first */
+    last_valuator = -1;
+    for (i = 0; i < MAX_VALUATORS; i++)
     {
-        key = xE->u.u.detail;
-        bit = 1 << (key & 7);
+        if (BitIsOn(&event->valuators.mask, i))
+        {
+            if (!v)
+            {
+                ErrorF("[Xi] Valuators reported for non-valuator device '%s'. "
+                        "Ignoring event.\n", device->name);
+                return DONT_PROCESS;
+            } else if (v->numAxes < i)
+            {
+                ErrorF("[Xi] Too many valuators reported for device '%s'. "
+                        "Ignoring event.\n", device->name);
+                return DONT_PROCESS;
+            }
+            last_valuator = i;
+        }
     }
 
-    /* Update device axis */
-    /* Don't update valuators for the VCP, it never sends XI events anyway */
-    for (i = 1; !device->isMaster && i < count; i++) {
-	if ((++xV)->type == DeviceValuator) {
-	    int *axisvals;
-            int first = xV->first_valuator;
-            BOOL change = FALSE;
-
-
-	    if (xV->num_valuators &&
-                (!v || (xV->num_valuators &&
-                      (first + xV->num_valuators > v->numAxes))))
-		FatalError("Bad valuators reported for device %s\n",
-			   device->name);
-	    if (v && v->axisVal) {
-                /* v->axisVal is always in absolute coordinates. Only the
-                 * delivery mode changes.
-                 * If device is mode Absolute
-                 *     dev = event
-                 * If device is mode Relative
-                 *      swap = (event - device)
-                 *      dev = event
-                 *      event = delta
-                 */
-                int delta;
-                axisvals = v->axisVal;
-                if (v->mode == Relative) /* device reports relative */
-                    change = TRUE;
-
-                switch (xV->num_valuators) {
-                    case 6:
-                        if (change) delta = xV->valuator5 - *(axisvals + first + 5);
-                        *(axisvals + first + 5) = xV->valuator5;
-                        if (change) xV->valuator5 = delta;
-                    case 5:
-                        if (change) delta = xV->valuator4 - *(axisvals + first + 4);
-                        *(axisvals + first + 4) = xV->valuator4;
-                        if (change) xV->valuator4 = delta;
-                    case 4:
-                        if (change) delta = xV->valuator3 - *(axisvals + first + 3);
-                        *(axisvals + first + 3) = xV->valuator3;
-                        if (change) xV->valuator3 = delta;
-                    case 3:
-                        if (change) delta = xV->valuator2 - *(axisvals + first + 2);
-                        *(axisvals + first + 2) = xV->valuator2;
-                        if (change) xV->valuator2 = delta;
-                    case 2:
-                        if (change) delta = xV->valuator1 - *(axisvals + first + 1);
-                        *(axisvals + first + 1) = xV->valuator1;
-                        if (change) xV->valuator1 = delta;
-                    case 1:
-                        if (change) delta = xV->valuator0 - *(axisvals + first);
-                        *(axisvals + first) = xV->valuator0;
-                        if (change) xV->valuator0 = delta;
-                    case 0:
-                    default:
-                        break;
-                }
-	    }
-	}
+    for (i = 0; i <= last_valuator && i < v->numAxes; i++)
+    {
+        if (BitIsOn(&event->valuators.mask, i))
+        {
+            /* XXX: Relative/Absolute mode */
+            v->axisVal[i] = event->valuators.data[i];
+            v->axisVal[i] += event->valuators.data_frac[i];
+        }
     }
 
-    if (xE->u.u.type == DeviceKeyPress) {
+    if (event->type == ET_KeyPress) {
         if (!k)
             return DONT_PROCESS;
 
-	modifiers = k->modifierMap[key];
 	kptr = &k->down[key >> 3];
-	if (*kptr & bit) {	/* allow ddx to generate multiple downs */
-	    return IS_REPEAT;
-	}
+        /* don't allow ddx to generate multiple downs, but repeats are okay */
+	if ((*kptr & bit) && !event->key_repeat)
+	    return DONT_PROCESS;
 	if (device->valuator)
 	    device->valuator->motionHintWindow = NullWindow;
 	*kptr |= bit;
-	k->prev_state = k->state;
-	for (i = 0, mask = 1; modifiers; i++, mask <<= 1) {
-	    if (mask & modifiers) {
-		/* This key affects modifier "i" */
-		k->modifierKeyCount[i]++;
-		k->state |= mask;
-		modifiers &= ~mask;
-	    }
-	}
-    } else if (xE->u.u.type == DeviceKeyRelease) {
+    } else if (event->type == ET_KeyRelease) {
         if (!k)
             return DONT_PROCESS;
 
 	kptr = &k->down[key >> 3];
 	if (!(*kptr & bit))	/* guard against duplicates */
 	    return DONT_PROCESS;
-	modifiers = k->modifierMap[key];
 	if (device->valuator)
 	    device->valuator->motionHintWindow = NullWindow;
 	*kptr &= ~bit;
-	k->prev_state = k->state;
-	for (i = 0, mask = 1; modifiers; i++, mask <<= 1) {
-	    if (mask & modifiers) {
-		/* This key affects modifier "i" */
-		if (--k->modifierKeyCount[i] <= 0) {
-		    k->modifierKeyCount[i] = 0;
-		    k->state &= ~mask;
-		}
-		modifiers &= ~mask;
-	    }
-	}
-    } else if (xE->u.u.type == DeviceButtonPress) {
+    } else if (event->type == ET_ButtonPress) {
+        Mask mask;
         if (!b)
             return DONT_PROCESS;
 
@@ -903,15 +849,21 @@ UpdateDeviceState(DeviceIntPtr device, xEvent* xE, int count)
 	b->motionMask = DeviceButtonMotionMask;
         if (b->map[key] <= 5)
 	    b->state |= (Button1Mask >> 1) << b->map[key];
-	SetMaskForEvent(device->id, Motion_Filter(b), DeviceMotionNotify);
-    } else if (xE->u.u.type == DeviceButtonRelease) {
+
+        /* Add state and motionMask to the filter for this event */
+        mask = DevicePointerMotionMask | b->state | b->motionMask;
+        SetMaskForEvent(device->id, mask, DeviceMotionNotify);
+        mask = PointerMotionMask | b->state | b->motionMask;
+        SetMaskForEvent(device->id, mask, MotionNotify);
+    } else if (event->type == ET_ButtonRelease) {
+        Mask mask;
         if (!b)
             return DONT_PROCESS;
 
         kptr = &b->down[key>>3];
         if (!(*kptr & bit))
             return DONT_PROCESS;
-        if (device->isMaster) {
+        if (IsMaster(device)) {
             DeviceIntPtr sd;
 
             /*
@@ -920,7 +872,9 @@ UpdateDeviceState(DeviceIntPtr device, xEvent* xE, int count)
              * event being delivered through the slave first
              */
             for (sd = inputInfo.devices; sd; sd = sd->next) {
-                if (sd->isMaster || sd->u.master != device)
+                if (IsMaster(sd) || sd->u.master != device)
+                    continue;
+                if (!sd->button)
                     continue;
                 if ((sd->button->down[key>>3] & bit) != 0)
                     return DONT_PROCESS;
@@ -935,35 +889,76 @@ UpdateDeviceState(DeviceIntPtr device, xEvent* xE, int count)
 	    b->motionMask = 0;
 	if (b->map[key] <= 5)
 	    b->state &= ~((Button1Mask >> 1) << b->map[key]);
-	SetMaskForEvent(device->id, Motion_Filter(b), DeviceMotionNotify);
-    } else if (xE->u.u.type == ProximityIn)
+
+        /* Add state and motionMask to the filter for this event */
+        mask = DevicePointerMotionMask | b->state | b->motionMask;
+        SetMaskForEvent(device->id, mask, DeviceMotionNotify);
+        mask = PointerMotionMask | b->state | b->motionMask;
+        SetMaskForEvent(device->id, mask, MotionNotify);
+    } else if (event->type == ET_ProximityIn)
 	device->valuator->mode &= ~OutOfProximity;
-    else if (xE->u.u.type == ProximityOut)
+    else if (event->type == ET_ProximityOut)
 	device->valuator->mode |= OutOfProximity;
 
     return DEFAULT;
 }
 
+static void
+ProcessRawEvent(RawDeviceEvent *ev, DeviceIntPtr device)
+{
+    GrabPtr grab = device->deviceGrab.grab;
+
+    if (grab)
+        DeliverGrabbedEvent((InternalEvent*)ev, device, FALSE);
+    else { /* deliver to all root windows */
+        xEvent *xi;
+        int i;
+
+        i = EventToXI2((InternalEvent*)ev, (xEvent**)&xi);
+        if (i != Success)
+        {
+            ErrorF("[Xi] %s: XI2 conversion failed in ProcessRawEvent (%d)\n",
+                    device->name, i);
+            return;
+        }
+
+        for (i = 0; i < screenInfo.numScreens; i++)
+            DeliverEventsToWindow(device, WindowTable[i], xi, 1,
+                                  GetEventFilter(device, xi), NULL);
+        xfree(xi);
+    }
+}
+
 /**
  * Main device event processing function.
  * Called from when processing the events from the event queue.
  *
  */
 void
-ProcessOtherEvent(xEventPtr xE, DeviceIntPtr device, int count)
+ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device)
 {
-    int i;
-    CARD16 modifiers;
-    GrabPtr grab = device->deviceGrab.grab;
+    GrabPtr grab;
     Bool deactivateDeviceGrab = FALSE;
     int key = 0, rootX, rootY;
     ButtonClassPtr b;
     KeyClassPtr k;
     ValuatorClassPtr v;
-    deviceValuator *xV  = (deviceValuator *) xE;
     int ret = 0;
-    int state;
+    int state, i;
     DeviceIntPtr mouse = NULL, kbd = NULL;
+    DeviceEvent *event = (DeviceEvent*)ev;
+
+    CHECKEVENT(ev);
+
+    if (ev->any.type == ET_RawKeyPress ||
+        ev->any.type == ET_RawKeyRelease ||
+        ev->any.type == ET_RawButtonPress ||
+        ev->any.type == ET_RawButtonRelease ||
+        ev->any.type == ET_RawMotion)
+    {
+        ProcessRawEvent((RawDeviceEvent*)ev, device);
+        return;
+    }
 
     if (IsPointerDevice(device))
     {
@@ -980,10 +975,34 @@ ProcessOtherEvent(xEventPtr xE, DeviceIntPtr device, int count)
     }
 
     /* State needs to be assembled BEFORE the device is updated. */
-    state = (kbd) ? kbd->key->state : 0;
-    state |= (mouse) ? (mouse->button->state) : 0;
+    state = (kbd && kbd->key) ? XkbStateFieldFromRec(&kbd->key->xkbInfo->state) : 0;
+    state |= (mouse && mouse->button) ? (mouse->button->state) : 0;
+
+    for (i = 0; mouse && mouse->button && i < mouse->button->numButtons; i++)
+        if (BitIsOn(mouse->button->down, i))
+            SetBit(event->buttons, i);
 
-    ret = UpdateDeviceState(device, xE, count);
+    if (kbd && kbd->key)
+    {
+        XkbStatePtr state;
+        /* we need the state before the event happens */
+        if (event->type == ET_KeyPress || event->type == ET_KeyRelease)
+            state = &kbd->key->xkbInfo->prev_state;
+        else
+            state = &kbd->key->xkbInfo->state;
+
+        event->mods.base = state->base_mods;
+        event->mods.latched = state->latched_mods;
+        event->mods.locked = state->locked_mods;
+        event->mods.effective = state->mods;
+
+        event->group.base = state->base_group;
+        event->group.latched = state->latched_group;
+        event->group.locked = state->locked_group;
+        event->group.effective = state->group;
+    }
+
+    ret = UpdateDeviceState(device, event);
     if (ret == DONT_PROCESS)
         return;
 
@@ -991,19 +1010,31 @@ ProcessOtherEvent(xEventPtr xE, DeviceIntPtr device, int count)
     b = device->button;
     k = device->key;
 
-    if (device->isMaster)
-        CheckMotion(xE, device);
-
-    if (xE->u.u.type != DeviceValuator && xE->u.u.type != GenericEvent) {
-	GetSpritePosition(device, &rootX, &rootY);
-	xE->u.keyButtonPointer.rootX = rootX;
-	xE->u.keyButtonPointer.rootY = rootY;
-	NoticeEventTime(xE);
+    if (IsMaster(device) || !device->u.master)
+        CheckMotion(event, device);
 
-        xE->u.keyButtonPointer.state = state;
-
-        key = xE->u.u.detail;
+    switch (event->type)
+    {
+        case ET_Motion:
+        case ET_ButtonPress:
+        case ET_ButtonRelease:
+        case ET_KeyPress:
+        case ET_KeyRelease:
+        case ET_ProximityIn:
+        case ET_ProximityOut:
+            GetSpritePosition(device, &rootX, &rootY);
+            event->root_x = rootX;
+            event->root_y = rootY;
+            NoticeEventTime((InternalEvent*)event);
+            event->corestate = state;
+            key = event->detail.key;
+            break;
+        default:
+            break;
     }
+
+#if 0
+    /* FIXME: I'm broken. Please fix me. Thanks */
     if (DeviceEventCallback) {
 	DeviceEventInfoRec eventinfo;
 
@@ -1011,84 +1042,70 @@ ProcessOtherEvent(xEventPtr xE, DeviceIntPtr device, int count)
 	eventinfo.count = count;
 	CallCallbacks(&DeviceEventCallback, (pointer) & eventinfo);
     }
+#endif
+    grab = device->deviceGrab.grab;
 
-    /* Valuator event handling */
-    /* Don't care about valuators for the VCP, it never sends XI events */
-
-    for (i = 1; !device->isMaster && i < count; i++) {
-	if ((++xV)->type == DeviceValuator) {
-	    int first = xV->first_valuator;
-	    if (xV->num_valuators
-		&& (!v
-		    || (xV->num_valuators
-			&& (first + xV->num_valuators > v->numAxes))))
-		FatalError("Bad valuators reported for device %s\n",
-			   device->name);
-	    xV->device_state = 0;
-	    if (k)
-		xV->device_state |= k->state;
-	    if (b)
-		xV->device_state |= b->state;
-	}
+    switch(event->type)
+    {
+        case ET_KeyPress:
+            if (!grab && CheckDeviceGrabs(device, event, 0)) {
+                device->deviceGrab.activatingKey = key;
+                return;
+            }
+            break;
+        case ET_KeyRelease:
+            if (grab && device->deviceGrab.fromPassiveGrab &&
+                (key == device->deviceGrab.activatingKey) &&
+                (device->deviceGrab.grab->type == KeyPress ||
+                 device->deviceGrab.grab->type == DeviceKeyPress ||
+                 device->deviceGrab.grab->type == XI_KeyPress))
+                deactivateDeviceGrab = TRUE;
+            break;
+        case ET_ButtonPress:
+            event->detail.button = b->map[key];
+            if (!event->detail.button) { /* there's no button 0 */
+                event->detail.button = key;
+                return;
+            }
+            if (!grab && CheckDeviceGrabs(device, event, 0))
+            {
+                /* if a passive grab was activated, the event has been sent
+                 * already */
+                return;
+            }
+            break;
+        case ET_ButtonRelease:
+            event->detail.button = b->map[key];
+            if (!event->detail.button) { /* there's no button 0 */
+                event->detail.button = key;
+                return;
+            }
+            if (grab && !b->buttonsDown &&
+                device->deviceGrab.fromPassiveGrab &&
+                (device->deviceGrab.grab->type == ButtonPress ||
+                 device->deviceGrab.grab->type == DeviceButtonPress ||
+                 device->deviceGrab.grab->type == XI_ButtonPress))
+                deactivateDeviceGrab = TRUE;
+        default:
+            break;
     }
 
-    if (xE->u.u.type == DeviceKeyPress) {
-        if (ret == IS_REPEAT) {	/* allow ddx to generate multiple downs */
-            modifiers = k->modifierMap[key];
-	    if (!modifiers) {
-		xE->u.u.type = DeviceKeyRelease;
-		ProcessOtherEvent(xE, device, count);
-		xE->u.u.type = DeviceKeyPress;
-		/* release can have side effects, don't fall through */
-		ProcessOtherEvent(xE, device, count);
-	    }
-	    return;
-	}
-	if (!grab && CheckDeviceGrabs(device, xE, 0, count)) {
-	    device->deviceGrab.activatingKey = key;
-	    return;
-	}
-    } else if (xE->u.u.type == DeviceKeyRelease) {
-	if (device->deviceGrab.fromPassiveGrab &&
-            (key == device->deviceGrab.activatingKey))
-	    deactivateDeviceGrab = TRUE;
-    } else if (xE->u.u.type == DeviceButtonPress) {
-	xE->u.u.detail = b->map[key];
-	if (xE->u.u.detail == 0) {
-	    xE->u.u.detail = key;
-	    return;
-	}
-        if (!grab && CheckDeviceGrabs(device, xE, 0, count))
-        {
-            /* if a passive grab was activated, the event has been sent
-             * already */
-            return;
-        }
-
-    } else if (xE->u.u.type == DeviceButtonRelease) {
-	xE->u.u.detail = b->map[key];
-	if (xE->u.u.detail == 0) {
-	    xE->u.u.detail = key;
-	    return;
-	}
-        if (!b->buttonsDown && device->deviceGrab.fromPassiveGrab)
-            deactivateDeviceGrab = TRUE;
-    }
 
     if (grab)
-        DeliverGrabbedEvent(xE, device, deactivateDeviceGrab, count);
-    else if (device->focus && !IsPointerEvent(xE))
-	DeliverFocusedEvent(device, xE, GetSpriteWindow(device), count);
+        DeliverGrabbedEvent((InternalEvent*)event, device, deactivateDeviceGrab);
+    else if (device->focus && !IsPointerEvent((InternalEvent*)ev))
+        DeliverFocusedEvent(device, (InternalEvent*)event,
+                            GetSpriteWindow(device));
     else
-	DeliverDeviceEvents(GetSpriteWindow(device), xE, NullGrab, NullWindow,
-			    device, count);
+        DeliverDeviceEvents(GetSpriteWindow(device), (InternalEvent*)event,
+                            NullGrab, NullWindow, device);
 
     if (deactivateDeviceGrab == TRUE)
 	(*device->deviceGrab.DeactivateGrab) (device);
-    xE->u.u.detail = key;
+    event->detail.key = key;
 }
 
-_X_EXPORT int
+int
 InitProximityClassDeviceStruct(DeviceIntPtr dev)
 {
     ProximityClassPtr proxc;
@@ -1096,6 +1113,7 @@ InitProximityClassDeviceStruct(DeviceIntPtr dev)
     proxc = (ProximityClassPtr) xalloc(sizeof(ProximityClassRec));
     if (!proxc)
 	return FALSE;
+    proxc->sourceid = dev->id;
     dev->proximity = proxc;
     return TRUE;
 }
@@ -1109,14 +1127,16 @@ InitProximityClassDeviceStruct(DeviceIntPtr dev)
  *
  * @see InitValuatorClassDeviceStruct
  */
-_X_EXPORT void
-InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, int minval, int maxval,
+void
+InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval, int maxval,
 		       int resolution, int min_res, int max_res)
 {
     AxisInfoPtr ax;
 
     if (!dev || !dev->valuator || minval > maxval)
         return;
+    if (axnum >= dev->valuator->numAxes)
+        return;
 
     ax = dev->valuator->axes + axnum;
 
@@ -1125,6 +1145,7 @@ InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, int minval, int maxval,
     ax->resolution = resolution;
     ax->min_resolution = min_res;
     ax->max_resolution = max_res;
+    ax->label = label;
 }
 
 static void
@@ -1145,7 +1166,8 @@ FixDeviceStateNotify(DeviceIntPtr dev, deviceStateNotify * ev, KeyClassPtr k,
 	memcpy((char*)ev->buttons, (char*)b->down, 4);
     } else if (k) {
 	ev->classes_reported |= (1 << KeyClass);
-	ev->num_keys = k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode;
+	ev->num_keys = k->xkbInfo->desc->max_key_code -
+                       k->xkbInfo->desc->min_key_code;
 	memmove((char *)&ev->keys[0], (char *)k->down, 4);
     }
     if (v) {
@@ -1193,21 +1215,65 @@ DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
 		 WindowPtr pWin)
 {
     deviceFocus event;
+    xXIFocusInEvent *xi2event;
+    DeviceIntPtr mouse;
+    int btlen, len, i;
+
+    mouse = (IsMaster(dev) || dev->u.master) ? GetMaster(dev, MASTER_POINTER) : dev;
+
+    /* XI 2 event */
+    btlen = (mouse->button) ? bits_to_bytes(mouse->button->numButtons) : 0;
+    btlen = bytes_to_int32(btlen);
+    len = sizeof(xXIFocusInEvent) + btlen * 4;
+
+    xi2event = xcalloc(1, len);
+    xi2event->type         = GenericEvent;
+    xi2event->extension    = IReqCode;
+    xi2event->evtype       = type;
+    xi2event->length       = bytes_to_int32(len - sizeof(xEvent));
+    xi2event->buttons_len  = btlen;
+    xi2event->detail       = detail;
+    xi2event->time         = currentTime.milliseconds;
+    xi2event->deviceid     = dev->id;
+    xi2event->sourceid     = dev->id; /* a device doesn't change focus by itself */
+    xi2event->mode         = mode;
+    xi2event->root_x       = FP1616(mouse->spriteInfo->sprite->hot.x, 0);
+    xi2event->root_y       = FP1616(mouse->spriteInfo->sprite->hot.y, 0);
+
+    for (i = 0; mouse && mouse->button && i < mouse->button->numButtons; i++)
+        if (BitIsOn(mouse->button->down, i))
+            SetBit(&xi2event[1], i);
+
+    if (dev->key)
+    {
+        xi2event->mods.base_mods = dev->key->xkbInfo->state.base_mods;
+        xi2event->mods.latched_mods = dev->key->xkbInfo->state.latched_mods;
+        xi2event->mods.locked_mods = dev->key->xkbInfo->state.locked_mods;
+        xi2event->mods.effective_mods = dev->key->xkbInfo->state.mods;
+
+        xi2event->group.base_group = dev->key->xkbInfo->state.base_group;
+        xi2event->group.latched_group = dev->key->xkbInfo->state.latched_group;
+        xi2event->group.locked_group = dev->key->xkbInfo->state.locked_group;
+        xi2event->group.effective_group = dev->key->xkbInfo->state.group;
+    }
 
-    if (type == FocusIn)
-	type = DeviceFocusIn;
-    else
-	type = DeviceFocusOut;
+    FixUpEventFromWindow(dev, (xEvent*)xi2event, pWin, None, FALSE);
+
+    DeliverEventsToWindow(dev, pWin, (xEvent*)xi2event, 1,
+                          GetEventFilter(dev, (xEvent*)xi2event), NullGrab);
 
+    xfree(xi2event);
+
+    /* XI 1.x event */
     event.deviceid = dev->id;
     event.mode = mode;
-    event.type = type;
+    event.type = (type == XI_FocusIn) ? DeviceFocusIn : DeviceFocusOut;
     event.detail = detail;
     event.window = pWin->drawable.id;
     event.time = currentTime.milliseconds;
 
-    (void)DeliverEventsToWindow(dev, pWin, (xEvent *) & event, 1,
-				DeviceFocusChangeMask, NullGrab, dev->id);
+    DeliverEventsToWindow(dev, pWin, (xEvent *) & event, 1,
+				DeviceFocusChangeMask, NullGrab);
 
     if ((type == DeviceFocusIn) &&
 	(wOtherInputMasks(pWin)) &&
@@ -1229,7 +1295,8 @@ DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
 		evcount++;
 	}
 	if ((k = dev->key) != NULL) {
-	    nkeys = k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode;
+	    nkeys = k->xkbInfo->desc->max_key_code -
+                    k->xkbInfo->desc->min_key_code;
 	    if (nkeys > 32)
 		evcount++;
 	    if (nbuttons > 0) {
@@ -1302,147 +1369,203 @@ DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
 	    }
 	}
 
-	(void)DeliverEventsToWindow(dev, pWin, (xEvent *) sev, evcount,
-				    DeviceStateNotifyMask, NullGrab, dev->id);
+	DeliverEventsToWindow(dev, pWin, (xEvent *) sev, evcount,
+				    DeviceStateNotifyMask, NullGrab);
 	xfree(sev);
     }
 }
 
 int
-GrabButton(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
-	   BYTE other_devices_mode, CARD16 modifiers,
-	   DeviceIntPtr modifier_device, CARD8 button, Window grabWindow,
-	   BOOL ownerEvents, Cursor rcursor, Window rconfineTo, Mask eventMask)
+CheckGrabValues(ClientPtr client, GrabParameters* param)
 {
-    WindowPtr pWin, confineTo;
-    CursorPtr cursor;
-    GrabPtr grab;
-    Mask access_mode = DixGrabAccess;
-    int rc;
+    if (param->grabtype != GRABTYPE_CORE &&
+        param->grabtype != GRABTYPE_XI &&
+        param->grabtype != GRABTYPE_XI2)
+    {
+        ErrorF("[Xi] grabtype is invalid. This is a bug.\n");
+        return BadImplementation;
+    }
 
-    if ((this_device_mode != GrabModeSync) &&
-	(this_device_mode != GrabModeAsync)) {
-	client->errorValue = this_device_mode;
+    if ((param->this_device_mode != GrabModeSync) &&
+	(param->this_device_mode != GrabModeAsync)) {
+	client->errorValue = param->this_device_mode;
 	return BadValue;
     }
-    if ((other_devices_mode != GrabModeSync) &&
-	(other_devices_mode != GrabModeAsync)) {
-	client->errorValue = other_devices_mode;
+    if ((param->other_devices_mode != GrabModeSync) &&
+	(param->other_devices_mode != GrabModeAsync)) {
+	client->errorValue = param->other_devices_mode;
 	return BadValue;
     }
-    if ((modifiers != AnyModifier) && (modifiers & ~AllModifiersMask)) {
-	client->errorValue = modifiers;
+
+    if (param->grabtype != GRABTYPE_XI2 && (param->modifiers != AnyModifier) &&
+        (param->modifiers & ~AllModifiersMask)) {
+	client->errorValue = param->modifiers;
 	return BadValue;
     }
-    if ((ownerEvents != xFalse) && (ownerEvents != xTrue)) {
-	client->errorValue = ownerEvents;
+
+    if ((param->ownerEvents != xFalse) && (param->ownerEvents != xTrue)) {
+	client->errorValue = param->ownerEvents;
 	return BadValue;
     }
-    rc = dixLookupWindow(&pWin, grabWindow, client, DixSetAttrAccess);
+    return Success;
+}
+
+int
+GrabButton(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr modifier_device,
+           int button, GrabParameters *param, GrabType grabtype,
+	   GrabMask *mask)
+{
+    WindowPtr pWin, confineTo;
+    CursorPtr cursor;
+    GrabPtr grab;
+    int rc, type = -1;
+    Mask access_mode = DixGrabAccess;
+
+    rc = CheckGrabValues(client, param);
     if (rc != Success)
 	return rc;
-    if (rconfineTo == None)
+    if (param->confineTo == None)
 	confineTo = NullWindow;
     else {
-	rc = dixLookupWindow(&confineTo, rconfineTo, client, DixSetAttrAccess);
+	rc = dixLookupWindow(&confineTo, param->confineTo, client, DixSetAttrAccess);
 	if (rc != Success)
 	    return rc;
     }
-    if (rcursor == None)
+    if (param->cursor == None)
 	cursor = NullCursor;
     else {
-	rc = dixLookupResourceByType((pointer *)&cursor, rcursor, RT_CURSOR,
-			       client, DixUseAccess);
+	rc = dixLookupResourceByType((pointer *)&cursor, param->cursor,
+				     RT_CURSOR, client, DixUseAccess);
 	if (rc != Success)
 	{
-	    client->errorValue = rcursor;
+	    client->errorValue = param->cursor;
 	    return (rc == BadValue) ? BadCursor : rc;
 	}
 	access_mode |= DixForceAccess;
     }
-    if (this_device_mode == GrabModeSync || other_devices_mode == GrabModeSync)
+    if (param->this_device_mode == GrabModeSync || param->other_devices_mode == GrabModeSync)
 	access_mode |= DixFreezeAccess;
     rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, access_mode);
     if (rc != Success)
 	return rc;
+    rc = dixLookupWindow(&pWin, param->grabWindow, client, DixSetAttrAccess);
+    if (rc != Success)
+	return rc;
 
-    grab = CreateGrab(client->index, dev, pWin, eventMask,
-		      (Bool) ownerEvents, (Bool) this_device_mode,
-		      (Bool) other_devices_mode, modifier_device, modifiers,
-		      DeviceButtonPress, button, confineTo, cursor);
+    if (grabtype == GRABTYPE_XI)
+        type = DeviceButtonPress;
+    else if (grabtype == GRABTYPE_XI2)
+        type = XI_ButtonPress;
+
+    grab = CreateGrab(client->index, dev, modifier_device, pWin, grabtype,
+                      mask, param, type, button, confineTo, cursor);
     if (!grab)
 	return BadAlloc;
     return AddPassiveGrabToList(client, grab);
 }
 
+/**
+ * Grab the given key. If grabtype is GRABTYPE_XI, the key is a keycode. If
+ * grabtype is GRABTYPE_XI2, the key is a keysym.
+ */
 int
-GrabKey(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
-	BYTE other_devices_mode, CARD16 modifiers,
-	DeviceIntPtr modifier_device, CARD8 key, Window grabWindow,
-	BOOL ownerEvents, Mask mask)
+GrabKey(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr modifier_device,
+        int key, GrabParameters *param, GrabType grabtype, GrabMask *mask)
 {
     WindowPtr pWin;
     GrabPtr grab;
     KeyClassPtr k = dev->key;
     Mask access_mode = DixGrabAccess;
-    int rc;
+    int rc, type = -1;
 
+    rc = CheckGrabValues(client, param);
+    if (rc != Success)
+        return rc;
     if (k == NULL)
 	return BadMatch;
-    if ((other_devices_mode != GrabModeSync) &&
-	(other_devices_mode != GrabModeAsync)) {
-	client->errorValue = other_devices_mode;
-	return BadValue;
-    }
-    if ((this_device_mode != GrabModeSync) &&
-	(this_device_mode != GrabModeAsync)) {
-	client->errorValue = this_device_mode;
-	return BadValue;
-    }
-    if (((key > k->curKeySyms.maxKeyCode) || (key < k->curKeySyms.minKeyCode))
-	&& (key != AnyKey)) {
-	client->errorValue = key;
-	return BadValue;
-    }
-    if ((modifiers != AnyModifier) && (modifiers & ~AllModifiersMask)) {
-	client->errorValue = modifiers;
-	return BadValue;
-    }
-    if ((ownerEvents != xTrue) && (ownerEvents != xFalse)) {
-	client->errorValue = ownerEvents;
-	return BadValue;
-    }
-    rc = dixLookupWindow(&pWin, grabWindow, client, DixSetAttrAccess);
+    if (grabtype == GRABTYPE_XI)
+    {
+        if ((key > k->xkbInfo->desc->max_key_code ||
+                    key < k->xkbInfo->desc->min_key_code)
+                && (key != AnyKey)) {
+            client->errorValue = key;
+            return BadValue;
+        }
+        type = DeviceKeyPress;
+    } else if (grabtype == GRABTYPE_XI2)
+        type = XI_KeyPress;
+
+    rc = dixLookupWindow(&pWin, param->grabWindow, client, DixSetAttrAccess);
     if (rc != Success)
 	return rc;
-    if (this_device_mode == GrabModeSync || other_devices_mode == GrabModeSync)
+    if (param->this_device_mode == GrabModeSync || param->other_devices_mode == GrabModeSync)
 	access_mode |= DixFreezeAccess;
     rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, access_mode);
     if (rc != Success)
 	return rc;
 
-    grab = CreateGrab(client->index, dev, pWin,
-		      mask, ownerEvents, this_device_mode, other_devices_mode,
-		      modifier_device, modifiers, DeviceKeyPress, key,
-		      NullWindow, NullCursor);
+    grab = CreateGrab(client->index, dev, modifier_device, pWin, grabtype,
+                      mask, param, type, key, NULL, NULL);
     if (!grab)
 	return BadAlloc;
     return AddPassiveGrabToList(client, grab);
 }
 
+/* Enter/FocusIn grab */
+int
+GrabWindow(ClientPtr client, DeviceIntPtr dev, int type,
+           GrabParameters *param, GrabMask *mask)
+{
+    WindowPtr pWin;
+    CursorPtr cursor;
+    GrabPtr grab;
+    Mask access_mode = DixGrabAccess;
+    int rc;
+
+    rc = CheckGrabValues(client, param);
+    if (rc != Success)
+        return rc;
+
+    rc = dixLookupWindow(&pWin, param->grabWindow, client, DixSetAttrAccess);
+    if (rc != Success)
+	return rc;
+    if (param->cursor == None)
+	cursor = NullCursor;
+    else {
+	rc = dixLookupResourceByType((pointer *)&cursor, param->cursor,
+				     RT_CURSOR, client, DixUseAccess);
+	if (rc != Success)
+	{
+	    client->errorValue = param->cursor;
+	    return (rc == BadValue) ? BadCursor : rc;
+	}
+	access_mode |= DixForceAccess;
+    }
+    if (param->this_device_mode == GrabModeSync || param->other_devices_mode == GrabModeSync)
+	access_mode |= DixFreezeAccess;
+    rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, access_mode);
+    if (rc != Success)
+	return rc;
+
+    grab = CreateGrab(client->index, dev, dev, pWin, GRABTYPE_XI2,
+                      mask, param, (type == XIGrabtypeEnter) ? XI_Enter : XI_FocusIn,
+                      0, NULL, cursor);
+
+    if (!grab)
+        return BadAlloc;
+
+    return AddPassiveGrabToList(client, grab);
+}
+
 int
 SelectForWindow(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client,
-		Mask mask, Mask exclusivemasks, Mask validmasks)
+		Mask mask, Mask exclusivemasks)
 {
     int mskidx = dev->id;
     int i, ret;
     Mask check;
     InputClientsPtr others;
 
-    if (mask & ~validmasks) {
-	client->errorValue = mask;
-	return BadValue;
-    }
     check = (mask & exclusivemasks);
     if (wOtherInputMasks(pWin)) {
 	if (check & wOtherInputMasks(pWin)->inputEvents[mskidx]) {	/* It is illegal for two different
@@ -1530,15 +1653,20 @@ RecalculateDeviceDeliverableEvents(WindowPtr pWin)
     InputClientsPtr others;
     struct _OtherInputMasks *inputMasks;	/* default: NULL */
     WindowPtr pChild, tmp;
-    int i;
+    int i, j;
 
     pChild = pWin;
     while (1) {
 	if ((inputMasks = wOtherInputMasks(pChild)) != 0) {
+            for (i = 0; i < EMASKSIZE; i++)
+                memset(inputMasks->xi2mask[i], 0, sizeof(inputMasks->xi2mask[i]));
 	    for (others = inputMasks->inputClients; others;
 		 others = others->next) {
 		for (i = 0; i < EMASKSIZE; i++)
 		    inputMasks->inputEvents[i] |= others->mask[i];
+                for (i = 0; i < EMASKSIZE; i++)
+                    for (j = 0; j < XI2MASKSIZE; j++)
+                        inputMasks->xi2mask[i][j] |= others->xi2mask[i][j];
 	    }
 	    for (i = 0; i < EMASKSIZE; i++)
 		inputMasks->deliverableEvents[i] = inputMasks->inputEvents[i];
@@ -1646,7 +1774,7 @@ SendEvent(ClientPtr client, DeviceIntPtr d, Window dest, Bool propagate,
     ev->u.u.type |= 0x80;
     if (propagate) {
 	for (; pWin; pWin = pWin->parent) {
-	    if (DeliverEventsToWindow(d, pWin, ev, count, mask, NullGrab, d->id))
+	    if (DeliverEventsToWindow(d, pWin, ev, count, mask, NullGrab))
 		return Success;
 	    if (pWin == effectiveFocus)
 		return Success;
@@ -1656,7 +1784,7 @@ SendEvent(ClientPtr client, DeviceIntPtr d, Window dest, Bool propagate,
 		break;
 	}
     } else if (!XaceHook(XACE_SEND_ACCESS, client, NULL, pWin, ev, count))
-	(void)(DeliverEventsToWindow(d, pWin, ev, count, mask, NullGrab, d->id));
+	DeliverEventsToWindow(d, pWin, ev, count, mask, NullGrab);
     return Success;
 }
 
@@ -1684,111 +1812,6 @@ SetButtonMapping(ClientPtr client, DeviceIntPtr dev, int nElts, BYTE * map)
 }
 
 int
-SetModifierMapping(ClientPtr client, DeviceIntPtr dev, int len, int rlen,
-		   int numKeyPerModifier, KeyCode * inputMap, KeyClassPtr * k)
-{
-    KeyCode *map = NULL;
-    int inputMapLen;
-    int i;
-
-    *k = dev->key;
-    if (*k == NULL)
-	return BadMatch;
-    if (len != ((numKeyPerModifier << 1) + rlen))
-	return BadLength;
-
-    inputMapLen = 8 * numKeyPerModifier;
-
-    /*
-     *  Now enforce the restriction that "all of the non-zero keycodes must be
-     *  in the range specified by min-keycode and max-keycode in the
-     *  connection setup (else a Value error)"
-     */
-    i = inputMapLen;
-    while (i--) {
-	if (inputMap[i]
-	    && (inputMap[i] < (*k)->curKeySyms.minKeyCode
-		|| inputMap[i] > (*k)->curKeySyms.maxKeyCode)) {
-	    client->errorValue = inputMap[i];
-	    return -1;	/* BadValue collides with MappingFailed */
-	}
-    }
-
-    /*
-     *  Now enforce the restriction that none of the old or new
-     *  modifier keys may be down while we change the mapping,  and
-     *  that the DDX layer likes the choice.
-     */
-    if (!AllModifierKeysAreUp(dev, (*k)->modifierKeyMap,
-			      (int)(*k)->maxKeysPerModifier, inputMap,
-			      (int)numKeyPerModifier)
-	|| !AllModifierKeysAreUp(dev, inputMap, (int)numKeyPerModifier,
-				 (*k)->modifierKeyMap,
-				 (int)(*k)->maxKeysPerModifier)) {
-	return MappingBusy;
-    } else {
-	for (i = 0; i < inputMapLen; i++) {
-	    if (inputMap[i] && !LegalModifier(inputMap[i], dev)) {
-		return MappingFailed;
-	    }
-	}
-    }
-
-    /*
-     *  Now build the keyboard's modifier bitmap from the
-     *  list of keycodes.
-     */
-    if (inputMapLen) {
-	map = (KeyCode *) xalloc(inputMapLen);
-	if (!map)
-	    return BadAlloc;
-    }
-    if ((*k)->modifierKeyMap)
-	xfree((*k)->modifierKeyMap);
-    if (inputMapLen) {
-	(*k)->modifierKeyMap = map;
-	memmove((char *)(*k)->modifierKeyMap, (char *)inputMap, inputMapLen);
-    } else
-	(*k)->modifierKeyMap = NULL;
-
-    (*k)->maxKeysPerModifier = numKeyPerModifier;
-    for (i = 0; i < MAP_LENGTH; i++)
-	(*k)->modifierMap[i] = 0;
-    for (i = 0; i < inputMapLen; i++)
-	if (inputMap[i]) {
-	    (*k)->modifierMap[inputMap[i]]
-		|= (1 << (i / (*k)->maxKeysPerModifier));
-	}
-
-    return (MappingSuccess);
-}
-
-void
-SendDeviceMappingNotify(ClientPtr client, CARD8 request,
-			KeyCode firstKeyCode, CARD8 count, DeviceIntPtr dev)
-{
-    xEvent event;
-    deviceMappingNotify *ev = (deviceMappingNotify *) & event;
-
-    ev->type = DeviceMappingNotify;
-    ev->request = request;
-    ev->deviceid = dev->id;
-    ev->time = currentTime.milliseconds;
-    if (request == MappingKeyboard) {
-	ev->firstKeyCode = firstKeyCode;
-	ev->count = count;
-    }
-
-#ifdef XKB
-    if (!noXkbExtension && (request == MappingKeyboard ||
-                            request == MappingModifier))
-        XkbApplyMappingChange(dev, request, firstKeyCode, count, client);
-#endif
-
-    SendEventToAllWindows(dev, DeviceMappingNotifyMask, (xEvent *) ev, 1);
-}
-
-int
 ChangeKeyMapping(ClientPtr client,
 		 DeviceIntPtr dev,
 		 unsigned len,
@@ -1805,8 +1828,8 @@ ChangeKeyMapping(ClientPtr client,
     if (len != (keyCodes * keySymsPerKeyCode))
 	return BadLength;
 
-    if ((firstKeyCode < k->curKeySyms.minKeyCode) ||
-	(firstKeyCode + keyCodes - 1 > k->curKeySyms.maxKeyCode)) {
+    if ((firstKeyCode < k->xkbInfo->desc->min_key_code) ||
+	(firstKeyCode + keyCodes - 1 > k->xkbInfo->desc->max_key_code)) {
 	client->errorValue = firstKeyCode;
 	return BadValue;
     }
@@ -1818,9 +1841,10 @@ ChangeKeyMapping(ClientPtr client,
     keysyms.maxKeyCode = firstKeyCode + keyCodes - 1;
     keysyms.mapWidth = keySymsPerKeyCode;
     keysyms.map = map;
-    if (!SetKeySymsMap(&k->curKeySyms, &keysyms))
-	return BadAlloc;
-    SendDeviceMappingNotify(client, MappingKeyboard, firstKeyCode, keyCodes, dev);
+
+    XkbApplyMappingChange(dev, &keysyms, firstKeyCode, keyCodes, NULL,
+                          serverClient);
+
     return client->noClientException;
 }
 
@@ -1849,7 +1873,8 @@ DeleteDeviceFromAnyExtEvents(WindowPtr pWin, DeviceIntPtr dev)
 
 	switch (dev->focus->revert) {
 	case RevertToNone:
-	    DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
+	    if (!ActivateFocusInGrab(dev, pWin, NoneWin))
+		DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
 	    dev->focus->win = NoneWin;
 	    dev->focus->traceGood = 0;
 	    break;
@@ -1860,26 +1885,34 @@ DeleteDeviceFromAnyExtEvents(WindowPtr pWin, DeviceIntPtr dev)
 		dev->focus->traceGood--;
 	    }
 	    while (!parent->realized);
-	    DoFocusEvents(dev, pWin, parent, focusEventMode);
+	    if (!ActivateFocusInGrab(dev, pWin, parent))
+		DoFocusEvents(dev, pWin, parent, focusEventMode);
 	    dev->focus->win = parent;
 	    dev->focus->revert = RevertToNone;
 	    break;
 	case RevertToPointerRoot:
-	    DoFocusEvents(dev, pWin, PointerRootWin, focusEventMode);
+	    if (!ActivateFocusInGrab(dev, pWin, PointerRootWin))
+		DoFocusEvents(dev, pWin, PointerRootWin, focusEventMode);
 	    dev->focus->win = PointerRootWin;
 	    dev->focus->traceGood = 0;
 	    break;
 	case RevertToFollowKeyboard:
-	    if (inputInfo.keyboard->focus->win) {
-		DoFocusEvents(dev, pWin, inputInfo.keyboard->focus->win,
-			      focusEventMode);
+            {
+                DeviceIntPtr kbd = GetMaster(dev, MASTER_KEYBOARD);
+                if (!kbd || (kbd == dev && kbd != inputInfo.keyboard))
+                    kbd = inputInfo.keyboard;
+	    if (kbd->focus->win) {
+		if (!ActivateFocusInGrab(dev, pWin, kbd->focus->win))
+		    DoFocusEvents(dev, pWin, kbd->focus->win, focusEventMode);
 		dev->focus->win = FollowKeyboardWin;
 		dev->focus->traceGood = 0;
 	    } else {
-		DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
+                if (!ActivateFocusInGrab(dev, pWin, NoneWin))
+                    DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
 		dev->focus->win = NoneWin;
 		dev->focus->traceGood = 0;
 	    }
+            }
 	    break;
 	}
     }
@@ -1898,8 +1931,6 @@ DeleteWindowFromAnyExtEvents(WindowPtr pWin, Bool freeResources)
     struct _OtherInputMasks *inputMasks;
 
     for (dev = inputInfo.devices; dev; dev = dev->next) {
-	if (dev == inputInfo.pointer || dev == inputInfo.keyboard)
-	    continue;
 	DeleteDeviceFromAnyExtEvents(pWin, dev);
     }
 
@@ -1946,7 +1977,7 @@ CheckDeviceGrabAndHintWindow(WindowPtr pWin, int type,
     DeviceIntPtr dev;
 
     dixLookupDevice(&dev, xE->deviceid & DEVICE_BITS, serverClient,
-		    DixReadAccess);
+		    DixGrabAccess);
     if (!dev)
         return;
 
@@ -1966,7 +1997,6 @@ CheckDeviceGrabAndHintWindow(WindowPtr pWin, int type,
 	tempGrab.pointerMode = GrabModeAsync;
 	tempGrab.confineTo = NullWindow;
 	tempGrab.cursor = NullCursor;
-        tempGrab.genericMasks = NULL;
         tempGrab.next = NULL;
 	(*dev->deviceGrab.ActivateGrab) (dev, &tempGrab, currentTime, TRUE);
     }
@@ -2065,7 +2095,7 @@ FindInterestedChildren(DeviceIntPtr dev, WindowPtr p1, Mask mask,
 
     while (p1) {
         p2 = p1->firstChild;
-        (void)DeliverEventsToWindow(dev, p1, ev, count, mask, NullGrab, dev->id);
+        DeliverEventsToWindow(dev, p1, ev, count, mask, NullGrab);
         FindInterestedChildren(dev, p2, mask, ev, count);
         p1 = p1->nextSib;
     }
@@ -2087,9 +2117,56 @@ SendEventToAllWindows(DeviceIntPtr dev, Mask mask, xEvent * ev, int count)
         pWin = WindowTable[i];
         if (!pWin)
             continue;
-        (void)DeliverEventsToWindow(dev, pWin, ev, count, mask, NullGrab, dev->id);
+        DeliverEventsToWindow(dev, pWin, ev, count, mask, NullGrab);
         p1 = pWin->firstChild;
         FindInterestedChildren(dev, p1, mask, ev, count);
     }
 }
 
+/**
+ * Set the XI2 mask for the given client on the given window.
+ * @param dev The device to set the mask for.
+ * @param win The window to set the mask on.
+ * @param client The client setting the mask.
+ * @param len Number of bytes in mask.
+ * @param mask Event mask in the form of (1 << eventtype)
+ */
+int
+XISetEventMask(DeviceIntPtr dev, WindowPtr win, ClientPtr client,
+               unsigned int len, unsigned char* mask)
+{
+    OtherInputMasks *masks;
+    InputClientsPtr others = NULL;
+
+    masks = wOtherInputMasks(win);
+    if (masks)
+    {
+	for (others = wOtherInputMasks(win)->inputClients; others;
+	     others = others->next) {
+	    if (SameClient(others, client)) {
+                memset(others->xi2mask[dev->id], 0,
+                       sizeof(others->xi2mask[dev->id]));
+                break;
+            }
+        }
+    }
+
+    len = min(len, sizeof(others->xi2mask[dev->id]));
+
+    if (len && !others)
+    {
+        if (AddExtensionClient(win, client, 0, 0) != Success)
+            return BadAlloc;
+        others= wOtherInputMasks(win)->inputClients;
+    }
+
+    if (others)
+        memset(others->xi2mask[dev->id], 0, sizeof(others->xi2mask[dev->id]));
+
+    if (len)
+        memcpy(others->xi2mask[dev->id], mask, len);
+
+    RecalculateDeviceDeliverableEvents(win);
+
+    return Success;
+}