andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

dmx: remove dmx-internal event queue.

Browse Source 
The EQ is in the DIX now.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
This commit is contained in:
Peter Hutterer 2009-09-08 17:46:06 +10:00
parent 545f11139d
commit 2d46678762
6 changed files with 69 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
hw/dmx/dmxcursor.c
View File

@ -195,8 +195,8 @@ miPointerScreenFuncRec dmxPointerCursorFuncs =
dmxCursorOffScreen,
dmxCrossScreen,
dmxWarpCursor,
dmxeqEnqueue, /*XXX incompatible type/function! */
dmxeqSwitchScreen
NULL,
NULL,
};

4
hw/dmx/dmxinput.c
View File

@ -71,10 +71,6 @@ void InitInput(int argc, char **argv)
for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++)
dmxInputInit(dmxInput);
if (!dmxeqInitialized()) {
dmxLog(dmxWarning, "Use keyboard/mouse pair with the first -input\n");
dmxLog(dmxFatal, "At least one core keyboard/mouse pair required\n");
}
mieqInit();
}

2
hw/dmx/dmxinput.h
View File

@ -140,8 +140,6 @@ extern void dmxInputLogDevices(void);
extern void dmxUpdateWindowInfo(DMXUpdateType type, WindowPtr pWindow);
/* These functions are defined in input/dmxeq.c */
extern Bool dmxeqInitialized(void);
extern void dmxeqEnqueue(DeviceIntPtr pDev, xEvent *e);
extern void dmxeqSwitchScreen(DeviceIntPtr pDev, ScreenPtr pScreen, Bool fromDIX);
/* This type is used in input/dmxevents.c. Also, these functions are

206
hw/dmx/input/dmxeq.c
View File

@ -88,209 +88,3 @@
#define DMXDBG2(f,a,b)
#define DMXDBG5(f,a,b,c,d,e)
#endif
/** The size of our queue. (The queue provided by mi/mieq.c has a size
* of 256.) */
#define QUEUE_SIZE 256
/** Information about the event. */
typedef struct _Event {
xEvent event; /**< Event. */
ScreenPtr pScreen; /**< Screen on which event occurred. */
deviceValuator valuator; /**< XInput device valuator information. */
DeviceIntPtr pDev;
} EventRec, *EventPtr;
/** Event queue. */
typedef struct _EventQueue {
HWEventQueueType head; /**< Queue head; must be long for SetInputCheck. */
HWEventQueueType tail; /**< Queue tail; must be long for SetInputCheck. */
CARD32 lastEventTime; /**< To avoid time running backwards. */
Bool lastMotion; /**< True if last event was motion. */
EventRec events[QUEUE_SIZE]; /**< Static allocation for signals. */
DevicePtr pKbd, pPtr; /**< Device pointers (to get funcs) */
ScreenPtr pEnqueueScreen;/**< Screen events are delivered to. */
ScreenPtr pDequeueScreen;/**< Screen events are dispatched to. */
} EventQueueRec, *EventQueuePtr;
static EventQueueRec dmxEventQueue;
static Bool dmxeqInitializedFlag = FALSE;
Bool dmxeqInitialized(void)
{
return dmxeqInitializedFlag;
}
Bool dmxeqInit(DevicePtr pKbd, DevicePtr pPtr)
{
static unsigned long dmxGeneration = 0;
if (dmxGeneration == serverGeneration && dmxeqInitializedFlag)
return FALSE;
dmxGeneration = serverGeneration;
dmxeqInitializedFlag = TRUE;
dmxEventQueue.head = 0;
dmxEventQueue.tail = 0;
dmxEventQueue.lastEventTime = GetTimeInMillis();
dmxEventQueue.pKbd = pKbd;
dmxEventQueue.pPtr = pPtr;
dmxEventQueue.lastMotion = FALSE;
dmxEventQueue.pEnqueueScreen = screenInfo.screens[0];
dmxEventQueue.pDequeueScreen = dmxEventQueue.pEnqueueScreen;
SetInputCheck(&dmxEventQueue.head, &dmxEventQueue.tail);
return TRUE;
}
/**
* This function adds an event to the end of the queue. If the event is
* an XInput event, then the next event (the valuator event) is also
* stored in the queue. If the new event has a time before the time of
* the last event currently on the queue, then the time is updated for
* the new event.
*
* Must be reentrant with ProcessInputEvents. Assumption: dmxeqEnqueue
* will never be interrupted. If this is called from both signal
* handlers and regular code, make sure the signal is suspended when
* called from regular code.
*/
void dmxeqEnqueue(DeviceIntPtr pDev, xEvent *e)
{
HWEventQueueType oldtail, newtail;
Bool isMotion;
deviceKeyButtonPointer *ev;
oldtail = dmxEventQueue.tail;
isMotion = e->u.u.type == MotionNotify;
if (isMotion
&& dmxEventQueue.lastMotion
&& oldtail != dmxEventQueue.head) {
if (oldtail == 0) oldtail = QUEUE_SIZE;
oldtail = oldtail - 1;
} else {
newtail = oldtail + 1;
if (newtail == QUEUE_SIZE) newtail = 0;
/* Toss events which come in late */
if (newtail == dmxEventQueue.head) return;
dmxEventQueue.tail = newtail;
}
DMXDBG2("dmxeqEnqueue %d %d\n", dmxEventQueue.head, dmxEventQueue.tail);
dmxEventQueue.lastMotion = isMotion;
dmxEventQueue.events[oldtail].pScreen = dmxEventQueue.pEnqueueScreen;
/* Store the event in the queue */
dmxEventQueue.events[oldtail].event = *e;
dmxEventQueue.events[oldtail].pDev = pDev;
/* If this is an XInput event, store the
* valuator event, too */
ev = (deviceKeyButtonPointer *)e;
if (e->u.u.type >= LASTEvent && (ev->deviceid & MORE_EVENTS))
dmxEventQueue.events[oldtail].valuator = *(deviceValuator *)(ev+1);
/* Make sure that event times don't go
* backwards - this is "unnecessary",
* but very useful */
if (e->u.keyButtonPointer.time < dmxEventQueue.lastEventTime
&& dmxEventQueue.lastEventTime - e->u.keyButtonPointer.time < 10000) {
dmxEventQueue.events[oldtail].event.u.keyButtonPointer.time =
dmxEventQueue.lastEventTime;
}
}
/** Make \a pScreen the new screen for enqueueing events. If \a fromDIX
* is TRUE, also make \a pScreen the new screen for dequeuing events. */
void dmxeqSwitchScreen(DeviceIntPtr pDev, ScreenPtr pScreen, Bool fromDIX)
{
dmxEventQueue.pEnqueueScreen = pScreen;
if (fromDIX) dmxEventQueue.pDequeueScreen = pScreen;
}
static void dmxeqProcessXInputEvent(xEvent *xe, EventRec *e)
{
deviceKeyButtonPointer *ev = (deviceKeyButtonPointer *)xe;
int id = ev->deviceid & DEVICE_BITS;
DeviceIntPtr pDevice;
dixLookupDevice(&pDevice, id, serverClient, DixUnknownAccess);
if (!pDevice) {
dmxLog(dmxError, "dmxeqProcessInputEvents: id %d not found\n", id);
return;
}
if (!pDevice->public.processInputProc) {
dmxLog(dmxError,
"dmxeqProcessInputEvents: no processInputProc for"
" device id %d (%s)\n", id, pDevice->name);
return;
}
if (ev->deviceid & MORE_EVENTS) {
xe[1] = *(xEvent *)(&e->valuator);
pDevice->public.processInputProc(xe, pDevice, 2);
} else {
pDevice->public.processInputProc(xe, pDevice, 1);
}
}
/**
* This function is called from #ProcessInputEvents() to remove events
* from the queue and process them.
*/
void dmxeqProcessInputEvents(void)
{
EventRec *e;
int x, y;
xEvent xe[2];
while (dmxEventQueue.head != dmxEventQueue.tail) {
dmxDPMSWakeup(); /* Handles screen saver and DPMS */
e = &dmxEventQueue.events[dmxEventQueue.head];
DMXDBG5("dmxeqProcessInputEvents: type=%d screen=%p,%p root=%d,%d\n",
e->event.u.u.type,
e->pScreen, dmxEventQueue.pDequeueScreen,
e->event.u.keyButtonPointer.rootX,
e->event.u.keyButtonPointer.rootY);
/*
* Assumption - screen switching can only occur on core motion events
*/
if (e->event.u.u.type == MotionNotify
&& e->pScreen != dmxEventQueue.pDequeueScreen) {
dmxEventQueue.pDequeueScreen = e->pScreen;
x = e->event.u.keyButtonPointer.rootX;
y = e->event.u.keyButtonPointer.rootY;
if (dmxEventQueue.head == QUEUE_SIZE - 1) dmxEventQueue.head = 0;
else ++dmxEventQueue.head;
NewCurrentScreen(e->pDev, dmxEventQueue.pDequeueScreen, x, y);
} else {
xe[0] = e->event;
if (dmxEventQueue.head == QUEUE_SIZE - 1) dmxEventQueue.head = 0;
else ++dmxEventQueue.head;
switch (xe[0].u.u.type) {
case KeyPress:
case KeyRelease:
if (!dmxEventQueue.pKbd) {
dmxLog(dmxError, "dmxeqProcessInputEvents: No keyboard\n");
return;
}
dmxEventQueue.pKbd
->processInputProc(xe,
(DeviceIntPtr)dmxEventQueue.pKbd, 1);
break;
default:
dmxeqProcessXInputEvent(xe, e);
break;
case ButtonPress:
case ButtonRelease:
case MotionNotify:
if (!dmxEventQueue.pPtr) {
dmxLog(dmxError, "dmxeqProcessInputEvents: No mouse\n");
return;
}
dmxEventQueue.pPtr
->processInputProc(xe,
(DeviceIntPtr)dmxEventQueue.pPtr, 1);
break;
}
}
}
}

