Integration of XEVIE branch to trunk, latest updates
https://freedesktop.org/bugzilla/show_bug.cgi?id=947 Modified Files: Imakefile xevie.c
This commit is contained in:
Stuart Kreitman
parent
e68bfc8016
commit
b2065f376b
425
Xext/xevie.c
425
Xext/xevie.c
|
|
@ -41,45 +41,31 @@ of the copyright holder.
|
|||
#include "colormapst.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "servermd.h"
|
||||
#include "opaque.h"
|
||||
#define _XEVIE_SERVER_
|
||||
#include "Xeviestr.h"
|
||||
#include "Xfuncproto.h"
|
||||
#include "input.h"
|
||||
#include "inputstr.h"
|
||||
#include "windowstr.h"
|
||||
#include "cursorstr.h"
|
||||
#include "swaprep.h"
|
||||
#include "panoramiX.h"
|
||||
#include "panoramiXsrv.h"
|
||||
|
||||
#ifndef EXTMODULE
|
||||
#include "../os/osdep.h"
|
||||
#else
|
||||
#include "xf86_ansic.h"
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
#define DEBUG
|
||||
#endif
|
||||
|
||||
#ifdef DEBUG
|
||||
# define ERR(x) ErrorF(x)
|
||||
#else
|
||||
#define ERR
|
||||
#endif
|
||||
|
||||
static int xevieFlag = 0;
|
||||
static int xevieClientIndex = 0;
|
||||
static Mask xevieMask = 0;
|
||||
static Bool xeviegrabState = FALSE;
|
||||
static unsigned int xevieServerGeneration;
|
||||
static int xevieDevicePrivateIndex;
|
||||
static Bool xevieModifiersOn = FALSE;
|
||||
|
||||
#define XEVIEINFO(dev) ((xevieDeviceInfoPtr)dev->devPrivates[xevieDevicePrivateIndex].ptr)
|
||||
#define NoSuchEvent 0x80000000
|
||||
|
||||
extern Bool noXkbExtension;
|
||||
extern int xeviegrabState;
|
||||
|
||||
static int ProcDispatch (), SProcDispatch ();
|
||||
static void ResetProc ();
|
||||
|
||||
static unsigned char ReqCode = 0;
|
||||
static int ErrorBase;
|
||||
|
||||
int xevieFlag = 0;
|
||||
int xevieClientIndex = 0;
|
||||
DeviceIntPtr xeviekb = NULL;
|
||||
DeviceIntPtr xeviemouse = NULL;
|
||||
Mask xevieMask = 0;
|
||||
int xevieEventSent = 0;
|
||||
int xevieKBEventSent = 0;
|
||||
Mask xevieFilters[128] =
|
||||
{
|
||||
NoSuchEvent, /* 0 */
|
||||
|
|
@ -90,72 +76,50 @@ Mask xevieFilters[128] =
|
|||
ButtonReleaseMask, /* ButtonRelease */
|
||||
PointerMotionMask /* MotionNotify (initial state) */
|
||||
};
|
||||
#undef NoSuchEvent
|
||||
|
||||
typedef struct {
|
||||
ProcessInputProc processInputProc;
|
||||
ProcessInputProc realInputProc;
|
||||
DeviceUnwrapProc unwrapProc;
|
||||
} xevieDeviceInfoRec, *xevieDeviceInfoPtr;
|
||||
|
||||
static int ProcDispatch (ClientPtr), SProcDispatch (ClientPtr);
|
||||
static void ResetProc (ExtensionEntry*);
|
||||
|
||||
static unsigned char ReqCode = 0;
|
||||
static int ErrorBase;
|
||||
|
||||
static Bool XevieStart(void);
|
||||
static void XevieEnd(int clientIndex);
|
||||
static void XevieClientStateCallback(CallbackListPtr *pcbl, pointer nulldata,
|
||||
pointer calldata);
|
||||
pointer calldata);
|
||||
static void XevieServerGrabStateCallback(CallbackListPtr *pcbl,
|
||||
pointer nulldata,
|
||||
pointer calldata);
|
||||
|
||||
static Bool XevieAdd(DeviceIntPtr device, pointer data);
|
||||
static void XevieWrap(DeviceIntPtr device, ProcessInputProc proc);
|
||||
static Bool XevieRemove(DeviceIntPtr device, pointer data);
|
||||
static void doSendEvent(xEvent *xE, DeviceIntPtr device);
|
||||
static void XeviePointerProcessInputProc(xEvent *xE, DeviceIntPtr dev,
|
||||
int count);
|
||||
static void XevieKbdProcessInputProc(xEvent *xE, DeviceIntPtr dev, int count);
|
||||
pointer nulldata,
|
||||
pointer calldata);
|
||||
|
||||
void
|
||||
XevieExtensionInit (INITARGS)
|
||||
XevieExtensionInit ()
|
||||
{
|
||||
ExtensionEntry* extEntry;
|
||||
|
||||
if (serverGeneration != xevieServerGeneration) {
|
||||
if ((xevieDevicePrivateIndex = AllocateDevicePrivateIndex()) == -1)
|
||||
return;
|
||||
xevieServerGeneration = serverGeneration;
|
||||
}
|
||||
|
||||
if (!AddCallback(&ServerGrabCallback,XevieServerGrabStateCallback,NULL))
|
||||
return;
|
||||
return;
|
||||
|
||||
if ((extEntry = AddExtension (XEVIENAME,
|
||||
if (extEntry = AddExtension (XEVIENAME,
|
||||
0,
|
||||
XevieNumberErrors,
|
||||
ProcDispatch,
|
||||
SProcDispatch,
|
||||
ResetProc,
|
||||
StandardMinorOpcode))) {
|
||||
StandardMinorOpcode)) {
|
||||
ReqCode = (unsigned char)extEntry->base;
|
||||
ErrorBase = extEntry->errorBase;
|
||||
}
|
||||
|
||||
/* PC servers initialize the desktop colors (citems) here! */
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
static
|
||||
void ResetProc (ExtensionEntry* extEntry)
|
||||
void ResetProc (extEntry)
|
||||
ExtensionEntry* extEntry;
|
||||
{
|
||||
}
|
||||
|
||||
static
|
||||
int ProcQueryVersion (ClientPtr client)
|
||||
int ProcQueryVersion (client)
|
||||
register ClientPtr client;
|
||||
{
|
||||
REQUEST (xXevieQueryVersionReq);
|
||||
xXevieQueryVersionReply rep;
|
||||
register int n;
|
||||
|
||||
REQUEST_SIZE_MATCH (xXevieQueryVersionReq);
|
||||
rep.type = X_Reply;
|
||||
|
|
@ -168,30 +132,26 @@ int ProcQueryVersion (ClientPtr client)
|
|||
}
|
||||
|
||||
static
|
||||
int ProcStart (ClientPtr client)
|
||||
int ProcStart (client)
|
||||
register ClientPtr client;
|
||||
{
|
||||
REQUEST (xXevieStartReq);
|
||||
xXevieStartReply rep;
|
||||
register int n;
|
||||
|
||||
REQUEST_SIZE_MATCH (xXevieStartReq);
|
||||
rep.pad1 = 0;
|
||||
|
||||
if(!xevieFlag){
|
||||
if (AddCallback(&ClientStateCallback,XevieClientStateCallback,NULL)) {
|
||||
xevieFlag = 1;
|
||||
rep.pad1 = 1;
|
||||
xevieClientIndex = client->index;
|
||||
} else
|
||||
return BadAlloc;
|
||||
if (AddCallback(&ClientStateCallback,XevieClientStateCallback,NULL)) {
|
||||
xevieFlag = 1;
|
||||
rep.pad1 = 1;
|
||||
xevieClientIndex = client->index;
|
||||
} else
|
||||
return BadAlloc;
|
||||
} else
|
||||
return BadAccess;
|
||||
|
||||
if (!XevieStart()) {
|
||||
DeleteCallback(&ClientStateCallback,XevieClientStateCallback,NULL);
|
||||
return BadAlloc;
|
||||
}
|
||||
return BadAccess;
|
||||
|
||||
xevieModifiersOn = FALSE;
|
||||
|
||||
rep.type = X_Reply;
|
||||
rep.sequence_number = client->sequence;
|
||||
WriteToClient (client, sizeof (xXevieStartReply), (char *)&rep);
|
||||
|
|
@ -199,18 +159,13 @@ int ProcStart (ClientPtr client)
|
|||
}
|
||||
|
||||
static
|
||||
int ProcEnd (ClientPtr client)
|
||||
int ProcEnd (client)
|
||||
register ClientPtr client;
|
||||
{
|
||||
xXevieEndReply rep;
|
||||
|
||||
if (xevieFlag) {
|
||||
if (client->index != xevieClientIndex)
|
||||
return BadAccess;
|
||||
XevieEnd(xevieClientIndex);
|
||||
|
||||
DeleteCallback(&ClientStateCallback,XevieClientStateCallback,NULL);
|
||||
XevieEnd(xevieClientIndex);
|
||||
}
|
||||
|
||||
rep.type = X_Reply;
|
||||
rep.sequence_number = client->sequence;
|
||||
WriteToClient (client, sizeof (xXevieEndReply), (char *)&rep);
|
||||
|
|
@ -218,18 +173,15 @@ int ProcEnd (ClientPtr client)
|
|||
}
|
||||
|
||||
static
|
||||
int ProcSend (ClientPtr client)
|
||||
int ProcSend (client)
|
||||
register ClientPtr client;
|
||||
{
|
||||
REQUEST (xXevieSendReq);
|
||||
xXevieSendReply rep;
|
||||
xEvent *xE;
|
||||
OsCommPtr oc;
|
||||
static unsigned char lastDetail = 0, lastType = 0;
|
||||
|
||||
ERR("ProcSend\n");
|
||||
|
||||
if (client->index != xevieClientIndex)
|
||||
return BadAccess;
|
||||
|
||||
xE = (xEvent *)&stuff->event;
|
||||
rep.type = X_Reply;
|
||||
rep.sequence_number = client->sequence;
|
||||
|
|
@ -238,31 +190,33 @@ int ProcSend (ClientPtr client)
|
|||
switch(xE->u.u.type) {
|
||||
case KeyPress:
|
||||
case KeyRelease:
|
||||
doSendEvent(xE, inputInfo.keyboard);
|
||||
xevieKBEventSent = 1;
|
||||
#ifdef XKB
|
||||
if(noXkbExtension)
|
||||
#endif
|
||||
CoreProcessKeyboardEvent (xE, xeviekb, 1);
|
||||
break;
|
||||
case ButtonPress:
|
||||
case ButtonRelease:
|
||||
case MotionNotify:
|
||||
doSendEvent(xE, inputInfo.pointer);
|
||||
xevieEventSent = 1;
|
||||
CoreProcessPointerEvent(xE, xeviemouse, 1);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
lastType = xE->u.u.type;
|
||||
lastDetail = xE->u.u.detail;
|
||||
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
static
|
||||
int ProcSelectInput (ClientPtr client)
|
||||
int ProcSelectInput (client)
|
||||
register ClientPtr client;
|
||||
{
|
||||
REQUEST (xXevieSelectInputReq);
|
||||
xXevieSelectInputReply rep;
|
||||
|
||||
if (client->index != xevieClientIndex)
|
||||
return BadAccess;
|
||||
|
||||
xevieMask = (long)stuff->event_mask;
|
||||
rep.type = X_Reply;
|
||||
rep.sequence_number = client->sequence;
|
||||
|
|
@ -271,7 +225,8 @@ int ProcSelectInput (ClientPtr client)
|
|||
}
|
||||
|
||||
static
|
||||
int ProcDispatch (ClientPtr client)
|
||||
int ProcDispatch (client)
|
||||
register ClientPtr client;
|
||||
{
|
||||
REQUEST (xReq);
|
||||
switch (stuff->data)
|
||||
|
|
@ -292,7 +247,8 @@ int ProcDispatch (ClientPtr client)
|
|||
}
|
||||
|
||||
static
|
||||
int SProcQueryVersion (ClientPtr client)
|
||||
int SProcQueryVersion (client)
|
||||
register ClientPtr client;
|
||||
{
|
||||
register int n;
|
||||
|
||||
|
|
@ -302,7 +258,8 @@ int SProcQueryVersion (ClientPtr client)
|
|||
}
|
||||
|
||||
static
|
||||
int SProcStart (ClientPtr client)
|
||||
int SProcStart (client)
|
||||
ClientPtr client;
|
||||
{
|
||||
register int n;
|
||||
|
||||
|
|
@ -314,9 +271,12 @@ int SProcStart (ClientPtr client)
|
|||
}
|
||||
|
||||
static
|
||||
int SProcEnd (ClientPtr client)
|
||||
int SProcEnd (client)
|
||||
ClientPtr client;
|
||||
{
|
||||
register int n;
|
||||
int count;
|
||||
xColorItem* pItem;
|
||||
|
||||
REQUEST (xXevieEndReq);
|
||||
swaps (&stuff->length, n);
|
||||
|
|
@ -326,9 +286,11 @@ int SProcEnd (ClientPtr client)
|
|||
}
|
||||
|
||||
static
|
||||
int SProcSend (ClientPtr client)
|
||||
int SProcSend (client)
|
||||
ClientPtr client;
|
||||
{
|
||||
register int n;
|
||||
int count;
|
||||
|
||||
REQUEST (xXevieSendReq);
|
||||
swaps (&stuff->length, n);
|
||||
|
|
@ -338,9 +300,11 @@ int SProcSend (ClientPtr client)
|
|||
}
|
||||
|
||||
static
|
||||
int SProcSelectInput (ClientPtr client)
|
||||
int SProcSelectInput (client)
|
||||
ClientPtr client;
|
||||
{
|
||||
register int n;
|
||||
int count;
|
||||
|
||||
REQUEST (xXevieSelectInputReq);
|
||||
swaps (&stuff->length, n);
|
||||
|
|
@ -351,7 +315,8 @@ int SProcSelectInput (ClientPtr client)
|
|||
|
||||
|
||||
static
|
||||
int SProcDispatch (ClientPtr client)
|
||||
int SProcDispatch (client)
|
||||
register ClientPtr client;
|
||||
{
|
||||
REQUEST(xReq);
|
||||
switch (stuff->data)
|
||||
|
|
@ -371,258 +336,36 @@ int SProcDispatch (ClientPtr client)
|
|||
}
|
||||
}
|
||||
|
||||
/*=====================================================*/
|
||||
|
||||
|
||||
#define WRAP_INPUTPROC(dev,store,inputProc) \
|
||||
store->processInputProc = dev->public.processInputProc; \
|
||||
dev->public.processInputProc = inputProc; \
|
||||
store->realInputProc = dev->public.realInputProc; \
|
||||
dev->public.realInputProc = inputProc;
|
||||
|
||||
#define COND_WRAP_INPUTPROC(dev,store,inputProc) \
|
||||
if (dev->public.processInputProc == dev->public.realInputProc) \
|
||||
dev->public.processInputProc = inputProc; \
|
||||
store->processInputProc = \
|
||||
store->realInputProc = dev->public.realInputProc; \
|
||||
dev->public.realInputProc = inputProc;
|
||||
|
||||
#define UNWRAP_INPUTPROC(dev,restore) \
|
||||
dev->public.processInputProc = restore->processInputProc; \
|
||||
dev->public.realInputProc = restore->realInputProc;
|
||||
|
||||
#define UNWRAP_INPUTPROC(dev,restore) \
|
||||
dev->public.processInputProc = restore->processInputProc; \
|
||||
dev->public.realInputProc = restore->realInputProc;
|
||||
|
||||
#define XEVIE_EVENT(xE) \
|
||||
(xevieFlag \
|
||||
&& !xeviegrabState \
|
||||
&& clients[xevieClientIndex] \
|
||||
&& (xevieMask & xevieFilters[xE->u.u.type]))
|
||||
|
||||
|
||||
static void
|
||||
sendEvent(ClientPtr pClient, xEvent *xE)
|
||||
{
|
||||
if(pClient->swapped) {
|
||||
xEvent eventTo;
|
||||
|
||||
/* Remember to strip off the leading bit of type in case
|
||||
this event was sent with "SendEvent." */
|
||||
(*EventSwapVector[xE->u.u.type & 0177]) (xE, &eventTo);
|
||||
(void)WriteToClient(pClient, sizeof(xEvent), (char *)&eventTo);
|
||||
} else {
|
||||
(void)WriteToClient(pClient, sizeof(xEvent), (char *) xE);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
XevieKbdProcessInputProc(xEvent *xE, DeviceIntPtr dev, int count)
|
||||
{
|
||||
int key, bit;
|
||||
BYTE *kptr;
|
||||
ProcessInputProc tmp;
|
||||
KeyClassPtr keyc = dev->key;
|
||||
xevieDeviceInfoPtr xeviep = XEVIEINFO(dev);
|
||||
|
||||
if(XEVIE_EVENT(xE)) {
|
||||
ERR("XevieKbdProcessInputProc\n");
|
||||
|
||||
key = xE->u.u.detail;
|
||||
kptr = &keyc->down[key >> 3];
|
||||
bit = 1 << (key & 7);
|
||||
|
||||
/*
|
||||
* This is a horrible hack: with xkb on we must zero the modifiers
|
||||
* before sending an event sent back by xevie to
|
||||
* CoreProcessKeyboardEvent.
|
||||
* Since we cannot probe for xkb directly we need to check if the
|
||||
* modifers are set at this point. If they are we know that xkb
|
||||
* isn't active.
|
||||
*/
|
||||
if (dev->key->modifierMap[xE->u.u.detail])
|
||||
xevieModifiersOn = TRUE;
|
||||
|
||||
xE->u.keyButtonPointer.event = xeviewin->drawable.id;
|
||||
xE->u.keyButtonPointer.root = GetCurrentRootWindow()->drawable.id;
|
||||
xE->u.keyButtonPointer.child = (xeviewin->firstChild)
|
||||
? xeviewin->firstChild->drawable.id:0;
|
||||
xE->u.keyButtonPointer.rootX = xeviehot.x;
|
||||
xE->u.keyButtonPointer.rootY = xeviehot.y;
|
||||
xE->u.keyButtonPointer.state = keyc->state;
|
||||
/* fix bug: sequence lost in Xlib */
|
||||
xE->u.u.sequenceNumber = clients[xevieClientIndex]->sequence;
|
||||
sendEvent(clients[xevieClientIndex], xE);
|
||||
return;
|
||||
}
|
||||
|
||||
tmp = dev->public.realInputProc;
|
||||
UNWRAP_INPUTPROC(dev,xeviep);
|
||||
dev->public.processInputProc(xE,dev,count);
|
||||
COND_WRAP_INPUTPROC(dev,xeviep,tmp);
|
||||
}
|
||||
|
||||
static void
|
||||
XeviePointerProcessInputProc(xEvent *xE, DeviceIntPtr dev, int count)
|
||||
{
|
||||
xevieDeviceInfoPtr xeviep = XEVIEINFO(dev);
|
||||
ProcessInputProc tmp;
|
||||
|
||||
if (XEVIE_EVENT(xE)) {
|
||||
ERR("XeviePointerProcessInputProc\n");
|
||||
/* fix bug: sequence lost in Xlib */
|
||||
xE->u.u.sequenceNumber = clients[xevieClientIndex]->sequence;
|
||||
sendEvent(clients[xevieClientIndex], xE);
|
||||
return;
|
||||
}
|
||||
|
||||
tmp = dev->public.realInputProc;
|
||||
UNWRAP_INPUTPROC(dev,xeviep);
|
||||
dev->public.processInputProc(xE,dev,count);
|
||||
COND_WRAP_INPUTPROC(dev,xeviep,tmp);
|
||||
}
|
||||
|
||||
static Bool
|
||||
XevieStart(void)
|
||||
{
|
||||
ProcessInputProc prp;
|
||||
prp = XevieKbdProcessInputProc;
|
||||
if (!XevieAdd(inputInfo.keyboard,&prp))
|
||||
return FALSE;
|
||||
prp = XeviePointerProcessInputProc;
|
||||
if (!XevieAdd(inputInfo.pointer,&prp))
|
||||
return FALSE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
XevieEnd(int clientIndex)
|
||||
{
|
||||
if (!clientIndex || clientIndex == xevieClientIndex) {
|
||||
XevieRemove(inputInfo.keyboard,NULL);
|
||||
XevieRemove(inputInfo.pointer,NULL);
|
||||
xevieFlag = 0;
|
||||
xevieClientIndex = 0;
|
||||
DeleteCallback (&ClientStateCallback, XevieClientStateCallback, NULL);
|
||||
xevieFlag = 0;
|
||||
xevieClientIndex = 0;
|
||||
DeleteCallback (&ClientStateCallback, XevieClientStateCallback, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
XevieClientStateCallback(CallbackListPtr *pcbl, pointer nulldata,
|
||||
pointer calldata)
|
||||
pointer calldata)
|
||||
{
|
||||
NewClientInfoRec *pci = (NewClientInfoRec *)calldata;
|
||||
ClientPtr client = pci->client;
|
||||
if (client->clientState == ClientStateGone
|
||||
|| client->clientState == ClientStateRetained)
|
||||
XevieEnd(client->index);
|
||||
|| client->clientState == ClientStateRetained)
|
||||
XevieEnd(client->index);
|
||||
}
|
||||
|
||||
static void
|
||||
XevieServerGrabStateCallback(CallbackListPtr *pcbl, pointer nulldata,
|
||||
pointer calldata)
|
||||
pointer calldata)
|
||||
{
|
||||
ServerGrabInfoRec *grbinfo = (ServerGrabInfoRec *)calldata;
|
||||
if (grbinfo->grabstate == SERVER_GRABBED)
|
||||
xeviegrabState = TRUE;
|
||||
xeviegrabState = TRUE;
|
||||
else
|
||||
xeviegrabState = FALSE;
|
||||
xeviegrabState = FALSE;
|
||||
}
|
||||
|
||||
#define UNWRAP_UNWRAPPROC(device,proc_store) \
|
||||
device->unwrapProc = proc_store;
|
||||
|
||||
#define WRAP_UNWRAPPROC(device,proc_store,proc) \
|
||||
proc_store = device->unwrapProc; \
|
||||
device->unwrapProc = proc;
|
||||
|
||||
static void
|
||||
xevieUnwrapProc(DeviceIntPtr device, DeviceHandleProc proc, pointer data)
|
||||
{
|
||||
xevieDeviceInfoPtr xeviep = XEVIEINFO(device);
|
||||
ProcessInputProc tmp = device->public.processInputProc;
|
||||
|
||||
UNWRAP_INPUTPROC(device,xeviep);
|
||||
UNWRAP_UNWRAPPROC(device,xeviep->unwrapProc);
|
||||
proc(device,data);
|
||||
WRAP_INPUTPROC(device,xeviep,tmp);
|
||||
WRAP_UNWRAPPROC(device,xeviep->unwrapProc,xevieUnwrapProc);
|
||||
}
|
||||
|
||||
static Bool
|
||||
XevieUnwrapAdd(DeviceIntPtr device, void* data)
|
||||
{
|
||||
if (device->unwrapProc)
|
||||
device->unwrapProc(device,XevieUnwrapAdd,data);
|
||||
else {
|
||||
ProcessInputProc *ptr = data;
|
||||
XevieWrap(device,*ptr);
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static Bool
|
||||
XevieAdd(DeviceIntPtr device, void* data)
|
||||
{
|
||||
xevieDeviceInfoPtr xeviep;
|
||||
|
||||
if (!AllocateDevicePrivate(device, xevieDevicePrivateIndex))
|
||||
return FALSE;
|
||||
|
||||
xeviep = xcalloc (sizeof (xevieDeviceInfoRec),1);
|
||||
if (!xeviep)
|
||||
return FALSE;
|
||||
|
||||
device->devPrivates[xevieDevicePrivateIndex].ptr = xeviep;
|
||||
XevieUnwrapAdd(device, data);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static Bool
|
||||
XevieRemove(DeviceIntPtr device,pointer data)
|
||||
{
|
||||
xevieDeviceInfoPtr xeviep = XEVIEINFO(device);
|
||||
|
||||
if (!xeviep) return TRUE;
|
||||
|
||||
UNWRAP_INPUTPROC(device,xeviep);
|
||||
UNWRAP_UNWRAPPROC(device,xeviep->unwrapProc);
|
||||
|
||||
xfree(xeviep);
|
||||
device->devPrivates[xevieDevicePrivateIndex].ptr = NULL;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
XevieWrap(DeviceIntPtr device, ProcessInputProc proc)
|
||||
{
|
||||
xevieDeviceInfoPtr xeviep = XEVIEINFO(device);
|
||||
|
||||
WRAP_INPUTPROC(device,xeviep,proc);
|
||||
WRAP_UNWRAPPROC(device,xeviep->unwrapProc,xevieUnwrapProc);
|
||||
}
|
||||
|
||||
static void
|
||||
doSendEvent(xEvent *xE, DeviceIntPtr dev)
|
||||
{
|
||||
xevieDeviceInfoPtr xeviep = XEVIEINFO(dev);
|
||||
ProcessInputProc tmp = dev->public.realInputProc;
|
||||
if (((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))
|
||||
&& !xevieModifiersOn) {
|
||||
CARD8 realModes = dev->key->modifierMap[xE->u.u.detail];
|
||||
dev->key->modifierMap[xE->u.u.detail] = 0;
|
||||
|
||||
UNWRAP_INPUTPROC(dev,xeviep);
|
||||
dev->public.processInputProc(xE,dev,1);
|
||||
COND_WRAP_INPUTPROC(dev,xeviep,tmp);
|
||||
dev->key->modifierMap[xE->u.u.detail] = realModes;
|
||||
} else {
|
||||
UNWRAP_INPUTPROC(dev,xeviep);
|
||||
dev->public.processInputProc(xE,dev,1);
|
||||
COND_WRAP_INPUTPROC(dev,xeviep,tmp);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user