xkb: Switch the xkb event processing path over to InternalEvents.

Before dropping down into the DIX, convert back into XI events. This is a
temporary solution only, until the DIX is capable of handling InternalEvents
anyway.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

7 files changed, 124 insertions, 109 deletions

diff --git a/dix/events.c b/dix/events.c
index 928c2f01a..43d336aff 100644
--- a/dix/events.c
+++ b/dix/events.c
@@ -3586,26 +3586,24 @@ DeliverGrabbedEvent(xEvent *xE, DeviceIntPtr thisDev,
    the device's processInputProc to be called, as in for example Mouse Keys.
 */
 void
-FixKeyState (xEvent *xE, DeviceIntPtr keybd)
+FixKeyState (DeviceEvent *event, DeviceIntPtr keybd)
 {
     int             key, bit;
     BYTE   *kptr;
     KeyClassPtr keyc = keybd->key;
 
-    key = xE->u.u.detail;
+    key = event->detail.key;
     kptr = &keyc->down[key >> 3];
     bit = 1 << (key & 7);
 
-    if (((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease)||
-         (xE->u.u.type==DeviceKeyPress)||(xE->u.u.type==DeviceKeyRelease))
-            ) {
+    if ((event->type == ET_KeyPress)||(event->type == ET_KeyRelease)) {
 	DebugF("FixKeyState: Key %d %s\n",key,
-               (((xE->u.u.type==KeyPress)||(xE->u.u.type==DeviceKeyPress))?"down":"up"));
+               (((event->type == ET_KeyPress)||(event->type == ET_DeviceKeyPress)) ? "down" : "up"));
     }
 
-    if (xE->u.u.type == KeyPress || xE->u.u.type == DeviceKeyPress)
+    if (event->type == ET_KeyPress)
 	    *kptr |= bit;
-    else if (xE->u.u.type == KeyRelease || xE->u.u.type == DeviceKeyRelease)
+    else if (event->type == ET_KeyRelease)
 	    *kptr &= ~bit;
     else
         FatalError("Impossible keyboard event");
diff --git a/include/dix.h b/include/dix.h
index 204dcf296..0afd76640 100644
--- a/include/dix.h
+++ b/include/dix.h
@@ -53,6 +53,7 @@ SOFTWARE.
 #include "input.h"
 #include "cursor.h"
 #include "geext.h"
+#include "events.h"
 #include <X11/extensions/XI.h>
 
 #define EARLIER -1
@@ -406,7 +407,7 @@ extern _X_EXPORT void DeliverGrabbedEvent(
     int /* count */);
 
 extern _X_EXPORT void FixKeyState(
-    xEvent * /* xE */,
+    DeviceEvent* /* event */,
     DeviceIntPtr /* keybd */);
 
 extern _X_EXPORT void RecalculateDeliverableEvents(
diff --git a/include/xkbsrv.h b/include/xkbsrv.h
index 449722058..8a81431ea 100644
--- a/include/xkbsrv.h
+++ b/include/xkbsrv.h
@@ -56,6 +56,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "xkbstr.h"
 #include "xkbrules.h"
 #include "inputstr.h"
+#include "events.h"
 
 typedef struct _XkbInterest {
 	DeviceIntPtr		dev;
@@ -709,16 +710,14 @@ extern _X_EXPORT void XkbSendNotification(
 );
 
 extern _X_EXPORT void XkbProcessKeyboardEvent(
-    struct _xEvent * 		/* xE */,
-    DeviceIntPtr		/* keybd */,
-    int 			/* count */
+    DeviceEvent*		/* event */,
+    DeviceIntPtr		/* keybd */
 );
 
 extern _X_EXPORT void XkbHandleActions(
     DeviceIntPtr		/* dev */,
     DeviceIntPtr		/* kbd */,
-    struct _xEvent * 		/* xE */,
-    int 			/* count */
+    DeviceEvent*		/* event */
 );
 
 extern _X_EXPORT Bool XkbEnableDisableControls(
@@ -734,15 +733,13 @@ extern _X_EXPORT void AccessXInit(
 );
 
 extern _X_EXPORT Bool AccessXFilterPressEvent(
-    struct _xEvent *	/* xE */,
-    DeviceIntPtr	/* keybd */,
-    int				/* count */
+    DeviceEvent*	/* event */,
+    DeviceIntPtr	/* keybd */
 );
 
 extern _X_EXPORT Bool AccessXFilterReleaseEvent(
-    struct _xEvent *	/* xE */,
-    DeviceIntPtr	/* keybd */,
-    int				/* count */
+    DeviceEvent*	/* event */,
+    DeviceIntPtr	/* keybd */
 );
 
 extern _X_EXPORT void AccessXCancelRepeatKey(
diff --git a/mi/mieq.c b/mi/mieq.c
index 7744b9a29..a3e58a3a6 100644
--- a/mi/mieq.c
+++ b/mi/mieq.c
@@ -400,20 +400,11 @@ mieqProcessInputEvents(void)
                             masterEvents->event, master, 1);
             } else
             {
-                /* FIXME: temporary solution only. */
-                static int nevents;
-                static xEvent xE[1000]; /* enough bytes for the events we have atm */
-
-                nevents = ConvertBackToXI(event, xE);
-
                 /* process slave first, then master */
-                dev->public.processInputProc(xE, dev, nevents);
+                dev->public.processInputProc(event, dev, 1);
 
                 if (master)
-                {
-                    nevents = ConvertBackToXI((InternalEvent*)masterEvents->event, xE);
-                    master->public.processInputProc(xE, master, nevents);
-                }
+                    master->public.processInputProc(masterEvents->event, master, 1);
             }
         }
 
diff --git a/xkb/xkbAccessX.c b/xkb/xkbAccessX.c
index c7f7439c2..8a520c6d3 100644
--- a/xkb/xkbAccessX.c
+++ b/xkb/xkbAccessX.c
@@ -119,22 +119,26 @@ XkbControlsPtr	ctrls = xkbi->desc->ctrls;
 /************************************************************************/
 static void 
 AccessXKeyboardEvent(DeviceIntPtr	keybd,
-				 BYTE		type,
+				 int		type,
 				 BYTE		keyCode,
 				 Bool		isRepeat)
 {
-xEvent		xE;
-    
-    xE.u.u.type = type;
-    xE.u.u.detail = keyCode;
-    xE.u.keyButtonPointer.time = GetTimeInMillis();	    
+    DeviceEvent event;
+    memset(&event, 0, sizeof(DeviceEvent));
+    event.header = ET_Internal;
+    event.type = type;
+    event.detail.key = keyCode;
+    event.time = GetTimeInMillis();
+    event.length = sizeof(DeviceEvent);
+
     if (xkbDebugFlags&0x8) {
-	DebugF("[xkb] AXKE: Key %d %s\n",keyCode,(xE.u.u.type==KeyPress?"down":"up"));
+	DebugF("[xkb] AXKE: Key %d %s\n", keyCode,
+               (event->type == ET_KeyPress ? "down" : "up"));
     }
 
     if (!_XkbIsPressEvent(type) && isRepeat)
-	XkbLastRepeatEvent=	(pointer)&xE;
-    XkbProcessKeyboardEvent(&xE,keybd,1L);
+	XkbLastRepeatEvent=	(pointer)&event;
+    XkbProcessKeyboardEvent(&event, keybd);
     XkbLastRepeatEvent= NULL;
     return;
     
@@ -310,8 +314,8 @@ KeyCode		key;
 	return 0;
 
     key = xkbi->repeatKey;
-    AccessXKeyboardEvent(dev, DeviceKeyRelease, key, True);
-    AccessXKeyboardEvent(dev, DeviceKeyPress, key, True);
+    AccessXKeyboardEvent(dev, ET_KeyRelease, key, True);
+    AccessXKeyboardEvent(dev, ET_KeyPress, key, True);
 
     return xkbi->desc->ctrls->repeat_interval;
 }
@@ -346,7 +350,7 @@ XkbControlsPtr	ctrls;
 	XkbSendAccessXNotify(keybd,&ev);
 	if (XkbAX_NeedFeedback(ctrls,XkbAX_SKAcceptFBMask))
 	    XkbDDXAccessXBeep(keybd,_BEEP_SLOW_ACCEPT,XkbSlowKeysMask);
-	AccessXKeyboardEvent(keybd,DeviceKeyPress,xkbi->slowKey,False);
+	AccessXKeyboardEvent(keybd, ET_KeyPress,xkbi->slowKey,False);
 	/* check for magic sequences */
 	if ((ctrls->enabled_ctrls&XkbAccessXKeysMask) &&
 	    ((sym[0]==XK_Shift_R)||(sym[0]==XK_Shift_L)))
@@ -442,14 +446,13 @@ XkbSrvLedInfoPtr	sli;
 /*									*/
 /************************************************************************/
 Bool
-AccessXFilterPressEvent(	register xEvent *	xE, 
-				register DeviceIntPtr	keybd, 
-				int			count)
+AccessXFilterPressEvent(	DeviceEvent*	event,
+				DeviceIntPtr	keybd)
 {
 XkbSrvInfoPtr	xkbi = keybd->key->xkbInfo;
 XkbControlsPtr	ctrls = xkbi->desc->ctrls;
 Bool		ignoreKeyEvent = FALSE;
-KeyCode		key = xE->u.u.detail;
+KeyCode		key = event->detail.key;
 KeySym *	sym = XkbKeySymsPtr(xkbi->desc,key);
 
     if (ctrls->enabled_ctrls&XkbAccessXKeysMask) {
@@ -555,7 +558,7 @@ KeySym *	sym = XkbKeySymsPtr(xkbi->desc,key);
     }
     
     if (!ignoreKeyEvent)
-	XkbProcessKeyboardEvent(xE,keybd,count);
+	XkbProcessKeyboardEvent(event, keybd);
     return ignoreKeyEvent;
 } /* AccessXFilterPressEvent */
 
@@ -572,13 +575,12 @@ KeySym *	sym = XkbKeySymsPtr(xkbi->desc,key);
 /*									*/
 /************************************************************************/
 Bool
-AccessXFilterReleaseEvent(	register xEvent *	xE, 
-				register DeviceIntPtr	keybd, 
-				int			count)
+AccessXFilterReleaseEvent(	DeviceEvent*	event,
+				DeviceIntPtr	keybd)
 {
 XkbSrvInfoPtr	xkbi = keybd->key->xkbInfo;
 XkbControlsPtr	ctrls = xkbi->desc->ctrls;
-KeyCode		key = xE->u.u.detail;
+KeyCode		key = event->detail.key;
 Bool		ignoreKeyEvent = FALSE;
     
     /* Don't transmit the KeyRelease if BounceKeys is on and
@@ -664,7 +666,7 @@ Bool		ignoreKeyEvent = FALSE;
     }
     
     if (!ignoreKeyEvent)
-	XkbProcessKeyboardEvent(xE,keybd,count);
+	XkbProcessKeyboardEvent(event, keybd);
     return ignoreKeyEvent;
     
 } /* AccessXFilterReleaseEvent */
@@ -691,16 +693,16 @@ XkbSrvInfoPtr	xkbi = dev->key->xkbInfo;
 unsigned 	changed = 0;
 ProcessInputProc backupproc;
 xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(mouse);
-deviceKeyButtonPointer *kbp = xE;
+DeviceEvent     *event = (DeviceEvent*)xE;
 
     xkbi->shiftKeyCount = 0;
-    xkbi->lastPtrEventTime= kbp->time;
+    xkbi->lastPtrEventTime= event->time;
 
-    if (xE->u.u.type==DeviceButtonPress) {
+    if (event->type == ET_ButtonPress) {
 	    changed |= XkbPointerButtonMask;
     }
-    else if (xE->u.u.type==DeviceButtonRelease) {
-	xkbi->lockedPtrButtons&= ~(1<<(kbp->detail&0x7));
+    else if (event->type == ET_ButtonRelease) {
+	xkbi->lockedPtrButtons&= ~(1 << (event->detail.key & 0x7));
 	changed |= XkbPointerButtonMask;
     }
 
@@ -719,15 +721,25 @@ deviceKeyButtonPointer *kbp = xE;
      *
      *          see. it's still steaming. told you. (whot)
      */
+
+    {
+        /* FIXME: temporary solution only. */
+        static int nevents;
+        static xEvent ev[1000]; /* enough bytes for the events we have atm */
+
+        nevents = ConvertBackToXI((InternalEvent*)xE, ev);
+
+
     UNWRAP_PROCESS_INPUT_PROC(mouse, xkbPrivPtr, backupproc);
-    mouse->public.processInputProc(xE, mouse, count);
+    mouse->public.processInputProc(ev, mouse, nevents);
     COND_WRAP_PROCESS_INPUT_PROC(mouse, xkbPrivPtr,
 				     backupproc, xkbUnwrapProc);
+    }
 
     xkbi->state.ptr_buttons = mouse->button->state;
     
     /* clear any latched modifiers */
-    if ( xkbi->state.latched_mods && (kbp->type==DeviceButtonRelease) ) {
+    if ( xkbi->state.latched_mods && (event->type == ET_ButtonRelease) ) {
 	unsigned 		changed_leds;
 	XkbStateRec		oldState;
 	XkbSrvLedInfoPtr	sli;
@@ -742,7 +754,7 @@ deviceKeyButtonPointer *kbp = xE;
 	    changed_leds= XkbIndicatorsToUpdate(dev,changed,False);
 	    if (changed_leds) {
 		XkbEventCauseRec	cause;
-		XkbSetCauseKey(&cause,(kbp->detail&0x7),kbp->type);
+		XkbSetCauseKey(&cause,(event->detail.key & 0x7), event->type);
 		XkbUpdateIndicators(dev,changed_leds,True,NULL,&cause);
 	    }
 	}
@@ -750,8 +762,8 @@ deviceKeyButtonPointer *kbp = xE;
 
     if (((xkbi->flags&_XkbStateNotifyInProgress)==0)&&(changed!=0)) {
 	xkbStateNotify	sn;
-	sn.keycode= kbp->detail;
-	sn.eventType= kbp->type;
+	sn.keycode= event->detail.key;
+	sn.eventType= event->type;
 	sn.requestMajor = sn.requestMinor = 0;
 	sn.changed= changed;
 	XkbSendStateNotify(dev,&sn);
diff --git a/xkb/xkbActions.c b/xkb/xkbActions.c
index 9a138b0be..6f5c6bc04 100644
--- a/xkb/xkbActions.c
+++ b/xkb/xkbActions.c
@@ -1068,7 +1068,7 @@ register int	i,send;
 }
 
 void
-XkbHandleActions(DeviceIntPtr dev,DeviceIntPtr kbd,xEvent *xE,int count)
+XkbHandleActions(DeviceIntPtr dev, DeviceIntPtr kbd, DeviceEvent* event)
 {
 int		key,bit,i;
 XkbSrvInfoPtr	xkbi;
@@ -1086,7 +1086,7 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
 
     keyc= kbd->key;
     xkbi= keyc->xkbInfo;
-    key= xE->u.u.detail;
+    key= event->detail.key;
     /* The state may change, so if we're not in the middle of sending a state
      * notify, prepare for it */
     if ((xkbi->flags&_XkbStateNotifyInProgress)==0) {
@@ -1100,10 +1100,8 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
     xkbi->groupChange = 0;
 
     sendEvent = 1;
-    keyEvent= ((xE->u.u.type==KeyPress)||(xE->u.u.type==DeviceKeyPress)||
-		(xE->u.u.type==KeyRelease)||(xE->u.u.type==DeviceKeyRelease));
-    pressEvent= (xE->u.u.type==KeyPress)||(xE->u.u.type==DeviceKeyPress)||
-		 (xE->u.u.type==ButtonPress)||(xE->u.u.type==DeviceButtonPress);
+    keyEvent= ((event->type == ET_KeyPress) || (event->type == ET_KeyRelease));
+    pressEvent= ((event->type == ET_KeyPress)|| (event->type == ET_ButtonPress));
 
     if (pressEvent) {
 	if (keyEvent)	
@@ -1213,13 +1211,23 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
         else
             tmpdev = GetPairedDevice(dev);
 
+        {
+
+
+        /* FIXME: temporary solution only. */
+        static int nevents;
+        static xEvent ev[1000]; /* enough bytes for the events we have atm */
+        nevents = ConvertBackToXI((InternalEvent*)event, ev);
+
         UNWRAP_PROCESS_INPUT_PROC(tmpdev,xkbPrivPtr, backupproc);
-        dev->public.processInputProc(xE,tmpdev,count);
+        dev->public.processInputProc(ev, tmpdev, nevents);
         COND_WRAP_PROCESS_INPUT_PROC(tmpdev, xkbPrivPtr,
                                      backupproc,xkbUnwrapProc);
+
+        }
     }
     else if (keyEvent) {
-	FixKeyState(xE,dev);
+	FixKeyState(event, dev);
     }
 
     xkbi->prev_state= oldState;
@@ -1229,7 +1237,7 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
 	if (changed) {
 	    xkbStateNotify	sn;
 	    sn.keycode= key;
-	    sn.eventType= xE->u.u.type;
+	    sn.eventType= event->type;
 	    sn.requestMajor = sn.requestMinor = 0;
 	    sn.changed= changed;
 	    XkbSendStateNotify(dev,&sn);
@@ -1239,7 +1247,7 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
     changed= XkbIndicatorsToUpdate(dev,changed,False);
     if (changed) {
 	XkbEventCauseRec	cause;
-	XkbSetCauseKey(&cause,key,xE->u.u.type);
+	XkbSetCauseKey(&cause, key, event->type);
 	XkbUpdateIndicators(dev,changed,False,NULL,&cause);
     }
     return;
diff --git a/xkb/xkbPrKeyEv.c b/xkb/xkbPrKeyEv.c
index badfb14a2..33fd09840 100644
--- a/xkb/xkbPrKeyEv.c
+++ b/xkb/xkbPrKeyEv.c
@@ -38,11 +38,12 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "exevents.h"
 #include <xkbsrv.h>
 #include <ctype.h>
+#include "events.h"
 
 /***====================================================================***/
 
 void
-XkbProcessKeyboardEvent(xEvent *xE,DeviceIntPtr keybd,int count)
+XkbProcessKeyboardEvent(DeviceEvent *event, DeviceIntPtr keybd)
 {
 KeyClassPtr	keyc = keybd->key;
 XkbSrvInfoPtr	xkbi;
@@ -51,12 +52,12 @@ XkbBehavior	behavior;
 unsigned        ndx;
 
     xkbi= keyc->xkbInfo;
-    key= xE->u.u.detail;
+    key= event->detail.key;
     if (xkbDebugFlags&0x8) {
-	DebugF("[xkb] XkbPKE: Key %d %s\n",key,(xE->u.u.type==DeviceKeyPress?"down":"up"));
+	DebugF("[xkb] XkbPKE: Key %d %s\n",key,(event->type == ET_KeyPress?"down":"up"));
     }
 
-    if ( (xkbi->repeatKey==key) && (xE->u.u.type==DeviceKeyRelease) &&
+    if ( (xkbi->repeatKey==key) && (event->type== ET_KeyRelease) &&
 	 ((xkbi->desc->ctrls->enabled_ctrls&XkbRepeatKeysMask)==0) ) {
 	AccessXCancelRepeatKey(xkbi,key);
     }
@@ -70,37 +71,37 @@ unsigned        ndx;
     if ((behavior.type&XkbKB_Permanent)==0) {
 	switch (behavior.type) {
 	    case XkbKB_Default:
-		if (xE->u.u.type == DeviceKeyPress && 
+		if (event->type == ET_KeyPress &&
 		    (keyc->down[key>>3] & (1<<(key&7)))) {
-		    XkbLastRepeatEvent=	(pointer)xE;
+		    XkbLastRepeatEvent=	(pointer)event;
 
-                    xE->u.u.type = DeviceKeyRelease;
-		    XkbHandleActions(keybd,keybd,xE,count);
+		    event->type = ET_KeyRelease;
+		    XkbHandleActions(keybd, keybd, event);
 
-                    xE->u.u.type = DeviceKeyPress;
-		    XkbHandleActions(keybd,keybd,xE,count);
+		    event->type = ET_KeyPress;
+		    XkbHandleActions(keybd, keybd, event);
 		    XkbLastRepeatEvent= NULL;
 		    return;
 		}
-		else if (xE->u.u.type==DeviceKeyRelease &&
+		else if (event->type == ET_KeyRelease &&
 			(!(keyc->down[key>>3]&(1<<(key&7))))) {
-		    XkbLastRepeatEvent=	(pointer)&xE;
-                    xE->u.u.type = DeviceKeyPress;
-		    XkbHandleActions(keybd,keybd,xE,count);
-                    xE->u.u.type = DeviceKeyRelease;
-		    XkbHandleActions(keybd,keybd,xE,count);
+		    XkbLastRepeatEvent=	(pointer)event;
+		    event->type = ET_KeyPress;
+		    XkbHandleActions(keybd, keybd, event);
+		    event->type = ET_KeyRelease;
+		    XkbHandleActions(keybd, keybd, event);
 		    XkbLastRepeatEvent= NULL;
 		    return;
 		}
 		break;
 	    case XkbKB_Lock:
-		if (xE->u.u.type == DeviceKeyRelease) {
+		if (event->type == ET_KeyRelease) {
 		    return;
                 }
 		else {
 		    int	bit= 1<<(key&7);
 		    if ( keyc->down[key>>3]&bit ) {
-                        xE->u.u.type = DeviceKeyRelease;
+			event->type = ET_KeyRelease;
                     }
                 }
 		break;
@@ -109,25 +110,25 @@ unsigned        ndx;
 		if ( ndx<xkbi->nRadioGroups ) {
 		    XkbRadioGroupPtr	rg;
 
-		    if (xE->u.u.type == DeviceKeyRelease)
+		    if (event->type == ET_KeyRelease)
 		        return;
 
 		    rg = &xkbi->radioGroups[ndx];
-		    if ( rg->currentDown == xE->u.u.detail ) {
+		    if ( rg->currentDown == event->detail.key) {
 		        if (behavior.data&XkbKB_RGAllowNone) {
-		            xE->u.u.type = DeviceKeyRelease;
-			    XkbHandleActions(keybd,keybd,xE,count);
+		            event->type = ET_KeyRelease;
+			    XkbHandleActions(keybd, keybd, event);
 			    rg->currentDown= 0;
 		        }
 		        return;
 		    }
 		    if ( rg->currentDown!=0 ) {
-			int key = xE->u.u.detail;
-                        xE->u.u.type = DeviceKeyRelease;
-			xE->u.u.detail= rg->currentDown;
-		        XkbHandleActions(keybd,keybd,xE,count);
-                        xE->u.u.type = DeviceKeyPress;
-		        xE->u.u.detail= key;
+			int key = event->detail.key;
+			event->type = ET_KeyRelease;
+			event->detail.key = rg->currentDown;
+			XkbHandleActions(keybd, keybd, event);
+			event->type = ET_KeyPress;
+			event->detail.key = key;
 		    }
 		    rg->currentDown= key;
 		}
@@ -142,7 +143,7 @@ unsigned        ndx;
 			break;
 		    if ((behavior.data>=xkbi->desc->min_key_code)&&
 			(behavior.data<=xkbi->desc->max_key_code)) {
-			xE->u.u.detail= behavior.data;
+                        event->detail.key = behavior.data;
 			/* 9/11/94 (ef) -- XXX! need to match release with */
 			/*                 press even if the state of the  */
 			/*                 corresponding overlay control   */
@@ -155,7 +156,7 @@ unsigned        ndx;
 		break;
 	}
     }
-    XkbHandleActions(keybd,keybd,xE,count);
+    XkbHandleActions(keybd, keybd, event);
     return;
 }
 
@@ -167,16 +168,23 @@ ProcessKeyboardEvent(xEvent *xE,DeviceIntPtr keybd,int count)
     XkbSrvInfoPtr xkbi = NULL;
     ProcessInputProc backup_proc;
     xkbDeviceInfoPtr xkb_priv = XKBDEVICEINFO(keybd);
-    int is_press = (xE->u.u.type == DeviceKeyPress);
-    int is_release = (xE->u.u.type == DeviceKeyRelease);
+    DeviceEvent *event = (DeviceEvent*)xE;
+    int is_press = (event->type == ET_KeyPress);
+    int is_release = (event->type == ET_KeyRelease);
 
     if (keyc)
         xkbi = keyc->xkbInfo;
 
     /* We're only interested in key events. */
     if (!is_press && !is_release) {
+        /* FIXME: temporary solution only. */
+        static int nevents;
+        static xEvent ev[1000]; /* enough bytes for the events we have atm */
+
+        nevents = ConvertBackToXI((InternalEvent*)xE, ev);
+
         UNWRAP_PROCESS_INPUT_PROC(keybd, xkb_priv, backup_proc);
-        keybd->public.processInputProc(xE, keybd, count);
+        keybd->public.processInputProc(ev, keybd, nevents);
         COND_WRAP_PROCESS_INPUT_PROC(keybd, xkb_priv, backup_proc,
                                      xkbUnwrapProc);
         return;
@@ -190,12 +198,12 @@ ProcessKeyboardEvent(xEvent *xE,DeviceIntPtr keybd,int count)
      * they'll punt through XPKE anyway. */
     if ((xkbi->desc->ctrls->enabled_ctrls & XkbAllFilteredEventsMask)) {
         if (is_press)
-            AccessXFilterPressEvent(xE, keybd, count);
+            AccessXFilterPressEvent(event, keybd);
         else if (is_release)
-            AccessXFilterReleaseEvent(xE, keybd, count);
+            AccessXFilterReleaseEvent(event, keybd);
 
     } else {
-        XkbProcessKeyboardEvent(xE, keybd, count);
+        XkbProcessKeyboardEvent(event, keybd);
     }
 
     return;