void mieqProcessInputEvents()
{
EventRec *e;
int x, y;
xEvent xe;
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.u.keyButtonPointer.rootX;
y = e->event.u.keyButtonPointer.rootY;
if (miEventQueue.head == QUEUE_SIZE - 1)
miEventQueue.head = 0;
else
++miEventQueue.head;
NewCurrentScreen (miEventQueue.pDequeueScreen, x, y);
}
else
{
xe = e->event;
if (miEventQueue.head == QUEUE_SIZE - 1)
miEventQueue.head = 0;
else
++miEventQueue.head;
switch (xe.u.u.type)
{
case KeyPress:
case KeyRelease:
(*miEventQueue.pKbd->processInputProc)
(&xe, (DeviceIntPtr)miEventQueue.pKbd, 1);
break;
default:
(*miEventQueue.pPtr->processInputProc)
(&xe, (DeviceIntPtr)miEventQueue.pPtr, 1);
break;
}
}
}
}
void
miPointerSetScreen(DeviceIntPtr pDev, int screen_no, int x, int y)
{
miPointerScreenPtr pScreenPriv;
ScreenPtr pScreen;
miPointerPtr pPointer;
pPointer = MIPOINTER(pDev);
pScreen = screenInfo.screens[screen_no];
pScreenPriv = GetScreenPrivate (pScreen);
(*pScreenPriv->screenFuncs->NewEventScreen) (pDev, pScreen, FALSE);
NewCurrentScreen (pDev, pScreen, x, y);
pPointer->limits.x2 = pScreen->width;
pPointer->limits.y2 = pScreen->height;
}
/*
* DESCRIPTION:
*
* This routine processes the simulation of some input event.
*
*/
int XETrapSimulateXEvent(register xXTrapInputReq *request,
register ClientPtr client)
{
ScreenPtr pScr = NULL;
int status = Success;
xEvent xev;
register int x = request->input.x;
register int y = request->input.y;
DevicePtr keydev = LookupKeyboardDevice();
DevicePtr ptrdev = LookupPointerDevice();
if (request->input.screen < screenInfo.numScreens)
{
pScr = screenInfo.screens[request->input.screen];
}
else
{ /* Trying to play bogus events to this WS! */
#ifdef VERBOSE
ErrorF("%s: Trying to send events to screen %d!\n", XTrapExtName,
request->input.screen);
#endif
status = XETrapErrorBase + BadScreen;
}
/* Fill in the event structure with the information
* Note: root, event, child, eventX, eventY, state, and sameScreen
* are all updated by FixUpEventFromWindow() when the events
* are delivered via DeliverDeviceEvents() or whatever. XTrap
* needs to only concern itself with type, detail, time, rootX,
* and rootY.
*/
if (status == Success)
{
xev.u.u.type = request->input.type;
xev.u.u.detail = request->input.detail;
xev.u.keyButtonPointer.time = GetTimeInMillis();
xev.u.keyButtonPointer.rootX = x;
xev.u.keyButtonPointer.rootY = y;
if (request->input.type == MotionNotify)
{ /* Set new cursor position on screen */
XETrap_avail.data.cur_x = x;
XETrap_avail.data.cur_y = y;
NewCurrentScreen (pScr, x, y); /* fix from [email protected] */
if (!(*pScr->SetCursorPosition)(pScr, x, y, xFalse))
{
status = BadImplementation;
}
}
}
if (status == Success)
{
switch(request->input.type)
{ /* Now process the event appropriately */
case KeyPress:
case KeyRelease:
(*XETrapKbdDev->realInputProc)(&xev,(DeviceIntPtr)keydev, 1L);
break;
case MotionNotify:
case ButtonPress:
case ButtonRelease:
(*XETrapPtrDev->realInputProc)(&xev,(DeviceIntPtr)ptrdev, 1L);
break;
default:
status = BadValue;
break;
}
}
return(status);
}
/*
* ProcessInputEvents
* Read and process events from the event queue until it is empty.
*/
void ProcessInputEvents(void)
{
EventRec *e;
int x, y;
xEvent xe;
static int old_flags = 0; // last known modifier state
// button number and modifier mask of currently pressed fake button
static int darwinFakeMouseButtonDown = 0;
static int darwinFakeMouseButtonMask = 0;
// Empty the signaling pipe
x = sizeof(xe);
while (x == sizeof(xe)) {
x = read(darwinEventReadFD, &xe, sizeof(xe));
}
while (darwinEventQueue.head != darwinEventQueue.tail)
{
if (screenIsSaved == SCREEN_SAVER_ON)
SaveScreens (SCREEN_SAVER_OFF, ScreenSaverReset);
e = &darwinEventQueue.events[darwinEventQueue.head];
xe = e->event;
// Shift from global screen coordinates to coordinates relative to
// the origin of the current screen.
xe.u.keyButtonPointer.rootX -= darwinMainScreenX +
dixScreenOrigins[miPointerCurrentScreen()->myNum].x;
xe.u.keyButtonPointer.rootY -= darwinMainScreenY +
dixScreenOrigins[miPointerCurrentScreen()->myNum].y;
/*
* Assumption - screen switching can only occur on motion events
*/
if (e->pScreen != darwinEventQueue.pDequeueScreen)
{
darwinEventQueue.pDequeueScreen = e->pScreen;
x = xe.u.keyButtonPointer.rootX;
y = xe.u.keyButtonPointer.rootY;
if (darwinEventQueue.head == QUEUE_SIZE - 1)
darwinEventQueue.head = 0;
else
++darwinEventQueue.head;
NewCurrentScreen (darwinEventQueue.pDequeueScreen, x, y);
}
else
{
if (darwinEventQueue.head == QUEUE_SIZE - 1)
darwinEventQueue.head = 0;
else
++darwinEventQueue.head;
switch (xe.u.u.type)
{
case KeyPress:
if (old_flags == 0
&& darwinSyncKeymap && darwinKeymapFile == NULL)
{
/* See if keymap has changed. */
static unsigned int last_seed;
unsigned int this_seed;
this_seed = DarwinModeSystemKeymapSeed();
if (this_seed != last_seed)
{
last_seed = this_seed;
DarwinKeyboardReload(darwinKeyboard);
}
}
/* fall through */
case KeyRelease:
xe.u.u.detail += MIN_KEYCODE;
(*darwinEventQueue.pKbd->processInputProc)
(&xe, (DeviceIntPtr)darwinEventQueue.pKbd, 1);
break;
case ButtonPress:
miPointerAbsoluteCursor(xe.u.keyButtonPointer.rootX,
xe.u.keyButtonPointer.rootY,
xe.u.keyButtonPointer.time);
if (darwinFakeButtons && xe.u.u.detail == 1) {
// Mimic multi-button mouse with modifier-clicks
// If both sets of modifiers are pressed,
// button 2 is clicked.
if ((old_flags & darwinFakeMouse2Mask) ==
darwinFakeMouse2Mask)
{
DarwinSimulateMouseClick(&xe, 2, darwinFakeMouse2Mask);
darwinFakeMouseButtonDown = 2;
darwinFakeMouseButtonMask = darwinFakeMouse2Mask;
break;
}
else if ((old_flags & darwinFakeMouse3Mask) ==
darwinFakeMouse3Mask)
{
DarwinSimulateMouseClick(&xe, 3, darwinFakeMouse3Mask);
darwinFakeMouseButtonDown = 3;
darwinFakeMouseButtonMask = darwinFakeMouse3Mask;
break;
}
}
(*darwinEventQueue.pPtr->processInputProc)
(&xe, (DeviceIntPtr)darwinEventQueue.pPtr, 1);
break;
case ButtonRelease:
miPointerAbsoluteCursor(xe.u.keyButtonPointer.rootX,
xe.u.keyButtonPointer.rootY,
xe.u.keyButtonPointer.time);
if (darwinFakeButtons && xe.u.u.detail == 1 &&
darwinFakeMouseButtonDown)
{
// If last mousedown was a fake click, don't check for
// mouse modifiers here. The user may have released the
// modifiers before the mouse button.
xe.u.u.detail = darwinFakeMouseButtonDown;
darwinFakeMouseButtonDown = 0;
(*darwinEventQueue.pPtr->processInputProc)
(&xe, (DeviceIntPtr)darwinEventQueue.pPtr, 1);
// Bring modifiers back up to date
DarwinUpdateModifiers(&xe, KeyPress,
darwinFakeMouseButtonMask & old_flags);
darwinFakeMouseButtonMask = 0;
} else {
(*darwinEventQueue.pPtr->processInputProc)
(&xe, (DeviceIntPtr)darwinEventQueue.pPtr, 1);
}
break;
case MotionNotify:
miPointerAbsoluteCursor(xe.u.keyButtonPointer.rootX,
xe.u.keyButtonPointer.rootY,
xe.u.keyButtonPointer.time);
break;
case kXDarwinUpdateModifiers:
{
// Update modifier state.
// Any amount of modifiers may have changed.
int flags = xe.u.clientMessage.u.l.longs0;
DarwinUpdateModifiers(&xe, KeyRelease,
old_flags & ~flags);
DarwinUpdateModifiers(&xe, KeyPress,
~old_flags & flags);
old_flags = flags;
break;
}
case kXDarwinUpdateButtons:
{
long hwDelta = xe.u.clientMessage.u.l.longs0;
long hwButtons = xe.u.clientMessage.u.l.longs1;
int i;
for (i = 1; i < 5; i++) {
if (hwDelta & (1 << i)) {
// IOKit and X have different numbering for the
// middle and right mouse buttons.
if (i == 1) {
xe.u.u.detail = 3;
} else if (i == 2) {
xe.u.u.detail = 2;
} else {
xe.u.u.detail = i + 1;
}
if (hwButtons & (1 << i)) {
xe.u.u.type = ButtonPress;
} else {
xe.u.u.type = ButtonRelease;
}
(*darwinEventQueue.pPtr->processInputProc)
(&xe, (DeviceIntPtr)darwinEventQueue.pPtr, 1);
}
}
break;
}
case kXDarwinScrollWheel:
{
short count = xe.u.clientMessage.u.s.shorts0;
if (count > 0) {
xe.u.u.detail = SCROLLWHEELUPFAKE;
} else {
xe.u.u.detail = SCROLLWHEELDOWNFAKE;
count = -count;
}
for (; count; --count) {
xe.u.u.type = ButtonPress;
(*darwinEventQueue.pPtr->processInputProc)
(&xe, (DeviceIntPtr)darwinEventQueue.pPtr, 1);
xe.u.u.type = ButtonRelease;
(*darwinEventQueue.pPtr->processInputProc)
(&xe, (DeviceIntPtr)darwinEventQueue.pPtr, 1);
}
break;
}
default:
// Check for mode specific event
DarwinModeProcessEvent(&xe);
}
}
}
miPointerUpdate();
}
void
xnestCollectEvents(void)
{
XEvent X;
int valuators[2];
ValuatorMask mask;
ScreenPtr pScreen;
while (XCheckIfEvent(xnestDisplay, &X, xnestNotExposurePredicate, NULL)) {
switch (X.type) {
case KeyPress:
xnestUpdateModifierState(X.xkey.state);
xnestQueueKeyEvent(KeyPress, X.xkey.keycode);
break;
case KeyRelease:
xnestUpdateModifierState(X.xkey.state);
xnestQueueKeyEvent(KeyRelease, X.xkey.keycode);
break;
case ButtonPress:
valuator_mask_set_range(&mask, 0, 0, NULL);
xnestUpdateModifierState(X.xkey.state);
lastEventTime = GetTimeInMillis();
QueuePointerEvents(xnestPointerDevice, ButtonPress,
X.xbutton.button, POINTER_RELATIVE, &mask);
break;
case ButtonRelease:
valuator_mask_set_range(&mask, 0, 0, NULL);
xnestUpdateModifierState(X.xkey.state);
lastEventTime = GetTimeInMillis();
QueuePointerEvents(xnestPointerDevice, ButtonRelease,
X.xbutton.button, POINTER_RELATIVE, &mask);
break;
case MotionNotify:
valuators[0] = X.xmotion.x;
valuators[1] = X.xmotion.y;
valuator_mask_set_range(&mask, 0, 2, valuators);
lastEventTime = GetTimeInMillis();
QueuePointerEvents(xnestPointerDevice, MotionNotify,
0, POINTER_ABSOLUTE, &mask);
break;
case FocusIn:
if (X.xfocus.detail != NotifyInferior) {
pScreen = xnestScreen(X.xfocus.window);
if (pScreen)
xnestDirectInstallColormaps(pScreen);
}
break;
case FocusOut:
if (X.xfocus.detail != NotifyInferior) {
pScreen = xnestScreen(X.xfocus.window);
if (pScreen)
xnestDirectUninstallColormaps(pScreen);
}
break;
case KeymapNotify:
break;
case EnterNotify:
if (X.xcrossing.detail != NotifyInferior) {
pScreen = xnestScreen(X.xcrossing.window);
if (pScreen) {
NewCurrentScreen(inputInfo.pointer, pScreen, X.xcrossing.x,
X.xcrossing.y);
valuators[0] = X.xcrossing.x;
valuators[1] = X.xcrossing.y;
valuator_mask_set_range(&mask, 0, 2, valuators);
lastEventTime = GetTimeInMillis();
QueuePointerEvents(xnestPointerDevice, MotionNotify,
0, POINTER_ABSOLUTE, &mask);
xnestDirectInstallColormaps(pScreen);
}
}
break;
case LeaveNotify:
if (X.xcrossing.detail != NotifyInferior) {
pScreen = xnestScreen(X.xcrossing.window);
if (pScreen) {
xnestDirectUninstallColormaps(pScreen);
}
}
break;
case DestroyNotify:
if (xnestParentWindow != (Window) 0 &&
X.xdestroywindow.window == xnestParentWindow)
exit(0);
break;
case CirculateNotify:
case ConfigureNotify:
case GravityNotify:
case MapNotify:
case ReparentNotify:
case UnmapNotify:
break;
default:
ErrorF("xnest warning: unhandled event\n");
break;
}
}
}
