summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--dix/getevents.c54
-rw-r--r--hw/kdrive/src/kinput.c10
-rw-r--r--hw/xfree86/common/xf86DGA.c46
-rw-r--r--hw/xfree86/common/xf86Events.c13
-rw-r--r--hw/xfree86/common/xf86Xinput.c21
-rw-r--r--include/input.h3
-rw-r--r--mi/mi.h1
-rw-r--r--mi/mieq.c152
8 files changed, 132 insertions, 168 deletions
diff --git a/dix/getevents.c b/dix/getevents.c
index 4f9608053..42b9df9d2 100644
--- a/dix/getevents.c
+++ b/dix/getevents.c
@@ -481,19 +481,19 @@ GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
xv->deviceid = kbp->deviceid;
switch (final_valuator - i) {
case 6:
- xv->valuator5 = valuators[i+5];
+ xv->valuator5 = valuators[i + 5];
case 5:
- xv->valuator4 = valuators[i+4];
+ xv->valuator4 = valuators[i + 4];
case 4:
- xv->valuator3 = valuators[i+3];
+ xv->valuator3 = valuators[i + 3];
case 3:
- xv->valuator2 = valuators[i+2];
+ xv->valuator2 = valuators[i + 2];
case 2:
/* x and y may have been accelerated. */
if (i == 0)
xv->valuator1 = kbp->root_y;
else
- xv->valuator1 = valuators[i+1];
+ xv->valuator1 = valuators[i + 1];
case 1:
/* x and y may have been accelerated. */
if (i == 0)
@@ -520,11 +520,47 @@ GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
else {
events->u.u.detail = 0;
}
-
- if (inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr !=
- pDev)
- inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr = pDev;
}
return num_events;
}
+
+void SwitchCoreKeyboard(DeviceIntPtr pDev)
+{
+ KeyClassPtr ckeyc = inputInfo.keyboard->key;
+
+ if (inputInfo.keyboard->devPrivates[CoreDevicePrivatesIndex].ptr != pDev) {
+ memcpy(ckeyc->modifierMap, pDev->key->modifierMap, MAP_LENGTH);
+ if (ckeyc->modifierKeyMap)
+ xfree(ckeyc->modifierKeyMap);
+ ckeyc->modifierKeyMap = xalloc(8 * pDev->key->maxKeysPerModifier);
+ memcpy(ckeyc->modifierKeyMap, pDev->key->modifierKeyMap,
+ (8 * pDev->key->maxKeysPerModifier));
+
+ ckeyc->maxKeysPerModifier = pDev->key->maxKeysPerModifier;
+ ckeyc->curKeySyms.minKeyCode = pDev->key->curKeySyms.minKeyCode;
+ ckeyc->curKeySyms.maxKeyCode = pDev->key->curKeySyms.maxKeyCode;
+ SetKeySymsMap(&ckeyc->curKeySyms, &pDev->key->curKeySyms);
+
+#ifdef XKB
+ if (!noXkbExtension && pDev->key->xkbInfo && pDev->key->xkbInfo->desc) {
+ if (!XkbCopyKeymap(pDev->key->xkbInfo->desc, ckeyc->xkbInfo->desc,
+ True))
+ FatalError("Couldn't pivot keymap from device to core!\n");
+ }
+#endif
+
+ SendMappingNotify(MappingKeyboard, ckeyc->curKeySyms.minKeyCode,
+ (ckeyc->curKeySyms.maxKeyCode -
+ ckeyc->curKeySyms.minKeyCode),
+ serverClient);
+ inputInfo.keyboard->devPrivates[CoreDevicePrivatesIndex].ptr = pDev;
+ }
+}
+
+/* Currently a no-op. */
+void SwitchCorePointer(DeviceIntPtr pDev)
+{
+ if (inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr != pDev)
+ inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr = pDev;
+}
diff --git a/hw/kdrive/src/kinput.c b/hw/kdrive/src/kinput.c
index 8dd372829..449be9e06 100644
--- a/hw/kdrive/src/kinput.c
+++ b/hw/kdrive/src/kinput.c
@@ -1656,10 +1656,10 @@ char *kdActionNames[] = {
#endif
static void
-KdQueueEvent (xEvent *ev)
+KdQueueEvent (DeviceIntPtr pDev, xEvent *ev)
{
KdAssertSigioBlocked ("KdQueueEvent");
- mieqEnqueue (ev);
+ mieqEnqueue (pDev, ev);
}
/* We return true if we're stealing the event. */
@@ -1862,7 +1862,7 @@ KdReleaseAllKeys (void)
KdHandleKeyboardEvent(ki, KeyRelease, key);
nEvents = GetKeyboardEvents(kdEvents, ki->dixdev, KeyRelease, key);
for (i = 0; i < nEvents; i++)
- KdQueueEvent (kdEvents + i);
+ KdQueueEvent (ki->dixdev, kdEvents + i);
}
}
}
@@ -1934,7 +1934,7 @@ KdEnqueueKeyboardEvent(KdKeyboardInfo *ki,
ErrorF("KdEnqueueKeyboardEvent: got %d events from GKE\n", nEvents);
#endif
for (i = 0; i < nEvents; i++)
- KdQueueEvent(kdEvents + i);
+ KdQueueEvent(ki->dixdev, kdEvents + i);
}
else {
ErrorF("driver %s wanted to post scancode %d outside of [%d, %d]!\n",
@@ -2052,7 +2052,7 @@ _KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,
nEvents = GetPointerEvents(kdEvents, pi->dixdev, type, b, absrel, 0, 3,
valuators);
for (i = 0; i < nEvents; i++)
- KdQueueEvent(kdEvents + i);
+ KdQueueEvent(pi->dixdev, kdEvents + i);
}
void
diff --git a/hw/xfree86/common/xf86DGA.c b/hw/xfree86/common/xf86DGA.c
index cb7783994..204457fb1 100644
--- a/hw/xfree86/common/xf86DGA.c
+++ b/hw/xfree86/common/xf86DGA.c
@@ -909,22 +909,6 @@ DGAVTSwitch(void)
Bool
DGAStealKeyEvent(int index, xEvent *e)
{
- DGAScreenPtr pScreenPriv;
- dgaEvent de;
-
- if(DGAScreenIndex < 0) /* no DGA */
- return FALSE;
-
- pScreenPriv = DGA_GET_SCREEN_PRIV(screenInfo.screens[index]);
-
- if(!pScreenPriv || !pScreenPriv->grabKeyboard) /* no direct mode */
- return FALSE;
-
- de.u.u.type = e->u.u.type + *XDGAEventBase;
- de.u.u.detail = e->u.u.detail;
- de.u.event.time = e->u.keyButtonPointer.time;
- mieqEnqueue ((xEvent *) &de);
- return TRUE;
}
static int DGAMouseX, DGAMouseY;
@@ -932,36 +916,6 @@ static int DGAMouseX, DGAMouseY;
Bool
DGAStealMouseEvent(int index, xEvent *e, int dx, int dy)
{
- DGAScreenPtr pScreenPriv;
- dgaEvent de;
-
- if(DGAScreenIndex < 0) /* no DGA */
- return FALSE;
-
- pScreenPriv = DGA_GET_SCREEN_PRIV(screenInfo.screens[index]);
-
- if(!pScreenPriv || !pScreenPriv->grabMouse) /* no direct mode */
- return FALSE;
-
- DGAMouseX += dx;
- if (DGAMouseX < 0)
- DGAMouseX = 0;
- else if (DGAMouseX > screenInfo.screens[index]->width)
- DGAMouseX = screenInfo.screens[index]->width;
- DGAMouseY += dy;
- if (DGAMouseY < 0)
- DGAMouseY = 0;
- else if (DGAMouseY > screenInfo.screens[index]->height)
- DGAMouseY = screenInfo.screens[index]->height;
- de.u.u.type = e->u.u.type + *XDGAEventBase;
- de.u.u.detail = e->u.u.detail;
- de.u.event.time = e->u.keyButtonPointer.time;
- de.u.event.dx = dx;
- de.u.event.dy = dy;
- de.u.event.pad1 = DGAMouseX;
- de.u.event.pad2 = DGAMouseY;
- mieqEnqueue ((xEvent *) &de);
- return TRUE;
}
Bool
diff --git a/hw/xfree86/common/xf86Events.c b/hw/xfree86/common/xf86Events.c
index db259b3b2..3df201aa7 100644
--- a/hw/xfree86/common/xf86Events.c
+++ b/hw/xfree86/common/xf86Events.c
@@ -104,19 +104,12 @@ extern Bool noXkbExtension;
#define XE_POINTER 1
#define XE_KEYBOARD 2
-#define __EqEnqueue(ev) mieqEnqueue(ev)
-
-#define EqEnqueue(ev) { \
+#define EqEnqueue(pDev, ev) { \
int __sigstate = xf86BlockSIGIO (); \
- __EqEnqueue (ev); \
+ mieqEnqueue (pDev, ev); \
xf86UnblockSIGIO(__sigstate); \
}
-#define ENQUEUE(ev, code, direction, dev_type) \
- (ev)->u.u.detail = (code); \
- (ev)->u.u.type = (direction); \
- EqEnqueue((ev))
-
/*
* The first of many hacks to get VT switching to work under
* Solaris 2.1 for x86. The basic problem is that Solaris is supposed
@@ -839,7 +832,7 @@ xf86ReleaseKeys(DeviceIntPtr pDev)
else {
nevents = GetKeyboardEvents(xf86Events, pDev, KeyRelease, i);
for (j = 0; j < nevents; j++)
- mieqEnqueue(xf86Events + i);
+ EqEnqueue(pDev, xf86Events + i);
}
break;
}
diff --git a/hw/xfree86/common/xf86Xinput.c b/hw/xfree86/common/xf86Xinput.c
index 411deddab..97c038f7b 100644
--- a/hw/xfree86/common/xf86Xinput.c
+++ b/hw/xfree86/common/xf86Xinput.c
@@ -656,20 +656,7 @@ xf86PostMotionEvent(DeviceIntPtr device,
valuators);
for (i = 0; i < nevents; i++)
- mieqEnqueue(xf86Events + i);
-
-#if 0
- if (HAS_MOTION_HISTORY(local)) {
- buff = ((char *)local->motion_history +
- (sizeof(INT32) * local->dev->valuator->numAxes + sizeof(Time)) * local->last);
- }
-
- if (HAS_MOTION_HISTORY(local)) {
- local->last = (local->last + 1) % device->valuator->numMotionEvents;
- if (local->last == local->first)
- local->first = (local->first + 1) % device->valuator->numMotionEvents;
- }
-#endif
+ mieqEnqueue(device, xf86Events + i);
}
_X_EXPORT void
@@ -795,7 +782,7 @@ xf86PostButtonEvent(DeviceIntPtr device,
first_valuator, num_valuators, valuators);
for (i = 0; i < nevents; i++)
- mieqEnqueue(xf86Events + i);
+ mieqEnqueue(device, xf86Events + i);
}
_X_EXPORT void
@@ -839,7 +826,7 @@ xf86PostKeyEvent(DeviceIntPtr device,
}
for (i = 0; i < nevents; i++)
- mieqEnqueue(xf86Events + i);
+ mieqEnqueue(device, xf86Events + i);
}
_X_EXPORT void
@@ -858,7 +845,7 @@ xf86PostKeyboardEvent(DeviceIntPtr device,
is_down ? KeyPress : KeyRelease, key_code);
for (i = 0; i < nevents; i++)
- mieqEnqueue(xf86Events + i);
+ mieqEnqueue(device, xf86Events + i);
}
/*
diff --git a/include/input.h b/include/input.h
index 3e3d16d2b..a9eeb3f62 100644
--- a/include/input.h
+++ b/include/input.h
@@ -406,6 +406,9 @@ extern int GetKeyboardValuatorEvents(
int num_valuator,
int *valuators);
+extern void SwitchCoreKeyboard(DeviceIntPtr pDev);
+extern void SwitchCorePointer(DeviceIntPtr pDev);
+
extern DeviceIntPtr LookupDeviceIntRec(
CARD8 deviceid);
diff --git a/mi/mi.h b/mi/mi.h
index 89d460fb7..8d9d120bd 100644
--- a/mi/mi.h
+++ b/mi/mi.h
@@ -173,6 +173,7 @@ extern Bool mieqInit(
);
extern void mieqEnqueue(
+ DeviceIntPtr /*pDev*/,
xEventPtr /*e*/
);
diff --git a/mi/mieq.c b/mi/mieq.c
index 16e638c64..0ac68d6e8 100644
--- a/mi/mieq.c
+++ b/mi/mieq.c
@@ -73,14 +73,14 @@ typedef struct _EventQueue {
static EventQueueRec miEventQueue;
Bool
-mieqInit ()
+mieqInit()
{
miEventQueue.head = miEventQueue.tail = 0;
miEventQueue.lastEventTime = GetTimeInMillis ();
miEventQueue.lastMotion = FALSE;
miEventQueue.pEnqueueScreen = screenInfo.screens[0];
miEventQueue.pDequeueScreen = miEventQueue.pEnqueueScreen;
- SetInputCheck (&miEventQueue.head, &miEventQueue.tail);
+ SetInputCheck(&miEventQueue.head, &miEventQueue.tail);
return TRUE;
}
@@ -92,57 +92,39 @@ mieqInit ()
*/
void
-mieqEnqueue (xEvent *e)
+mieqEnqueue(DeviceIntPtr pDev, xEvent *e)
{
HWEventQueueType oldtail = miEventQueue.tail, newtail;
int isMotion = 0;
- DeviceIntPtr pDev = NULL;
- deviceKeyButtonPointer *kbp = (deviceKeyButtonPointer *) e;
deviceValuator *v = (deviceValuator *) e;
EventPtr laste = &miEventQueue.events[oldtail - 1];
deviceKeyButtonPointer *lastkbp = (deviceKeyButtonPointer *)
&laste->event[0];
- if (e->u.u.type == MotionNotify) {
- pDev = inputInfo.pointer;
- isMotion = inputInfo.pointer->id & DEVICE_BITS;
- }
- else if (e->u.u.type == KeyPress || e->u.u.type == KeyRelease) {
- pDev = inputInfo.keyboard;
- }
- else if (e->u.u.type == ButtonPress || e->u.u.type == ButtonRelease) {
- pDev = inputInfo.pointer;
- }
- else {
- pDev = LookupDeviceIntRec(kbp->deviceid & DEVICE_BITS);
-
- /* We silently steal valuator events: just tack them on to the last
- * motion event they need to be attached to. Sigh. */
- if (e->u.u.type == DeviceValuator) {
- if (laste->nevents > 6) {
- ErrorF("mieqEnqueue: more than six valuator events; dropping.\n");
- return;
- }
- if (oldtail == miEventQueue.head ||
- !(lastkbp->type == DeviceMotionNotify ||
- lastkbp->type == DeviceButtonPress ||
- lastkbp->type == DeviceButtonRelease) ||
- ((lastkbp->deviceid & DEVICE_BITS) !=
- (v->deviceid & DEVICE_BITS))) {
- ErrorF("mieqEnequeue: out-of-order valuator event; dropping.\n");
- return;
- }
- memcpy(&(laste->event[laste->nevents++]), e, sizeof(xEvent));
+ if (e->u.u.type == MotionNotify)
+ isMotion = inputInfo.pointer->id;
+ else if (e->u.u.type == DeviceMotionNotify)
+ isMotion = pDev->id;
+
+ /* We silently steal valuator events: just tack them on to the last
+ * motion event they need to be attached to. Sigh. */
+ if (e->u.u.type == DeviceValuator) {
+ if (laste->nevents > 6) {
+ ErrorF("mieqEnqueue: more than six valuator events; dropping.\n");
return;
}
- else if (e->u.u.type == DeviceMotionNotify) {
- isMotion = pDev->id & DEVICE_BITS;
+ if (oldtail == miEventQueue.head ||
+ !(lastkbp->type == DeviceMotionNotify ||
+ lastkbp->type == DeviceButtonPress ||
+ lastkbp->type == DeviceButtonRelease) ||
+ (lastkbp->deviceid != v->deviceid)) {
+ ErrorF("mieqEnequeue: out-of-order valuator event; dropping.\n");
+ return;
}
+ memcpy(&(laste->event[laste->nevents++]), e, sizeof(xEvent));
+ return;
}
- if (!pDev)
- FatalError("Couldn't find device for event!\n");
-
if (isMotion && isMotion == miEventQueue.lastMotion &&
oldtail != miEventQueue.head) {
if (oldtail == 0)
@@ -164,10 +146,8 @@ mieqEnqueue (xEvent *e)
memcpy(&(miEventQueue.events[oldtail].event[0]), e, sizeof(xEvent));
miEventQueue.events[oldtail].nevents = 1;
- /*
- * Make sure that event times don't go backwards - this
- * is "unnecessary", but very useful
- */
+ /* Make sure that event times don't go backwards - this
+ * is "unnecessary", but very useful. */
if (e->u.keyButtonPointer.time < miEventQueue.lastEventTime &&
miEventQueue.lastEventTime - e->u.keyButtonPointer.time < 10000)
miEventQueue.events[oldtail].event[0].u.keyButtonPointer.time =
@@ -182,49 +162,59 @@ mieqEnqueue (xEvent *e)
}
void
-mieqSwitchScreen (ScreenPtr pScreen, Bool fromDIX)
+mieqSwitchScreen(ScreenPtr pScreen, Bool fromDIX)
{
miEventQueue.pEnqueueScreen = pScreen;
if (fromDIX)
miEventQueue.pDequeueScreen = pScreen;
}
-/*
- * Call this from ProcessInputEvents()
- */
-
-void mieqProcessInputEvents ()
+/* Call this from ProcessInputEvents(). */
+void
+mieqProcessInputEvents()
{
- EventRec *e;
- int x, y;
-
- while (miEventQueue.head != miEventQueue.tail)
- {
- if (screenIsSaved == SCREEN_SAVER_ON)
- SaveScreens (SCREEN_SAVER_OFF, ScreenSaverReset);
-
- e = &miEventQueue.events[miEventQueue.head];
- /*
- * Assumption - screen switching can only occur on motion events
- */
- if (e->pScreen != miEventQueue.pDequeueScreen)
- {
- miEventQueue.pDequeueScreen = e->pScreen;
- x = e->event[0].u.keyButtonPointer.rootX;
- y = e->event[0].u.keyButtonPointer.rootY;
- if (miEventQueue.head == QUEUE_SIZE - 1)
- miEventQueue.head = 0;
- else
- ++miEventQueue.head;
- NewCurrentScreen (miEventQueue.pDequeueScreen, x, y);
- }
- else
- {
- if (miEventQueue.head == QUEUE_SIZE - 1)
- miEventQueue.head = 0;
- else
- ++miEventQueue.head;
- (*e->pDev->public.processInputProc)(e->event, e->pDev, e->nevents);
- }
+ EventRec *e = NULL;
+ int x = 0, y = 0;
+ DeviceIntPtr dev = NULL;
+
+ while (miEventQueue.head != miEventQueue.tail) {
+ if (screenIsSaved == SCREEN_SAVER_ON)
+ SaveScreens (SCREEN_SAVER_OFF, ScreenSaverReset);
+
+ e = &miEventQueue.events[miEventQueue.head];
+ /* Assumption - screen switching can only occur on motion events. */
+ if (e->pScreen != miEventQueue.pDequeueScreen) {
+ miEventQueue.pDequeueScreen = e->pScreen;
+ x = e->event[0].u.keyButtonPointer.rootX;
+ y = e->event[0].u.keyButtonPointer.rootY;
+ if (miEventQueue.head == QUEUE_SIZE - 1)
+ miEventQueue.head = 0;
+ else
+ ++miEventQueue.head;
+ NewCurrentScreen (miEventQueue.pDequeueScreen, x, y);
+ }
+ else {
+ if (miEventQueue.head == QUEUE_SIZE - 1)
+ miEventQueue.head = 0;
+ else
+ ++miEventQueue.head;
+
+ if (e->event[0].u.u.type == KeyPress ||
+ e->event[0].u.u.type == KeyRelease) {
+ SwitchCoreKeyboard(e->pDev);
+ dev = inputInfo.keyboard;
+ }
+ else if (e->event[0].u.u.type == MotionNotify ||
+ e->event[0].u.u.type == ButtonPress ||
+ e->event[0].u.u.type == ButtonRelease) {
+ SwitchCorePointer(e->pDev);
+ dev = inputInfo.pointer;
+ }
+ else {
+ dev = e->pDev;
+ }
+
+ dev->public.processInputProc(e->event, dev, e->nevents);
+ }
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-19 08:37:09 +0000