frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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>
This commit is contained in:
Peter Hutterer 2009-01-30 14:35:22 +10:00
parent 64ea607810
commit 007e93c869
7 changed files with 124 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
dix/events.c
View File

@ -3586,26 +3586,24 @@ DeliverGrabbedEvent(xEvent *xE, DeviceIntPtr thisDev,
the device's processInputProc to be called, as in for example Mouse Keys. the device's processInputProc to be called, as in for example Mouse Keys.
*/ */
void void
FixKeyState (xEvent *xE, DeviceIntPtr keybd) FixKeyState (DeviceEvent *event, DeviceIntPtr keybd)
{ {
int key, bit; int key, bit;
BYTE *kptr; BYTE *kptr;
KeyClassPtr keyc = keybd->key; KeyClassPtr keyc = keybd->key;
key = xE->u.u.detail; key = event->detail.key;
kptr = &keyc->down[key >> 3]; kptr = &keyc->down[key >> 3];
bit = 1 << (key & 7); bit = 1 << (key & 7);
if (((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease)|| if ((event->type == ET_KeyPress)||(event->type == ET_KeyRelease)) {
(xE->u.u.type==DeviceKeyPress)||(xE->u.u.type==DeviceKeyRelease))
) {
DebugF("FixKeyState: Key %d %s\n",key, 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; *kptr |= bit;
else if (xE->u.u.type == KeyRelease || xE->u.u.type == DeviceKeyRelease) else if (event->type == ET_KeyRelease)
*kptr &= ~bit; *kptr &= ~bit;
else else
FatalError("Impossible keyboard event"); FatalError("Impossible keyboard event");

3
include/dix.h
View File

@ -53,6 +53,7 @@ SOFTWARE.
#include "input.h" #include "input.h"
#include "cursor.h" #include "cursor.h"
#include "geext.h" #include "geext.h"
#include "events.h"
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#define EARLIER -1 #define EARLIER -1
@ -406,7 +407,7 @@ extern _X_EXPORT void DeliverGrabbedEvent(
int /* count */); int /* count */);
extern _X_EXPORT void FixKeyState( extern _X_EXPORT void FixKeyState(
xEvent * /* xE */, DeviceEvent* /* event */,
DeviceIntPtr /* keybd */); DeviceIntPtr /* keybd */);
extern _X_EXPORT void RecalculateDeliverableEvents( extern _X_EXPORT void RecalculateDeliverableEvents(

19
include/xkbsrv.h
View File

@ -56,6 +56,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "xkbstr.h" #include "xkbstr.h"
#include "xkbrules.h" #include "xkbrules.h"
#include "inputstr.h" #include "inputstr.h"
#include "events.h"
typedef struct _XkbInterest { typedef struct _XkbInterest {
DeviceIntPtr dev; DeviceIntPtr dev;
@ -709,16 +710,14 @@ extern _X_EXPORT void XkbSendNotification(
); );
extern _X_EXPORT void XkbProcessKeyboardEvent( extern _X_EXPORT void XkbProcessKeyboardEvent(
struct _xEvent * /* xE */, DeviceEvent* /* event */,
DeviceIntPtr /* keybd */, DeviceIntPtr /* keybd */
int /* count */
); );
extern _X_EXPORT void XkbHandleActions( extern _X_EXPORT void XkbHandleActions(
DeviceIntPtr /* dev */, DeviceIntPtr /* dev */,
DeviceIntPtr /* kbd */, DeviceIntPtr /* kbd */,
struct _xEvent * /* xE */, DeviceEvent* /* event */
int /* count */
); );
extern _X_EXPORT Bool XkbEnableDisableControls( extern _X_EXPORT Bool XkbEnableDisableControls(
@ -734,15 +733,13 @@ extern _X_EXPORT void AccessXInit(
); );
extern _X_EXPORT Bool AccessXFilterPressEvent( extern _X_EXPORT Bool AccessXFilterPressEvent(
struct _xEvent * /* xE */, DeviceEvent* /* event */,
DeviceIntPtr /* keybd */, DeviceIntPtr /* keybd */
int /* count */
); );
extern _X_EXPORT Bool AccessXFilterReleaseEvent( extern _X_EXPORT Bool AccessXFilterReleaseEvent(
struct _xEvent * /* xE */, DeviceEvent* /* event */,
DeviceIntPtr /* keybd */, DeviceIntPtr /* keybd */
int /* count */
); );
extern _X_EXPORT void AccessXCancelRepeatKey( extern _X_EXPORT void AccessXCancelRepeatKey(

13
mi/mieq.c
View File

@ -400,20 +400,11 @@ mieqProcessInputEvents(void)
masterEvents->event, master, 1); masterEvents->event, master, 1);
} else } 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 */ /* process slave first, then master */
dev->public.processInputProc(xE, dev, nevents); dev->public.processInputProc(event, dev, 1);
if (master) if (master)
{ master->public.processInputProc(masterEvents->event, master, 1);
nevents = ConvertBackToXI((InternalEvent*)masterEvents->event, xE);
master->public.processInputProc(xE, master, nevents);
}
} }
} }

74
xkb/xkbAccessX.c
View File

@ -119,22 +119,26 @@ XkbControlsPtr ctrls = xkbi->desc->ctrls;
/************************************************************************/ /************************************************************************/
static void static void
AccessXKeyboardEvent(DeviceIntPtr keybd, AccessXKeyboardEvent(DeviceIntPtr keybd,
BYTE type, int type,
BYTE keyCode, BYTE keyCode,
Bool isRepeat) Bool isRepeat)
{ {
xEvent xE; 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);
xE.u.u.type = type;
xE.u.u.detail = keyCode;
xE.u.keyButtonPointer.time = GetTimeInMillis();
if (xkbDebugFlags&0x8) { 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) if (!_XkbIsPressEvent(type) && isRepeat)
XkbLastRepeatEvent= (pointer)&xE; XkbLastRepeatEvent= (pointer)&event;
XkbProcessKeyboardEvent(&xE,keybd,1L); XkbProcessKeyboardEvent(&event, keybd);
XkbLastRepeatEvent= NULL; XkbLastRepeatEvent= NULL;
return; return;
@ -310,8 +314,8 @@ KeyCode key;
return 0; return 0;
key = xkbi->repeatKey; key = xkbi->repeatKey;
AccessXKeyboardEvent(dev, DeviceKeyRelease, key, True); AccessXKeyboardEvent(dev, ET_KeyRelease, key, True);
AccessXKeyboardEvent(dev, DeviceKeyPress, key, True); AccessXKeyboardEvent(dev, ET_KeyPress, key, True);
return xkbi->desc->ctrls->repeat_interval; return xkbi->desc->ctrls->repeat_interval;
} }
@ -346,7 +350,7 @@ XkbControlsPtr ctrls;
XkbSendAccessXNotify(keybd,&ev); XkbSendAccessXNotify(keybd,&ev);
if (XkbAX_NeedFeedback(ctrls,XkbAX_SKAcceptFBMask)) if (XkbAX_NeedFeedback(ctrls,XkbAX_SKAcceptFBMask))
XkbDDXAccessXBeep(keybd,_BEEP_SLOW_ACCEPT,XkbSlowKeysMask); XkbDDXAccessXBeep(keybd,_BEEP_SLOW_ACCEPT,XkbSlowKeysMask);
AccessXKeyboardEvent(keybd,DeviceKeyPress,xkbi->slowKey,False); AccessXKeyboardEvent(keybd, ET_KeyPress,xkbi->slowKey,False);
/* check for magic sequences */ /* check for magic sequences */
if ((ctrls->enabled_ctrls&XkbAccessXKeysMask) && if ((ctrls->enabled_ctrls&XkbAccessXKeysMask) &&
((sym[0]==XK_Shift_R)||(sym[0]==XK_Shift_L))) ((sym[0]==XK_Shift_R)||(sym[0]==XK_Shift_L)))
@ -442,14 +446,13 @@ XkbSrvLedInfoPtr sli;
/* */ /* */
/************************************************************************/ /************************************************************************/
Bool Bool
AccessXFilterPressEvent( register xEvent * xE, AccessXFilterPressEvent( DeviceEvent* event,
register DeviceIntPtr keybd, DeviceIntPtr keybd)
int count)
{ {
XkbSrvInfoPtr xkbi = keybd->key->xkbInfo; XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
XkbControlsPtr ctrls = xkbi->desc->ctrls; XkbControlsPtr ctrls = xkbi->desc->ctrls;
Bool ignoreKeyEvent = FALSE; Bool ignoreKeyEvent = FALSE;
KeyCode key = xE->u.u.detail; KeyCode key = event->detail.key;
KeySym * sym = XkbKeySymsPtr(xkbi->desc,key); KeySym * sym = XkbKeySymsPtr(xkbi->desc,key);
if (ctrls->enabled_ctrls&XkbAccessXKeysMask) { if (ctrls->enabled_ctrls&XkbAccessXKeysMask) {
@ -555,7 +558,7 @@ KeySym * sym = XkbKeySymsPtr(xkbi->desc,key);
} }
if (!ignoreKeyEvent) if (!ignoreKeyEvent)
XkbProcessKeyboardEvent(xE,keybd,count); XkbProcessKeyboardEvent(event, keybd);
return ignoreKeyEvent; return ignoreKeyEvent;
} /* AccessXFilterPressEvent */ } /* AccessXFilterPressEvent */
@ -572,13 +575,12 @@ KeySym * sym = XkbKeySymsPtr(xkbi->desc,key);
/* */ /* */
/************************************************************************/ /************************************************************************/
Bool Bool
AccessXFilterReleaseEvent( register xEvent * xE, AccessXFilterReleaseEvent( DeviceEvent* event,
register DeviceIntPtr keybd, DeviceIntPtr keybd)
int count)
{ {
XkbSrvInfoPtr xkbi = keybd->key->xkbInfo; XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
XkbControlsPtr ctrls = xkbi->desc->ctrls; XkbControlsPtr ctrls = xkbi->desc->ctrls;
KeyCode key = xE->u.u.detail; KeyCode key = event->detail.key;
Bool ignoreKeyEvent = FALSE; Bool ignoreKeyEvent = FALSE;
/* Don't transmit the KeyRelease if BounceKeys is on and /* Don't transmit the KeyRelease if BounceKeys is on and
@ -664,7 +666,7 @@ Bool ignoreKeyEvent = FALSE;
} }
if (!ignoreKeyEvent) if (!ignoreKeyEvent)
XkbProcessKeyboardEvent(xE,keybd,count); XkbProcessKeyboardEvent(event, keybd);
return ignoreKeyEvent; return ignoreKeyEvent;
} /* AccessXFilterReleaseEvent */ } /* AccessXFilterReleaseEvent */
@ -691,16 +693,16 @@ XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
unsigned changed = 0; unsigned changed = 0;
ProcessInputProc backupproc; ProcessInputProc backupproc;
xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(mouse); xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(mouse);
deviceKeyButtonPointer *kbp = xE; DeviceEvent *event = (DeviceEvent*)xE;
xkbi->shiftKeyCount = 0; xkbi->shiftKeyCount = 0;
xkbi->lastPtrEventTime= kbp->time; xkbi->lastPtrEventTime= event->time;
if (xE->u.u.type==DeviceButtonPress) { if (event->type == ET_ButtonPress) {
changed |= XkbPointerButtonMask; changed |= XkbPointerButtonMask;
} }
else if (xE->u.u.type==DeviceButtonRelease) { else if (event->type == ET_ButtonRelease) {
xkbi->lockedPtrButtons&= ~(1<<(kbp->detail&0x7)); xkbi->lockedPtrButtons&= ~(1 << (event->detail.key & 0x7));
changed |= XkbPointerButtonMask; changed |= XkbPointerButtonMask;
} }
@ -719,15 +721,25 @@ deviceKeyButtonPointer *kbp = xE;
* *
* see. it's still steaming. told you. (whot) * 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); 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, COND_WRAP_PROCESS_INPUT_PROC(mouse, xkbPrivPtr,
backupproc, xkbUnwrapProc); backupproc, xkbUnwrapProc);
}
xkbi->state.ptr_buttons = mouse->button->state; xkbi->state.ptr_buttons = mouse->button->state;
/* clear any latched modifiers */ /* clear any latched modifiers */
if ( xkbi->state.latched_mods && (kbp->type==DeviceButtonRelease) ) { if ( xkbi->state.latched_mods && (event->type == ET_ButtonRelease) ) {
unsigned changed_leds; unsigned changed_leds;
XkbStateRec oldState; XkbStateRec oldState;
XkbSrvLedInfoPtr sli; XkbSrvLedInfoPtr sli;
@ -742,7 +754,7 @@ deviceKeyButtonPointer *kbp = xE;
changed_leds= XkbIndicatorsToUpdate(dev,changed,False); changed_leds= XkbIndicatorsToUpdate(dev,changed,False);
if (changed_leds) { if (changed_leds) {
XkbEventCauseRec cause; XkbEventCauseRec cause;
XkbSetCauseKey(&cause,(kbp->detail&0x7),kbp->type); XkbSetCauseKey(&cause,(event->detail.key & 0x7), event->type);
XkbUpdateIndicators(dev,changed_leds,True,NULL,&cause); XkbUpdateIndicators(dev,changed_leds,True,NULL,&cause);
} }
} }
@ -750,8 +762,8 @@ deviceKeyButtonPointer *kbp = xE;
if (((xkbi->flags&_XkbStateNotifyInProgress)==0)&&(changed!=0)) { if (((xkbi->flags&_XkbStateNotifyInProgress)==0)&&(changed!=0)) {
xkbStateNotify sn; xkbStateNotify sn;
sn.keycode= kbp->detail; sn.keycode= event->detail.key;
sn.eventType= kbp->type; sn.eventType= event->type;
sn.requestMajor = sn.requestMinor = 0; sn.requestMajor = sn.requestMinor = 0;
sn.changed= changed; sn.changed= changed;
XkbSendStateNotify(dev,&sn); XkbSendStateNotify(dev,&sn);

28
xkb/xkbActions.c
View File

@ -1068,7 +1068,7 @@ register int i,send;
} }
void void
XkbHandleActions(DeviceIntPtr dev,DeviceIntPtr kbd,xEvent *xE,int count) XkbHandleActions(DeviceIntPtr dev, DeviceIntPtr kbd, DeviceEvent* event)
{ {
int key,bit,i; int key,bit,i;
XkbSrvInfoPtr xkbi; XkbSrvInfoPtr xkbi;
@ -1086,7 +1086,7 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
keyc= kbd->key; keyc= kbd->key;
xkbi= keyc->xkbInfo; 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 /* The state may change, so if we're not in the middle of sending a state
* notify, prepare for it */ * notify, prepare for it */
if ((xkbi->flags&_XkbStateNotifyInProgress)==0) { if ((xkbi->flags&_XkbStateNotifyInProgress)==0) {
@ -1100,10 +1100,8 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
xkbi->groupChange = 0; xkbi->groupChange = 0;
sendEvent = 1; sendEvent = 1;
keyEvent= ((xE->u.u.type==KeyPress)||(xE->u.u.type==DeviceKeyPress)|| keyEvent= ((event->type == ET_KeyPress) || (event->type == ET_KeyRelease));
(xE->u.u.type==KeyRelease)||(xE->u.u.type==DeviceKeyRelease)); pressEvent= ((event->type == ET_KeyPress)|| (event->type == ET_ButtonPress));
pressEvent= (xE->u.u.type==KeyPress)||(xE->u.u.type==DeviceKeyPress)||
(xE->u.u.type==ButtonPress)||(xE->u.u.type==DeviceButtonPress);
if (pressEvent) { if (pressEvent) {
if (keyEvent) if (keyEvent)
@ -1213,13 +1211,23 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
else else
tmpdev = GetPairedDevice(dev); 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); 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, COND_WRAP_PROCESS_INPUT_PROC(tmpdev, xkbPrivPtr,
backupproc,xkbUnwrapProc); backupproc,xkbUnwrapProc);
}
} }
else if (keyEvent) { else if (keyEvent) {
FixKeyState(xE,dev); FixKeyState(event, dev);
} }
xkbi->prev_state= oldState; xkbi->prev_state= oldState;
@ -1229,7 +1237,7 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
if (changed) { if (changed) {
xkbStateNotify sn; xkbStateNotify sn;
sn.keycode= key; sn.keycode= key;
sn.eventType= xE->u.u.type; sn.eventType= event->type;
sn.requestMajor = sn.requestMinor = 0; sn.requestMajor = sn.requestMinor = 0;
sn.changed= changed; sn.changed= changed;
XkbSendStateNotify(dev,&sn); XkbSendStateNotify(dev,&sn);
@ -1239,7 +1247,7 @@ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
changed= XkbIndicatorsToUpdate(dev,changed,False); changed= XkbIndicatorsToUpdate(dev,changed,False);
if (changed) { if (changed) {
XkbEventCauseRec cause; XkbEventCauseRec cause;
XkbSetCauseKey(&cause,key,xE->u.u.type); XkbSetCauseKey(&cause, key, event->type);
XkbUpdateIndicators(dev,changed,False,NULL,&cause); XkbUpdateIndicators(dev,changed,False,NULL,&cause);
} }
return; return;

80
xkb/xkbPrKeyEv.c
View File

@ -38,11 +38,12 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "exevents.h" #include "exevents.h"
#include <xkbsrv.h> #include <xkbsrv.h>
#include <ctype.h> #include <ctype.h>
#include "events.h"
/***====================================================================***/ /***====================================================================***/
void void
XkbProcessKeyboardEvent(xEvent *xE,DeviceIntPtr keybd,int count) XkbProcessKeyboardEvent(DeviceEvent *event, DeviceIntPtr keybd)
{ {
KeyClassPtr keyc = keybd->key; KeyClassPtr keyc = keybd->key;
XkbSrvInfoPtr xkbi; XkbSrvInfoPtr xkbi;
@ -51,12 +52,12 @@ XkbBehavior behavior;
unsigned ndx; unsigned ndx;
xkbi= keyc->xkbInfo; xkbi= keyc->xkbInfo;
key= xE->u.u.detail; key= event->detail.key;
if (xkbDebugFlags&0x8) { 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) ) { ((xkbi->desc->ctrls->enabled_ctrls&XkbRepeatKeysMask)==0) ) {
AccessXCancelRepeatKey(xkbi,key); AccessXCancelRepeatKey(xkbi,key);
} }
@ -70,37 +71,37 @@ unsigned ndx;
if ((behavior.type&XkbKB_Permanent)==0) { if ((behavior.type&XkbKB_Permanent)==0) {
switch (behavior.type) { switch (behavior.type) {
case XkbKB_Default: case XkbKB_Default:
if (xE->u.u.type == DeviceKeyPress && if (event->type == ET_KeyPress &&
(keyc->down[key>>3] & (1<<(key&7)))) { (keyc->down[key>>3] & (1<<(key&7)))) {
XkbLastRepeatEvent= (pointer)xE; XkbLastRepeatEvent= (pointer)event;
xE->u.u.type = DeviceKeyRelease; event->type = ET_KeyRelease;
XkbHandleActions(keybd,keybd,xE,count); XkbHandleActions(keybd, keybd, event);
xE->u.u.type = DeviceKeyPress; event->type = ET_KeyPress;
XkbHandleActions(keybd,keybd,xE,count); XkbHandleActions(keybd, keybd, event);
XkbLastRepeatEvent= NULL; XkbLastRepeatEvent= NULL;
return; return;
} }
else if (xE->u.u.type==DeviceKeyRelease && else if (event->type == ET_KeyRelease &&
(!(keyc->down[key>>3]&(1<<(key&7))))) { (!(keyc->down[key>>3]&(1<<(key&7))))) {
XkbLastRepeatEvent= (pointer)&xE; XkbLastRepeatEvent= (pointer)event;
xE->u.u.type = DeviceKeyPress; event->type = ET_KeyPress;
XkbHandleActions(keybd,keybd,xE,count); XkbHandleActions(keybd, keybd, event);
xE->u.u.type = DeviceKeyRelease; event->type = ET_KeyRelease;
XkbHandleActions(keybd,keybd,xE,count); XkbHandleActions(keybd, keybd, event);
XkbLastRepeatEvent= NULL; XkbLastRepeatEvent= NULL;
return; return;
} }
break; break;
case XkbKB_Lock: case XkbKB_Lock:
if (xE->u.u.type == DeviceKeyRelease) { if (event->type == ET_KeyRelease) {
return; return;
} }
else { else {
int bit= 1<<(key&7); int bit= 1<<(key&7);
if ( keyc->down[key>>3]&bit ) { if ( keyc->down[key>>3]&bit ) {
xE->u.u.type = DeviceKeyRelease; event->type = ET_KeyRelease;
} }
} }
break; break;
@ -109,25 +110,25 @@ unsigned ndx;
if ( ndx<xkbi->nRadioGroups ) { if ( ndx<xkbi->nRadioGroups ) {
XkbRadioGroupPtr rg; XkbRadioGroupPtr rg;
if (xE->u.u.type == DeviceKeyRelease) if (event->type == ET_KeyRelease)
return; return;
rg = &xkbi->radioGroups[ndx]; rg = &xkbi->radioGroups[ndx];
if ( rg->currentDown == xE->u.u.detail ) { if ( rg->currentDown == event->detail.key) {
if (behavior.data&XkbKB_RGAllowNone) { if (behavior.data&XkbKB_RGAllowNone) {
xE->u.u.type = DeviceKeyRelease; event->type = ET_KeyRelease;
XkbHandleActions(keybd,keybd,xE,count); XkbHandleActions(keybd, keybd, event);
rg->currentDown= 0; rg->currentDown= 0;
} }
return; return;
} }
if ( rg->currentDown!=0 ) { if ( rg->currentDown!=0 ) {
int key = xE->u.u.detail; int key = event->detail.key;
xE->u.u.type = DeviceKeyRelease; event->type = ET_KeyRelease;
xE->u.u.detail= rg->currentDown; event->detail.key = rg->currentDown;
XkbHandleActions(keybd,keybd,xE,count); XkbHandleActions(keybd, keybd, event);
xE->u.u.type = DeviceKeyPress; event->type = ET_KeyPress;
xE->u.u.detail= key; event->detail.key = key;
} }
rg->currentDown= key; rg->currentDown= key;
} }
@ -142,7 +143,7 @@ unsigned ndx;
break; break;
if ((behavior.data>=xkbi->desc->min_key_code)&& if ((behavior.data>=xkbi->desc->min_key_code)&&
(behavior.data<=xkbi->desc->max_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 */ /* 9/11/94 (ef) -- XXX! need to match release with */
/* press even if the state of the */ /* press even if the state of the */
/* corresponding overlay control */ /* corresponding overlay control */
@ -155,7 +156,7 @@ unsigned ndx;
break; break;
} }
} }
XkbHandleActions(keybd,keybd,xE,count); XkbHandleActions(keybd, keybd, event);
return; return;
} }
@ -167,16 +168,23 @@ ProcessKeyboardEvent(xEvent *xE,DeviceIntPtr keybd,int count)
XkbSrvInfoPtr xkbi = NULL; XkbSrvInfoPtr xkbi = NULL;
ProcessInputProc backup_proc; ProcessInputProc backup_proc;
xkbDeviceInfoPtr xkb_priv = XKBDEVICEINFO(keybd); xkbDeviceInfoPtr xkb_priv = XKBDEVICEINFO(keybd);
int is_press = (xE->u.u.type == DeviceKeyPress); DeviceEvent *event = (DeviceEvent*)xE;
int is_release = (xE->u.u.type == DeviceKeyRelease); int is_press = (event->type == ET_KeyPress);
int is_release = (event->type == ET_KeyRelease);
if (keyc) if (keyc)
xkbi = keyc->xkbInfo; xkbi = keyc->xkbInfo;
/* We're only interested in key events. */ /* We're only interested in key events. */
if (!is_press && !is_release) { 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); 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, COND_WRAP_PROCESS_INPUT_PROC(keybd, xkb_priv, backup_proc,
xkbUnwrapProc); xkbUnwrapProc);
return; return;
@ -190,12 +198,12 @@ ProcessKeyboardEvent(xEvent *xE,DeviceIntPtr keybd,int count)
* they'll punt through XPKE anyway. */ * they'll punt through XPKE anyway. */
if ((xkbi->desc->ctrls->enabled_ctrls & XkbAllFilteredEventsMask)) { if ((xkbi->desc->ctrls->enabled_ctrls & XkbAllFilteredEventsMask)) {
if (is_press) if (is_press)
AccessXFilterPressEvent(xE, keybd, count); AccessXFilterPressEvent(event, keybd);
else if (is_release) else if (is_release)
AccessXFilterReleaseEvent(xE, keybd, count); AccessXFilterReleaseEvent(event, keybd);
} else { } else {
XkbProcessKeyboardEvent(xE, keybd, count); XkbProcessKeyboardEvent(event, keybd);
} }
return; return;