home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / extensions / server / xtest.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-21  |  9.0 KB  |  359 lines
  1. /* $XConsortium: xtest.c,v 1.12.1.1 92/09/09 17:08:16 rws Exp $ */
  2. /*
  3.  
  4. Copyright 1992 by the Massachusetts Institute of Technology
  5.  
  6. Permission to use, copy, modify, distribute, and sell this software and its
  7. documentation for any purpose is hereby granted without fee, provided that
  8. the above copyright notice appear in all copies and that both that
  9. copyright notice and this permission notice appear in supporting
  10. documentation, and that the name of M.I.T. not be used in advertising or
  11. publicity pertaining to distribution of the software without specific,
  12. written prior permission.  M.I.T. makes no representations about the
  13. suitability of this software for any purpose.  It is provided "as is"
  14. without express or implied warranty.
  15.  
  16. */
  17.  
  18. #include "X.h"
  19. #define NEED_EVENTS
  20. #include "Xproto.h"
  21. #include "misc.h"
  22. #include "os.h"
  23. #include "dixstruct.h"
  24. #include "extnsionst.h"
  25. #include "windowstr.h"
  26. #include "inputstr.h"
  27. #include "scrnintstr.h"
  28. #define _XTEST_SERVER_
  29. #include "XTest.h"
  30. #include "xteststr.h"
  31.  
  32. static unsigned char XTestReqCode;
  33. static int ProcXTestDispatch(), SProcXTestDispatch();
  34. static void XTestResetProc();
  35. static int XTestSwapFakeInput();
  36. CursorPtr GetSpriteCursor();
  37. WindowPtr GetCurrentRootWindow();
  38. extern int screenIsSaved;
  39.  
  40. void
  41. XTestExtensionInit()
  42. {
  43.     ExtensionEntry *extEntry, *AddExtension();
  44.  
  45.     if (extEntry = AddExtension(XTestExtensionName, 0, 0,
  46.                  ProcXTestDispatch, SProcXTestDispatch,
  47.                  XTestResetProc, StandardMinorOpcode))
  48.     XTestReqCode = (unsigned char)extEntry->base;
  49. }
  50.  
  51. /*ARGSUSED*/
  52. static void
  53. XTestResetProc (extEntry)
  54. ExtensionEntry    *extEntry;
  55. {
  56. }
  57.  
  58. static int
  59. ProcXTestGetVersion(client)
  60.     register ClientPtr client;
  61. {
  62.     REQUEST(xXTestGetVersionReq);
  63.     xXTestGetVersionReply rep;
  64.     register int n;
  65.  
  66.     REQUEST_SIZE_MATCH(xXTestGetVersionReq);
  67.     rep.type = X_Reply;
  68.     rep.length = 0;
  69.     rep.sequenceNumber = client->sequence;
  70.     rep.majorVersion = XTestMajorVersion;
  71.     rep.minorVersion = XTestMinorVersion;
  72.     if (client->swapped) {
  73.         swaps(&rep.sequenceNumber, n);
  74.     swaps(&rep.minorVersion, n);
  75.     }
  76.     WriteToClient(client, sizeof(xXTestGetVersionReply), (char *)&rep);
  77.     return(client->noClientException);
  78. }
  79.  
  80. static int
  81. ProcXTestCompareCursor(client)
  82.     register ClientPtr client;
  83. {
  84.     REQUEST(xXTestCompareCursorReq);
  85.     xXTestCompareCursorReply rep;
  86.     WindowPtr pWin;
  87.     CursorPtr pCursor;
  88.     register int n;
  89.  
  90.     REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
  91.     pWin = (WindowPtr)LookupWindow(stuff->window, client);
  92.     if (!pWin)
  93.         return(BadWindow);
  94.     if (stuff->cursor == None)
  95.     pCursor = NullCursor;
  96.     else if (stuff->cursor == XTestCurrentCursor)
  97.     pCursor = GetSpriteCursor();
  98.     else {
  99.     pCursor = (CursorPtr)LookupIDByType(stuff->cursor, RT_CURSOR);
  100.     if (!pCursor) 
  101.     {
  102.         client->errorValue = stuff->cursor;
  103.         return (BadCursor);
  104.     }
  105.     }
  106.     rep.type = X_Reply;
  107.     rep.length = 0;
  108.     rep.sequenceNumber = client->sequence;
  109.     rep.same = (wCursor(pWin) == pCursor);
  110.     if (client->swapped) {
  111.         swaps(&rep.sequenceNumber, n);
  112.     }
  113.     WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *)&rep);
  114.     return(client->noClientException);
  115. }
  116.  
  117. static int
  118. ProcXTestFakeInput(client)
  119.     register ClientPtr client;
  120. {
  121.     REQUEST(xReq);
  122.     int nev;
  123.     int    n;
  124.     xEvent *ev;
  125.     DeviceIntPtr dev;
  126.     WindowPtr root;
  127.  
  128.     nev = (stuff->length << 2) - sizeof(xReq);
  129.     if (nev % sizeof(xEvent))
  130.     return BadLength;
  131.     nev /= sizeof(xEvent);
  132.     if (nev != 1)
  133.     return BadLength; /* for now */
  134.     UpdateCurrentTime();
  135.     ev = (xEvent *)&stuff[1];
  136.     switch (ev->u.u.type & 0177)
  137.     {
  138.     case KeyPress:
  139.     case KeyRelease:
  140.     case MotionNotify:
  141.     case ButtonPress:
  142.     case ButtonRelease:
  143.     break;
  144.     default:
  145.     client->errorValue = ev->u.u.type;
  146.     return BadValue;
  147.     }
  148.     if (ev->u.keyButtonPointer.time)
  149.     {
  150.     TimeStamp activateTime;
  151.     CARD32 ms;
  152.  
  153.     activateTime = currentTime;
  154.     ms = activateTime.milliseconds + ev->u.keyButtonPointer.time;
  155.     if (ms < activateTime.milliseconds)
  156.         activateTime.months++;
  157.     activateTime.milliseconds = ms;
  158.     ev->u.keyButtonPointer.time = 0;
  159.     /* swap the request back so we can simply re-execute it */
  160.     if (client->swapped)
  161.     {
  162.             (void) XTestSwapFakeInput(client, stuff);
  163.         swaps(&stuff->length, n);
  164.     }
  165.     ResetCurrentRequest (client);
  166.     client->sequence--;
  167.     if (!ClientSleepUntil(client, &activateTime, NULL, NULL))
  168.     {
  169.         /* 
  170.          * flush this request - must be in this order because
  171.          * ResetCurrentRequest adds the client back to 
  172.          * clientsWithInput which will cause the client to
  173.          * keep going, instead of waiting for the timeout.
  174.          */
  175.         (void) ReadRequestFromClient (client);
  176.         client->sequence++;
  177.         return BadAlloc;
  178.     }
  179.     return Success;
  180.     }
  181.     switch (ev->u.u.type & 0177)
  182.     {
  183.     case KeyPress:
  184.     case KeyRelease:
  185.     dev = (DeviceIntPtr)LookupKeyboardDevice();
  186.     if (ev->u.u.detail < dev->key->curKeySyms.minKeyCode ||
  187.         ev->u.u.detail > dev->key->curKeySyms.maxKeyCode)
  188.     {
  189.         client->errorValue = ev->u.u.detail;
  190.         return BadValue;
  191.     }
  192.     break;
  193.     case MotionNotify:
  194.     dev = (DeviceIntPtr)LookupPointerDevice();
  195.     if (ev->u.keyButtonPointer.root == None)
  196.         root = GetCurrentRootWindow();
  197.     else
  198.     {
  199.         root = LookupWindow(ev->u.keyButtonPointer.root, client);
  200.         if (!root)
  201.         return BadWindow;
  202.         if (root->parent)
  203.         {
  204.         client->errorValue = ev->u.keyButtonPointer.root;
  205.         return BadValue;
  206.         }
  207.     }
  208.     if (ev->u.u.detail == xTrue)
  209.     {
  210.         int x, y;
  211.         GetSpritePosition(&x, &y);
  212.         ev->u.keyButtonPointer.rootX += x;
  213.         ev->u.keyButtonPointer.rootY += y;
  214.     }
  215.     else if (ev->u.u.detail != xFalse)
  216.     {
  217.         client->errorValue = ev->u.u.detail;
  218.         return BadValue;
  219.     }
  220.     if (ev->u.keyButtonPointer.rootX < 0)
  221.         ev->u.keyButtonPointer.rootX = 0;
  222.     else if (ev->u.keyButtonPointer.rootX >= root->drawable.width)
  223.         ev->u.keyButtonPointer.rootX = root->drawable.width - 1;
  224.     if (ev->u.keyButtonPointer.rootY < 0)
  225.         ev->u.keyButtonPointer.rootY = 0;
  226.     else if (ev->u.keyButtonPointer.rootY >= root->drawable.height)
  227.         ev->u.keyButtonPointer.rootY = root->drawable.height - 1;
  228.     if (root != GetCurrentRootWindow())
  229.     {
  230.         NewCurrentScreen(root->drawable.pScreen,
  231.                  ev->u.keyButtonPointer.rootX,
  232.                  ev->u.keyButtonPointer.rootY);
  233.         return client->noClientException;
  234.     }
  235.     (*root->drawable.pScreen->SetCursorPosition)
  236.         (root->drawable.pScreen,
  237.          ev->u.keyButtonPointer.rootX,
  238.          ev->u.keyButtonPointer.rootY, FALSE);
  239.     break;
  240.     case ButtonPress:
  241.     case ButtonRelease:
  242.     dev = (DeviceIntPtr)LookupPointerDevice();
  243.     if (!ev->u.u.detail || ev->u.u.detail > dev->button->numButtons)
  244.     {
  245.         client->errorValue = ev->u.u.detail;
  246.         return BadValue;
  247.     }
  248.     break;
  249.     }
  250.     if (screenIsSaved == SCREEN_SAVER_ON)
  251.     SaveScreens(SCREEN_SAVER_OFF, ScreenSaverReset);
  252.     ev->u.keyButtonPointer.time = currentTime.milliseconds;
  253.     (*dev->public.processInputProc)(ev, (DevicePtr)dev, 1); 
  254.     return client->noClientException;
  255. }
  256.  
  257. static int
  258. ProcXTestDispatch (client)
  259.     register ClientPtr    client;
  260. {
  261.     REQUEST(xReq);
  262.     switch (stuff->data)
  263.     {
  264.     case X_XTestGetVersion:
  265.     return ProcXTestGetVersion(client);
  266.     case X_XTestCompareCursor:
  267.     return ProcXTestCompareCursor(client);
  268.     case X_XTestFakeInput:
  269.     return ProcXTestFakeInput(client);
  270.     default:
  271.     return BadRequest;
  272.     }
  273. }
  274.  
  275. static int
  276. SProcXTestGetVersion(client)
  277.     register ClientPtr    client;
  278. {
  279.     register int n;
  280.     REQUEST(xXTestGetVersionReq);
  281.  
  282.     swaps(&stuff->length, n);
  283.     REQUEST_SIZE_MATCH(xXTestGetVersionReq);
  284.     swaps(&stuff->minorVersion, n);
  285.     return ProcXTestGetVersion(client);
  286. }
  287.  
  288. static int
  289. SProcXTestCompareCursor(client)
  290.     register ClientPtr    client;
  291. {
  292.     register int n;
  293.     REQUEST(xXTestCompareCursorReq);
  294.  
  295.     swaps(&stuff->length, n);
  296.     REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
  297.     swapl(&stuff->window, n);
  298.     swapl(&stuff->cursor, n);
  299.     return ProcXTestCompareCursor(client);
  300. }
  301.  
  302. static int
  303. XTestSwapFakeInput(client, req)
  304.     register ClientPtr    client;
  305.     xReq *req;
  306. {
  307.     register int nev;
  308.     register xEvent *ev;
  309.     xEvent sev;
  310.     void (*proc)(), NotImplemented();
  311.  
  312.     nev = ((req->length << 2) - sizeof(xReq)) / sizeof(xEvent);
  313.     for (ev = (xEvent *)&req[1]; --nev >= 0; ev++)
  314.     {
  315.         /* Swap event */
  316.         proc = EventSwapVector[ev->u.u.type & 0177];
  317.     /* no swapping proc; invalid event type? */
  318.         if (!proc || (int (*)()) proc == (int (*)()) NotImplemented) {
  319.         client->errorValue = ev->u.u.type;
  320.         return BadValue;
  321.     }
  322.         (*proc)(ev, &sev);
  323.     *ev = sev;
  324.     }
  325.     return Success;
  326. }
  327.  
  328. static int
  329. SProcXTestFakeInput(client)
  330.     register ClientPtr    client;
  331. {
  332.     register int n;
  333.     REQUEST(xReq);
  334.  
  335.     swaps(&stuff->length, n);
  336.     n = XTestSwapFakeInput(client, stuff);
  337.     if (n != Success)
  338.     return n;
  339.     return ProcXTestFakeInput(client);
  340. }
  341.  
  342. static int
  343. SProcXTestDispatch (client)
  344.     register ClientPtr    client;
  345. {
  346.     REQUEST(xReq);
  347.     switch (stuff->data)
  348.     {
  349.     case X_XTestGetVersion:
  350.     return SProcXTestGetVersion(client);
  351.     case X_XTestCompareCursor:
  352.     return SProcXTestCompareCursor(client);
  353.     case X_XTestFakeInput:
  354.     return SProcXTestFakeInput(client);
  355.     default:
  356.     return BadRequest;
  357.     }
  358. }
  359.