1 /* $XConsortium: xtest.c,v 1.22 94/04/17 20:32:59 dpw Exp $ */
2 /* $XFree86: xc/programs/Xserver/Xext/xtest.c,v 3.1 1996/05/06 05:55:41 dawes Exp $ */
5 Copyright (c) 1992 X Consortium
7 Permission is hereby granted, free of charge, to any person obtaining
8 a copy of this software and associated documentation files (the
9 "Software"), to deal in the Software without restriction, including
10 without limitation the rights to use, copy, modify, merge, publish,
11 distribute, sublicense, and/or sell copies of the Software, and to
12 permit persons to whom the Software is furnished to do so, subject to
13 the following conditions:
15 The above copyright notice and this permission notice shall be included
16 in all copies or substantial portions of the Software.
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR
22 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24 OTHER DEALINGS IN THE SOFTWARE.
26 Except as contained in this notice, the name of the X Consortium shall
27 not be used in advertising or otherwise to promote the sale, use or
28 other dealings in this Software without prior written authorization
29 from the X Consortium.
38 #include "dixstruct.h"
39 #include "extnsionst.h"
40 #include "windowstr.h"
42 #include "scrnintstr.h"
43 #include "dixevents.h"
44 #define _XTEST_SERVER_
50 #define EXTENSION_EVENT_BASE 64
51 #include "extinit.h" /* LookupDeviceIntRec */
54 static unsigned char XTestReqCode;
57 extern int DeviceValuator;
60 static void XTestResetProc(
61 #if NeedFunctionPrototypes
62 ExtensionEntry * /* extEntry */
65 static int XTestSwapFakeInput(
66 #if NeedFunctionPrototypes
67 ClientPtr /* client */,
72 static DISPATCH_PROC(ProcXTestCompareCursor);
73 static DISPATCH_PROC(ProcXTestDispatch);
74 static DISPATCH_PROC(ProcXTestFakeInput);
75 static DISPATCH_PROC(ProcXTestGetVersion);
76 static DISPATCH_PROC(ProcXTestGrabControl);
77 static DISPATCH_PROC(SProcXTestCompareCursor);
78 static DISPATCH_PROC(SProcXTestDispatch);
79 static DISPATCH_PROC(SProcXTestFakeInput);
80 static DISPATCH_PROC(SProcXTestGetVersion);
81 static DISPATCH_PROC(SProcXTestGrabControl);
86 ExtensionEntry *extEntry;
88 if ((extEntry = AddExtension(XTestExtensionName, 0, 0,
89 ProcXTestDispatch, SProcXTestDispatch,
90 XTestResetProc, StandardMinorOpcode)) != 0)
91 XTestReqCode = (unsigned char)extEntry->base;
96 XTestResetProc (extEntry)
97 ExtensionEntry *extEntry;
102 ProcXTestGetVersion(client)
103 register ClientPtr client;
105 xXTestGetVersionReply rep;
108 REQUEST_SIZE_MATCH(xXTestGetVersionReq);
111 rep.sequenceNumber = client->sequence;
112 rep.majorVersion = XTestMajorVersion;
113 rep.minorVersion = XTestMinorVersion;
114 if (client->swapped) {
115 swaps(&rep.sequenceNumber, n);
116 swaps(&rep.minorVersion, n);
118 WriteToClient(client, sizeof(xXTestGetVersionReply), (char *)&rep);
119 return(client->noClientException);
123 ProcXTestCompareCursor(client)
124 register ClientPtr client;
126 REQUEST(xXTestCompareCursorReq);
127 xXTestCompareCursorReply rep;
132 REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
133 pWin = (WindowPtr)LookupWindow(stuff->window, client);
136 if (stuff->cursor == None)
137 pCursor = NullCursor;
138 else if (stuff->cursor == XTestCurrentCursor)
139 pCursor = GetSpriteCursor();
141 pCursor = (CursorPtr)LookupIDByType(stuff->cursor, RT_CURSOR);
144 client->errorValue = stuff->cursor;
150 rep.sequenceNumber = client->sequence;
151 rep.same = (wCursor(pWin) == pCursor);
152 if (client->swapped) {
153 swaps(&rep.sequenceNumber, n);
155 WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *)&rep);
156 return(client->noClientException);
160 ProcXTestFakeInput(client)
161 register ClientPtr client;
163 REQUEST(xXTestFakeInputReq);
171 Bool extension = FALSE;
177 nev = (stuff->length << 2) - sizeof(xReq);
178 if ((nev % sizeof(xEvent)) || !nev)
180 nev /= sizeof(xEvent);
182 ev = (xEvent *)&((xReq *)stuff)[1];
183 type = ev->u.u.type & 0177;
185 if (type >= EXTENSION_EVENT_BASE)
187 type -= DeviceValuator;
189 case XI_DeviceKeyPress:
190 case XI_DeviceKeyRelease:
191 case XI_DeviceButtonPress:
192 case XI_DeviceButtonRelease:
193 case XI_DeviceMotionNotify:
195 case XI_ProximityOut:
198 client->errorValue = ev->u.u.type;
201 if (nev == 1 && type == XI_DeviceMotionNotify)
203 if (type == XI_DeviceMotionNotify)
204 base = ((deviceValuator *)(ev+1))->first_valuator;
207 for (n = 1; n < nev; n++)
209 dv = (deviceValuator *)(ev + n);
210 if (dv->type != DeviceValuator)
212 client->errorValue = dv->type;
215 if (dv->first_valuator != base)
217 client->errorValue = dv->first_valuator;
220 if (!dv->num_valuators || dv->num_valuators > 6)
222 client->errorValue = dv->num_valuators;
225 base += dv->num_valuators;
227 type = type - XI_DeviceKeyPress + KeyPress;
244 client->errorValue = ev->u.u.type;
248 if (ev->u.keyButtonPointer.time)
250 TimeStamp activateTime;
253 activateTime = currentTime;
254 ms = activateTime.milliseconds + ev->u.keyButtonPointer.time;
255 if (ms < activateTime.milliseconds)
256 activateTime.months++;
257 activateTime.milliseconds = ms;
258 ev->u.keyButtonPointer.time = 0;
260 /* see mbuf.c:QueueDisplayRequest for code similar to this */
262 if (!ClientSleepUntil(client, &activateTime, NULL, NULL))
266 /* swap the request back so we can simply re-execute it */
269 (void) XTestSwapFakeInput(client, (xReq *)stuff);
270 swaps(&stuff->length, n);
272 ResetCurrentRequest (client);
279 dev = LookupDeviceIntRec(stuff->deviceid & 0177);
282 client->errorValue = stuff->deviceid & 0177;
287 dv = (deviceValuator *)(ev + 1);
288 if (!dev->valuator || dv->first_valuator >= dev->valuator->numAxes)
290 client->errorValue = dv->first_valuator;
293 if (dv->first_valuator + dv->num_valuators >
294 dev->valuator->numAxes)
296 client->errorValue = dv->num_valuators;
309 dev = (DeviceIntPtr)LookupKeyboardDevice();
310 if (ev->u.u.detail < dev->key->curKeySyms.minKeyCode ||
311 ev->u.u.detail > dev->key->curKeySyms.maxKeyCode)
313 client->errorValue = ev->u.u.detail;
321 if (ev->u.u.detail != xFalse && ev->u.u.detail != xTrue)
323 client->errorValue = ev->u.u.detail;
326 if (ev->u.u.detail == xTrue && dev->valuator->mode == Absolute)
328 values = dev->valuator->axisVal + dv->first_valuator;
329 for (n = 1; n < nev; n++)
331 dv = (deviceValuator *)(ev + n);
332 switch (dv->num_valuators)
335 dv->valuator5 += values[5];
337 dv->valuator4 += values[4];
339 dv->valuator3 += values[3];
341 dv->valuator2 += values[2];
343 dv->valuator1 += values[1];
345 dv->valuator0 += values[0];
353 dev = (DeviceIntPtr)LookupPointerDevice();
354 if (ev->u.keyButtonPointer.root == None)
355 root = GetCurrentRootWindow();
358 root = LookupWindow(ev->u.keyButtonPointer.root, client);
363 client->errorValue = ev->u.keyButtonPointer.root;
367 if (ev->u.u.detail == xTrue)
370 GetSpritePosition(&x, &y);
371 ev->u.keyButtonPointer.rootX += x;
372 ev->u.keyButtonPointer.rootY += y;
374 else if (ev->u.u.detail != xFalse)
376 client->errorValue = ev->u.u.detail;
379 if (ev->u.keyButtonPointer.rootX < 0)
380 ev->u.keyButtonPointer.rootX = 0;
381 else if (ev->u.keyButtonPointer.rootX >= root->drawable.width)
382 ev->u.keyButtonPointer.rootX = root->drawable.width - 1;
383 if (ev->u.keyButtonPointer.rootY < 0)
384 ev->u.keyButtonPointer.rootY = 0;
385 else if (ev->u.keyButtonPointer.rootY >= root->drawable.height)
386 ev->u.keyButtonPointer.rootY = root->drawable.height - 1;
387 if (root != GetCurrentRootWindow())
389 NewCurrentScreen(root->drawable.pScreen,
390 ev->u.keyButtonPointer.rootX,
391 ev->u.keyButtonPointer.rootY);
392 return client->noClientException;
394 (*root->drawable.pScreen->SetCursorPosition)
395 (root->drawable.pScreen,
396 ev->u.keyButtonPointer.rootX,
397 ev->u.keyButtonPointer.rootY, FALSE);
404 dev = (DeviceIntPtr)LookupPointerDevice();
405 if (!ev->u.u.detail || ev->u.u.detail > dev->button->numButtons)
407 client->errorValue = ev->u.u.detail;
412 if (screenIsSaved == SCREEN_SAVER_ON)
413 SaveScreens(SCREEN_SAVER_OFF, ScreenSaverReset);
414 ev->u.keyButtonPointer.time = currentTime.milliseconds;
415 (*dev->public.processInputProc)(ev, dev, nev);
416 return client->noClientException;
420 ProcXTestGrabControl(client)
421 register ClientPtr client;
423 REQUEST(xXTestGrabControlReq);
425 REQUEST_SIZE_MATCH(xXTestGrabControlReq);
426 if ((stuff->impervious != xTrue) && (stuff->impervious != xFalse))
428 client->errorValue = stuff->impervious;
431 if (stuff->impervious)
432 MakeClientGrabImpervious(client);
434 MakeClientGrabPervious(client);
435 return(client->noClientException);
439 ProcXTestDispatch (client)
440 register ClientPtr client;
445 case X_XTestGetVersion:
446 return ProcXTestGetVersion(client);
447 case X_XTestCompareCursor:
448 return ProcXTestCompareCursor(client);
449 case X_XTestFakeInput:
450 return ProcXTestFakeInput(client);
451 case X_XTestGrabControl:
452 return ProcXTestGrabControl(client);
459 SProcXTestGetVersion(client)
460 register ClientPtr client;
463 REQUEST(xXTestGetVersionReq);
465 swaps(&stuff->length, n);
466 REQUEST_SIZE_MATCH(xXTestGetVersionReq);
467 swaps(&stuff->minorVersion, n);
468 return ProcXTestGetVersion(client);
472 SProcXTestCompareCursor(client)
473 register ClientPtr client;
476 REQUEST(xXTestCompareCursorReq);
478 swaps(&stuff->length, n);
479 REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
480 swapl(&stuff->window, n);
481 swapl(&stuff->cursor, n);
482 return ProcXTestCompareCursor(client);
486 XTestSwapFakeInput(client, req)
487 register ClientPtr client;
495 nev = ((req->length << 2) - sizeof(xReq)) / sizeof(xEvent);
496 for (ev = (xEvent *)&req[1]; --nev >= 0; ev++)
499 proc = EventSwapVector[ev->u.u.type & 0177];
500 /* no swapping proc; invalid event type? */
501 if (!proc || proc == NotImplemented) {
502 client->errorValue = ev->u.u.type;
512 SProcXTestFakeInput(client)
513 register ClientPtr client;
518 swaps(&stuff->length, n);
519 n = XTestSwapFakeInput(client, stuff);
522 return ProcXTestFakeInput(client);
526 SProcXTestGrabControl(client)
527 register ClientPtr client;
530 REQUEST(xXTestGrabControlReq);
532 swaps(&stuff->length, n);
533 REQUEST_SIZE_MATCH(xXTestGrabControlReq);
534 return ProcXTestGrabControl(client);
538 SProcXTestDispatch (client)
539 register ClientPtr client;
544 case X_XTestGetVersion:
545 return SProcXTestGetVersion(client);
546 case X_XTestCompareCursor:
547 return SProcXTestCompareCursor(client);
548 case X_XTestFakeInput:
549 return SProcXTestFakeInput(client);
550 case X_XTestGrabControl:
551 return SProcXTestGrabControl(client);