152
hw/dmx/input/dmxevents.c
View File

@ -155,59 +155,6 @@ static int dmxCheckFunctionKeys(DMXLocalInputInfoPtr dmxLocal,
return 0;
}
static void dmxEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal, xEvent *e,
DMXBlockType block)
{
xEvent xE[2];
deviceKeyButtonPointer *xev = (deviceKeyButtonPointer *)xE;
deviceValuator *xv = (deviceValuator *)xev+1;
DeviceIntPtr pDevice = dmxLocal->pDevice;
DMXInputInfo *dmxInput = &dmxInputs[dmxLocal->inputIdx];
int type = e->u.u.type;
switch (e->u.u.type) {
case KeyPress:
type = DeviceKeyPress;
break;
case KeyRelease:
type = DeviceKeyRelease;
break;
case ButtonPress:
type = DeviceButtonPress;
break;
case ButtonRelease:
type = DeviceButtonRelease;
break;
case MotionNotify:
dmxLog(dmxError,
"dmxEnqueueExtEvent: MotionNotify not allowed here\n");
return;
default:
if (e->u.u.type == ProximityIn || e->u.u.type == ProximityOut)
break;
dmxLogInput(dmxInput,
"dmxEnqueueExtEvent: Unhandled %s event (%d)\n",
e->u.u.type >= LASTEvent ? "extension" : "non-extension",
e->u.u.type);
return;
}
xev->type = type;
xev->detail = e->u.u.detail;
xev->deviceid = pDevice->id | MORE_EVENTS;
xev->time = e->u.keyButtonPointer.time;
xv->type = DeviceValuator;
xv->deviceid = pDevice->id;
xv->num_valuators = 0;
xv->first_valuator = 0;
if (block)
dmxSigioBlock();
dmxeqEnqueue(pDevice, xE);
if (block)
dmxSigioUnblock();
}
DMXScreenInfo *dmxFindFirstScreen(int x, int y)
{
@ -291,7 +238,7 @@ dmxCoreMotion(DevicePtr pDev, int x, int y, int delta, DMXBlockType block)
pScreen->myNum, dmxScreen->index, localX, localY);
if (block)
dmxSigioBlock();
dmxeqProcessInputEvents();
mieqProcessInputEvents();
miPointerSetScreen(inputInfo.pointer, dmxScreen->index,
localX, localY);
if (pDev)
@ -344,6 +291,8 @@ static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
int thisY = 0;
int i;
int count;
EventListPtr events;
int nevents;
memset(xE, 0, sizeof(xE));
@ -422,8 +371,12 @@ static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
if (block)
dmxSigioBlock();
dmxPointerPutMotionEvent(pDevice, firstAxis, axesCount, v, xev->time);
dmxeqEnqueue(pDevice, xE);
GetEventList(&events);
nevents = GetPointerEvents(events, pDevice, MotionNotify, 0, POINTER_ABSOLUTE,
firstAxis, axesCount, v);
for (i = 0; i < nevents; i++)
mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
if (block)
dmxSigioUnblock();
}
@ -431,14 +384,14 @@ static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
XEvent *e, DMXBlockType block)
{
xEvent xE[2];
deviceKeyButtonPointer *xev = (deviceKeyButtonPointer *)xE;
deviceValuator *xv = (deviceValuator *)xev+1;
int type;
int event = -1;
XDeviceKeyEvent *ke = (XDeviceKeyEvent *)e;
XDeviceMotionEvent *me = (XDeviceMotionEvent *)e;
DeviceIntPtr pDevice = dmxLocal->pDevice;
int valuators[6];
EventListPtr events;
int nevents, i;
if (!e)
return -1; /* No extended event passed, cannot handle */
@ -463,11 +416,11 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
switch (type) {
case XI_DeviceValuator: event = DeviceValuator; break;
case XI_DeviceKeyPress: event = DeviceKeyPress; break;
case XI_DeviceKeyRelease: event = DeviceKeyRelease; break;
case XI_DeviceButtonPress: event = DeviceButtonPress; break;
case XI_DeviceButtonRelease: event = DeviceButtonRelease; break;
case XI_DeviceMotionNotify: event = DeviceMotionNotify; break;
case XI_DeviceKeyPress: event = KeyPress; break;
case XI_DeviceKeyRelease: event = KeyRelease; break;
case XI_DeviceButtonPress: event = ButtonPress; break;
case XI_DeviceButtonRelease: event = ButtonRelease; break;
case XI_DeviceMotionNotify: event = MotionNotify; break;
case XI_DeviceFocusIn: event = DeviceFocusIn; break;
case XI_DeviceFocusOut: event = DeviceFocusOut; break;
case XI_ProximityIn: event = ProximityIn; break;
@ -479,35 +432,62 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
case XI_DeviceButtonstateNotify: event = DeviceStateNotify; break;
}
#define EXTRACT_VALUATORS(ke, valuators) \
valuators[0] = ke->axis_data[0]; \
valuators[1] = ke->axis_data[1]; \
valuators[2] = ke->axis_data[2]; \
valuators[3] = ke->axis_data[3]; \
valuators[4] = ke->axis_data[4]; \
valuators[5] = ke->axis_data[5]; \
switch (type) {
case XI_DeviceKeyPress:
case XI_DeviceKeyPress:
case XI_DeviceKeyRelease:
case XI_DeviceButtonPress:
case XI_DeviceButtonRelease:
case XI_ProximityIn:
case XI_ProximityOut:
xev->type = event;
xev->detail = ke->keycode; /* same as ->button */
xev->deviceid = dmxLocal->pDevice->id | MORE_EVENTS;
xev->time = GetTimeInMillis();
xv->type = DeviceValuator;
xv->deviceid = dmxLocal->pDevice->id;
xv->num_valuators = ke->axes_count;
xv->first_valuator = ke->first_axis;
xv->valuator0 = ke->axis_data[0];
xv->valuator1 = ke->axis_data[1];
xv->valuator2 = ke->axis_data[2];
xv->valuator3 = ke->axis_data[3];
xv->valuator4 = ke->axis_data[4];
xv->valuator5 = ke->axis_data[5];
EXTRACT_VALUATORS(ke, valuators);
if (block)
dmxSigioBlock();
dmxeqEnqueue(pDevice, xE);
GetEventList(&events);
nevents = GetKeyboardValuatorEvents(events, pDevice, event,
ke->keycode, ke->first_axis,
ke->axes_count, valuators);
for (i = 0; i < nevents; i++)
mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
if (block)
dmxSigioUnblock();
break;
case XI_DeviceButtonPress:
case XI_DeviceButtonRelease:
EXTRACT_VALUATORS(ke, valuators);
if (block)
dmxSigioBlock();
GetEventList(&events);
nevents = GetPointerEvents(events, pDevice, event, ke->keycode,
POINTER_ABSOLUTE, ke->first_axis,
ke->axes_count, valuators);
for (i = 0; i < nevents; i++)
mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
if (block)
dmxSigioUnblock();
break;
case XI_ProximityIn:
case XI_ProximityOut:
EXTRACT_VALUATORS(ke, valuators);
if (block)
dmxSigioBlock();
GetEventList(&events);
nevents = GetProximityEvents(events, pDevice, event,
ke->first_axis, ke->axes_count,
valuators);
for (i = 0; i < nevents; i++)
mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
if (block)
dmxSigioUnblock();
break;
break;
case XI_DeviceMotionNotify:
dmxExtMotion(dmxLocal, me->axis_data, me->first_axis, me->axes_count,

8
hw/dmx/input/dmxinputinit.c
View File

@ -545,7 +545,7 @@ static void dmxProcessInputEvents(DMXInputInfo *dmxInput)
{
int i;
dmxeqProcessInputEvents();
mieqProcessInputEvents();
#if 00 /*BP*/
miPointerUpdate();
#endif
@ -1071,12 +1071,6 @@ void dmxInputInit(DMXInputInfo *dmxInput)
}
}
if (pPointer && pKeyboard) {
if (dmxeqInit(&pKeyboard->public, &pPointer->public))
dmxLogInput(dmxInput, "Using %s and %s as true core devices\n",
pKeyboard->name, pPointer->name);
}
dmxInput->processInputEvents = dmxProcessInputEvents;
dmxInput->detached = False;