home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / server / dix / devices.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-21  |  36.2 KB  |  1,439 lines
  1. /************************************************************
  2. Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
  3. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Digital or MIT not be
  12. used in advertising or publicity pertaining to distribution of the
  13. software without specific, written prior permission.  
  14.  
  15. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  16. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  17. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  18. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  19. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  20. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21. SOFTWARE.
  22.  
  23. ********************************************************/
  24.  
  25.  
  26. /* $XConsortium: devices.c,v 5.22 91/12/10 11:19:22 keith Exp $ */
  27.  
  28. #include "X.h"
  29. #include "misc.h"
  30. #include "resource.h"
  31. #define NEED_EVENTS
  32. #define NEED_REPLIES
  33. #include "Xproto.h"
  34. #include "windowstr.h"
  35. #include "inputstr.h"
  36. #include "scrnintstr.h"
  37. #include "cursorstr.h"
  38. #include "dixstruct.h"
  39. #include "site.h"
  40.  
  41. extern InputInfo inputInfo;
  42. extern int (* InitialVector[3]) ();
  43. extern void (* ReplySwapVector[256]) ();
  44. extern void CopySwap32Write(), SwapTimeCoordWrite();
  45. extern void ActivatePointerGrab(), DeactivatePointerGrab();
  46. extern void ActivateKeyboardGrab(), DeactivateKeyboardGrab();
  47. extern Mask EventMaskForClient();
  48. extern void EnqueueEvent();
  49.  
  50. DevicePtr
  51. AddInputDevice(deviceProc, autoStart)
  52.     DeviceProc deviceProc;
  53.     Bool autoStart;
  54. {
  55.     register DeviceIntPtr dev;
  56.  
  57.     if (inputInfo.numDevices >= MAX_DEVICES)
  58.     return (DevicePtr)NULL;
  59.     dev = (DeviceIntPtr) xalloc(sizeof(DeviceIntRec));
  60.     if (!dev)
  61.     return (DevicePtr)NULL;
  62.     dev->name = (char *)NULL;
  63.     dev->type = 0;
  64.     dev->id = inputInfo.numDevices;
  65.     inputInfo.numDevices++;
  66.     dev->public.on = FALSE;
  67.     dev->public.processInputProc = NoopDDA;
  68.     dev->public.realInputProc = NoopDDA;
  69.     dev->public.enqueueInputProc = EnqueueEvent;
  70.     dev->deviceProc = deviceProc;
  71.     dev->startup = autoStart;
  72.     dev->sync.frozen = FALSE;
  73.     dev->sync.other = NullGrab;
  74.     dev->sync.state = NOT_GRABBED;
  75.     dev->sync.event = (xEvent *) NULL;
  76.     dev->grab = NullGrab;
  77.     dev->grabTime = currentTime;
  78.     dev->fromPassiveGrab = FALSE;
  79.     dev->key = (KeyClassPtr)NULL;
  80.     dev->valuator = (ValuatorClassPtr)NULL;
  81.     dev->button = (ButtonClassPtr)NULL;
  82.     dev->focus = (FocusClassPtr)NULL;
  83.     dev->proximity = (ProximityClassPtr)NULL;
  84.     dev->kbdfeed = (KbdFeedbackPtr)NULL;
  85.     dev->ptrfeed = (PtrFeedbackPtr)NULL;
  86.     dev->intfeed = (IntegerFeedbackPtr)NULL;
  87.     dev->stringfeed = (StringFeedbackPtr)NULL;
  88.     dev->bell = (BellFeedbackPtr)NULL;
  89.     dev->leds = (LedFeedbackPtr)NULL;
  90.     dev->next = inputInfo.off_devices;
  91.     inputInfo.off_devices = dev;
  92.     return &dev->public;
  93. }
  94.  
  95. Bool
  96. EnableDevice(dev)
  97.     register DeviceIntPtr dev;
  98. {
  99.     register DeviceIntPtr *prev;
  100.  
  101.     for (prev = &inputInfo.off_devices;
  102.      *prev && (*prev != dev);
  103.      prev = &(*prev)->next)
  104.     ;
  105.     if ((*prev != dev) || !dev->inited ||
  106.     ((*dev->deviceProc)(dev, DEVICE_ON) != Success))
  107.     return FALSE;
  108.     *prev = dev->next;
  109.     dev->next = inputInfo.devices;
  110.     inputInfo.devices = dev;
  111.     return TRUE;
  112. }
  113.  
  114. Bool
  115. DisableDevice(dev)
  116.     register DeviceIntPtr dev;
  117. {
  118.     register DeviceIntPtr *prev;
  119.  
  120.     for (prev = &inputInfo.devices;
  121.      *prev && (*prev != dev);
  122.      prev = &(*prev)->next)
  123.     ;
  124.     if (*prev != dev)
  125.     return FALSE;
  126.     (void)(*dev->deviceProc)(dev, DEVICE_OFF);
  127.     *prev = dev->next;
  128.     dev->next = inputInfo.off_devices;
  129.     inputInfo.off_devices = dev;
  130.     return TRUE;
  131. }
  132.  
  133. int
  134. InitAndStartDevices()
  135. {
  136.     register DeviceIntPtr dev, next;
  137.  
  138.     for (dev = inputInfo.off_devices; dev; dev = dev->next)
  139.     dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success);
  140.     for (dev = inputInfo.off_devices; dev; dev = next)
  141.     {
  142.     next = dev->next;
  143.     if (dev->inited && dev->startup)
  144.         (void)EnableDevice(dev);
  145.     }
  146.     for (dev = inputInfo.devices;
  147.      dev && (dev != inputInfo.keyboard);
  148.      dev = dev->next)
  149.     ;
  150.     if (!dev || (dev != inputInfo.keyboard))
  151.     return BadImplementation;
  152.     for (dev = inputInfo.devices;
  153.      dev && (dev != inputInfo.pointer);
  154.      dev = dev->next)
  155.     ;
  156.     if (!dev || (dev != inputInfo.pointer))
  157.     return BadImplementation;
  158.     return Success;
  159. }
  160.  
  161. static void
  162. CloseDevice(dev)
  163.     register DeviceIntPtr dev;
  164. {
  165.     KbdFeedbackPtr k, knext;
  166.     PtrFeedbackPtr p, pnext;
  167.     IntegerFeedbackPtr i, inext;
  168.     StringFeedbackPtr s, snext;
  169.     BellFeedbackPtr b, bnext;
  170.     LedFeedbackPtr l, lnext;
  171.  
  172.     if (dev->inited)
  173.     (void)(*dev->deviceProc)(dev, DEVICE_CLOSE);
  174.     xfree(dev->name);
  175.     if (dev->key)
  176.     {
  177.     xfree(dev->key->curKeySyms.map);
  178.     xfree(dev->key->modifierKeyMap);
  179.     xfree(dev->key);
  180.     }
  181.     xfree(dev->valuator);
  182.     xfree(dev->button);
  183.     if (dev->focus)
  184.     {
  185.     xfree(dev->focus->trace);
  186.     xfree(dev->focus);
  187.     }
  188.     xfree(dev->proximity);
  189.     for (k=dev->kbdfeed; k; k=knext)
  190.     {
  191.     knext = k->next;
  192.     xfree(k);
  193.     }
  194.     for (p=dev->ptrfeed; p; p=pnext)
  195.     {
  196.     pnext = p->next;
  197.     xfree(p);
  198.     }
  199.     for (i=dev->intfeed; i; i=inext)
  200.     {
  201.     inext = i->next;
  202.     xfree(i);
  203.     }
  204.     for (s=dev->stringfeed; s; s=snext)
  205.     {
  206.     snext = s->next;
  207.     xfree(s->ctrl.symbols_supported);
  208.     xfree(s->ctrl.symbols_displayed);
  209.     xfree(s);
  210.     }
  211.     for (b=dev->bell; b; b=bnext)
  212.     {
  213.     bnext = b->next;
  214.     xfree(b);
  215.     }
  216.     for (l=dev->leds; l; l=lnext)
  217.     {
  218.     lnext = l->next;
  219.     xfree(l);
  220.     }
  221.     xfree(dev);
  222. }
  223.  
  224. void
  225. CloseDownDevices()
  226. {
  227.     register DeviceIntPtr dev, next;
  228.  
  229.     for (dev = inputInfo.devices; dev; dev = next)
  230.     {
  231.     next = dev->next;
  232.     CloseDevice(dev);
  233.     }
  234.     for (dev = inputInfo.off_devices; dev; dev = next)
  235.     {
  236.     next = dev->next;
  237.     CloseDevice(dev);
  238.     }
  239. }
  240.  
  241. int
  242. NumMotionEvents()
  243. {
  244.     return inputInfo.pointer->valuator->numMotionEvents;
  245. }
  246.  
  247. void
  248. RegisterPointerDevice(device)
  249.     DevicePtr device;
  250. {
  251.     inputInfo.pointer = (DeviceIntPtr)device;
  252.     device->processInputProc = ProcessPointerEvent;
  253.     device->realInputProc = ProcessPointerEvent;
  254.     ((DeviceIntPtr)device)->ActivateGrab = ActivatePointerGrab;
  255.     ((DeviceIntPtr)device)->DeactivateGrab = DeactivatePointerGrab;
  256. }
  257.  
  258. void
  259. RegisterKeyboardDevice(device)
  260.     DevicePtr device;
  261. {
  262.     inputInfo.keyboard = (DeviceIntPtr)device;
  263.     device->processInputProc = ProcessKeyboardEvent;
  264.     device->realInputProc = ProcessKeyboardEvent;
  265.     ((DeviceIntPtr)device)->ActivateGrab = ActivateKeyboardGrab;
  266.     ((DeviceIntPtr)device)->DeactivateGrab = DeactivateKeyboardGrab;
  267. }
  268.  
  269. DevicePtr
  270. LookupKeyboardDevice()
  271. {
  272.     return &inputInfo.keyboard->public;
  273. }
  274.  
  275. DevicePtr
  276. LookupPointerDevice()
  277. {
  278.     return &inputInfo.pointer->public;
  279. }
  280.  
  281. void
  282. QueryMinMaxKeyCodes(minCode, maxCode)
  283.     KeyCode *minCode, *maxCode;
  284. {
  285.     *minCode = inputInfo.keyboard->key->curKeySyms.minKeyCode;
  286.     *maxCode = inputInfo.keyboard->key->curKeySyms.maxKeyCode;
  287. }
  288.  
  289. Bool
  290. SetKeySymsMap(dst, src)
  291.     register KeySymsPtr dst, src;
  292. {
  293.     int i, j;
  294.     int rowDif = src->minKeyCode - dst->minKeyCode;
  295.            /* if keysym map size changes, grow map first */
  296.  
  297.     if (src->mapWidth < dst->mapWidth)
  298.     {
  299.         for (i = src->minKeyCode; i <= src->maxKeyCode; i++)
  300.     {
  301. #define SI(r, c) (((r-src->minKeyCode)*src->mapWidth) + (c))
  302. #define DI(r, c) (((r - dst->minKeyCode)*dst->mapWidth) + (c))
  303.         for (j = 0; j < src->mapWidth; j++)
  304.         dst->map[DI(i, j)] = src->map[SI(i, j)];
  305.         for (j = src->mapWidth; j < dst->mapWidth; j++)
  306.         dst->map[DI(i, j)] = NoSymbol;
  307. #undef SI
  308. #undef DI
  309.     }
  310.     return TRUE;
  311.     }
  312.     else if (src->mapWidth > dst->mapWidth)
  313.     {
  314.         KeySym *map;
  315.     int bytes = sizeof(KeySym) * src->mapWidth *
  316.             (dst->maxKeyCode - dst->minKeyCode + 1);
  317.         map = (KeySym *)xalloc(bytes);
  318.     if (!map)
  319.         return FALSE;
  320.     bzero((char *)map, bytes);
  321.         if (dst->map)
  322.     {
  323.             for (i = 0; i <= dst->maxKeyCode-dst->minKeyCode; i++)
  324.         bcopy((char *)&dst->map[i*dst->mapWidth],
  325.               (char *)&map[i*src->mapWidth],
  326.               dst->mapWidth * sizeof(KeySym));
  327.         xfree(dst->map);
  328.     }
  329.     dst->mapWidth = src->mapWidth;
  330.     dst->map = map;
  331.     }
  332.     bcopy((char *)src->map,
  333.       (char *)&dst->map[rowDif * dst->mapWidth],
  334.       (int)(src->maxKeyCode - src->minKeyCode + 1) *
  335.       dst->mapWidth * sizeof(KeySym));
  336.     return TRUE;
  337. }
  338.  
  339. static Bool
  340. InitModMap(keyc)
  341.     register KeyClassPtr keyc;
  342. {
  343.     int i, j;
  344.     CARD8 keysPerModifier[8];
  345.     CARD8 mask;
  346.  
  347.     keyc->maxKeysPerModifier = 0;
  348.     for (i = 0; i < 8; i++)
  349.     keysPerModifier[i] = 0;
  350.     for (i = 8; i < MAP_LENGTH; i++)
  351.     {
  352.     for (j = 0, mask = 1; j < 8; j++, mask <<= 1)
  353.     {
  354.         if (mask & keyc->modifierMap[i])
  355.         {
  356.         if (++keysPerModifier[j] > keyc->maxKeysPerModifier)
  357.             keyc->maxKeysPerModifier = keysPerModifier[j];
  358.         }
  359.     }
  360.     }
  361.     keyc->modifierKeyMap = (KeyCode *)xalloc(8*keyc->maxKeysPerModifier);
  362.     if (!keyc->modifierKeyMap && keyc->maxKeysPerModifier)
  363.     return (FALSE);
  364.     bzero((char *)keyc->modifierKeyMap, 8*(int)keyc->maxKeysPerModifier);
  365.     for (i = 0; i < 8; i++)
  366.     keysPerModifier[i] = 0;
  367.     for (i = 8; i < MAP_LENGTH; i++)
  368.     {
  369.     for (j = 0, mask = 1; j < 8; j++, mask <<= 1)
  370.     {
  371.         if (mask & keyc->modifierMap[i])
  372.         {
  373.         keyc->modifierKeyMap[(j*keyc->maxKeysPerModifier) +
  374.                      keysPerModifier[j]] = i;
  375.         keysPerModifier[j]++;
  376.         }
  377.     }
  378.     }
  379.     return TRUE;
  380. }
  381.  
  382. Bool
  383. InitKeyClassDeviceStruct(dev, pKeySyms, pModifiers)
  384.     DeviceIntPtr dev;
  385.     KeySymsPtr pKeySyms;
  386.     CARD8 pModifiers[];
  387. {
  388.     int i;
  389.     register KeyClassPtr keyc;
  390.  
  391.     keyc = (KeyClassPtr)xalloc(sizeof(KeyClassRec));
  392.     if (!keyc)
  393.     return FALSE;
  394.     keyc->curKeySyms.map = (KeySym *)NULL;
  395.     keyc->curKeySyms.mapWidth = 0;
  396.     keyc->curKeySyms.minKeyCode = pKeySyms->minKeyCode;
  397.     keyc->curKeySyms.maxKeyCode = pKeySyms->maxKeyCode;
  398.     keyc->modifierKeyMap = (KeyCode *)NULL;
  399.     keyc->state = 0;
  400.     if (pModifiers)
  401.     bcopy((char *)pModifiers, (char *)keyc->modifierMap, MAP_LENGTH);
  402.     else
  403.     bzero((char *)keyc->modifierMap, MAP_LENGTH);
  404.     bzero((char *)keyc->down, DOWN_LENGTH);
  405.     for (i = 0; i < 8; i++)
  406.     keyc->modifierKeyCount[i] = 0;
  407.     if (!SetKeySymsMap(&keyc->curKeySyms, pKeySyms) || !InitModMap(keyc))
  408.     {
  409.     xfree(keyc->curKeySyms.map);
  410.     xfree(keyc->modifierKeyMap);
  411.     xfree(keyc);
  412.     return FALSE;
  413.     }
  414.     dev->key = keyc;
  415.     return TRUE;
  416. }
  417.  
  418. Bool
  419. InitButtonClassDeviceStruct(dev, numButtons, map)
  420.     register DeviceIntPtr dev;
  421.     int numButtons;
  422.     CARD8 *map;
  423. {
  424.     register ButtonClassPtr butc;
  425.     int i;
  426.  
  427.     butc = (ButtonClassPtr)xalloc(sizeof(ButtonClassRec));
  428.     if (!butc)
  429.     return FALSE;
  430.     butc->numButtons = numButtons;
  431.     for (i = 1; i <= numButtons; i++)
  432.     butc->map[i] = map[i];
  433.     butc->buttonsDown = 0;
  434.     butc->state = 0;
  435.     butc->motionMask = 0;
  436.     bzero((char *)butc->down, DOWN_LENGTH);
  437.     dev->button = butc;
  438.     return TRUE;
  439. }
  440.  
  441. Bool
  442. InitValuatorClassDeviceStruct(dev, numAxes, motionProc, numMotionEvents, mode)
  443.     DeviceIntPtr dev;
  444.     int (*motionProc)();
  445.     int numAxes;
  446.     int numMotionEvents;
  447.     int mode;
  448. {
  449.     int i;
  450.     register ValuatorClassPtr valc;
  451.  
  452.     valc = (ValuatorClassPtr)xalloc(sizeof(ValuatorClassRec) +
  453.                     numAxes * sizeof(AxisInfo) +
  454.                     numAxes * sizeof(unsigned int));
  455.     if (!valc)
  456.     return FALSE;
  457.     valc->GetMotionProc = motionProc;
  458.     valc->numMotionEvents = numMotionEvents;
  459.     valc->motionHintWindow = NullWindow;
  460.     valc->numAxes = numAxes;
  461.     valc->mode = mode;
  462.     valc->axes = (AxisInfoPtr)(valc + 1);
  463.     valc->axisVal = (int *)(valc->axes + numAxes);
  464.     for (i=0; i<numAxes; i++)
  465.     valc->axisVal[i]=0;
  466.     dev->valuator = valc;
  467.     return TRUE;
  468. }
  469.  
  470. Bool
  471. InitFocusClassDeviceStruct(dev)
  472.     DeviceIntPtr dev;
  473. {
  474.     register FocusClassPtr focc;
  475.  
  476.     focc = (FocusClassPtr)xalloc(sizeof(FocusClassRec));
  477.     if (!focc)
  478.     return FALSE;
  479.     focc->win = PointerRootWin;
  480.     focc->revert = None;
  481.     focc->time = currentTime;
  482.     focc->trace = (WindowPtr *)NULL;
  483.     focc->traceSize = 0;
  484.     focc->traceGood = 0;
  485.     dev->focus = focc;
  486.     return TRUE;
  487. }
  488.  
  489. Bool
  490. InitKbdFeedbackClassDeviceStruct(dev, bellProc, controlProc)
  491.     DeviceIntPtr dev;
  492.     void (*bellProc)();
  493.     void (*controlProc)();
  494. {
  495.     register KbdFeedbackPtr feedc;
  496.  
  497.     feedc = (KbdFeedbackPtr)xalloc(sizeof(KbdFeedbackClassRec));
  498.     if (!feedc)
  499.     return FALSE;
  500.     feedc->BellProc = bellProc;
  501.     feedc->CtrlProc = controlProc;
  502.     feedc->ctrl = defaultKeyboardControl;
  503.     feedc->ctrl.id = 0;
  504.     if (feedc->next = dev->kbdfeed)
  505.     feedc->ctrl.id = dev->kbdfeed->ctrl.id + 1;
  506.     dev->kbdfeed = feedc;
  507.     (*controlProc)(dev, &feedc->ctrl);
  508.     return TRUE;
  509. }
  510.  
  511. Bool
  512. InitPtrFeedbackClassDeviceStruct(dev, controlProc)
  513.     DeviceIntPtr dev;
  514.     void (*controlProc)();
  515. {
  516.     register PtrFeedbackPtr feedc;
  517.  
  518.     feedc = (PtrFeedbackPtr)xalloc(sizeof(PtrFeedbackClassRec));
  519.     if (!feedc)
  520.     return FALSE;
  521.     feedc->CtrlProc = controlProc;
  522.     feedc->ctrl = defaultPointerControl;
  523.     feedc->ctrl.id = 0;
  524.     if (feedc->next = dev->ptrfeed)
  525.         feedc->ctrl.id = dev->ptrfeed->ctrl.id + 1;
  526.     dev->ptrfeed = feedc;
  527.     (*controlProc)(dev, &feedc->ctrl);
  528.     return TRUE;
  529. }
  530.  
  531.  
  532. LedCtrl defaultLedControl = {
  533.     DEFAULT_LEDS, DEFAULT_LEDS_MASK, 0};
  534.  
  535. BellCtrl defaultBellControl = {
  536.     DEFAULT_BELL,
  537.     DEFAULT_BELL_PITCH,
  538.     DEFAULT_BELL_DURATION,
  539.     0};
  540.  
  541. IntegerCtrl defaultIntegerControl = {
  542.     DEFAULT_INT_RESOLUTION,
  543.     DEFAULT_INT_MIN_VALUE,
  544.     DEFAULT_INT_MAX_VALUE,
  545.     DEFAULT_INT_DISPLAYED,
  546.     0};
  547.  
  548. Bool
  549. InitStringFeedbackClassDeviceStruct (dev, controlProc, max_symbols,
  550.                      num_symbols_supported, symbols)
  551.     DeviceIntPtr dev;
  552.     void (*controlProc)();
  553.     int max_symbols;
  554.     int num_symbols_supported;
  555.     KeySym *symbols;
  556. {
  557.     int i;
  558.     register StringFeedbackPtr feedc;
  559.  
  560.     feedc = (StringFeedbackPtr)xalloc(sizeof(StringFeedbackClassRec));
  561.     if (!feedc)
  562.     return FALSE;
  563.     feedc->CtrlProc = controlProc;
  564.     feedc->ctrl.num_symbols_supported = num_symbols_supported;
  565.     feedc->ctrl.num_symbols_displayed = 0;
  566.     feedc->ctrl.max_symbols = max_symbols;
  567.     feedc->ctrl.symbols_supported = (KeySym *) 
  568.     xalloc (sizeof (KeySym) * num_symbols_supported);
  569.     feedc->ctrl.symbols_displayed = (KeySym *) 
  570.     xalloc (sizeof (KeySym) * max_symbols);
  571.     if (!feedc->ctrl.symbols_supported || !feedc->ctrl.symbols_displayed)
  572.     {
  573.     xfree(feedc->ctrl.symbols_supported);
  574.     xfree(feedc->ctrl.symbols_displayed);
  575.     xfree(feedc);
  576.     return FALSE;
  577.     }
  578.     for (i=0; i<num_symbols_supported; i++)
  579.     *(feedc->ctrl.symbols_supported+i) = *symbols++;
  580.     for (i=0; i<max_symbols; i++)
  581.     *(feedc->ctrl.symbols_displayed+i) = (KeySym) NULL;
  582.     feedc->ctrl.id = 0;
  583.     if (feedc->next = dev->stringfeed)
  584.     feedc->ctrl.id = dev->stringfeed->ctrl.id + 1;
  585.     dev->stringfeed = feedc;
  586.     (*controlProc)(dev, &feedc->ctrl);
  587.     return TRUE;
  588. }
  589.  
  590. Bool
  591. InitBellFeedbackClassDeviceStruct (dev, bellProc, controlProc)
  592.     DeviceIntPtr dev;
  593.     void (*bellProc)();
  594.     void (*controlProc)();
  595. {
  596.     register BellFeedbackPtr feedc;
  597.  
  598.     feedc = (BellFeedbackPtr)xalloc(sizeof(BellFeedbackClassRec));
  599.     if (!feedc)
  600.     return FALSE;
  601.     feedc->CtrlProc = controlProc;
  602.     feedc->BellProc = bellProc;
  603.     feedc->ctrl = defaultBellControl;
  604.     feedc->ctrl.id = 0;
  605.     if (feedc->next = dev->bell)
  606.     feedc->ctrl.id = dev->bell->ctrl.id + 1;
  607.     dev->bell = feedc;
  608.     (*controlProc)(dev, &feedc->ctrl);
  609.     return TRUE;
  610. }
  611.  
  612. Bool
  613. InitLedFeedbackClassDeviceStruct (dev, controlProc)
  614.     DeviceIntPtr dev;
  615.     void (*controlProc)();
  616. {
  617.     register LedFeedbackPtr feedc;
  618.  
  619.     feedc = (LedFeedbackPtr)xalloc(sizeof(LedFeedbackClassRec));
  620.     if (!feedc)
  621.     return FALSE;
  622.     feedc->CtrlProc = controlProc;
  623.     feedc->ctrl = defaultLedControl;
  624.     feedc->ctrl.id = 0;
  625.     if (feedc->next = dev->leds)
  626.     feedc->ctrl.id = dev->leds->ctrl.id + 1;
  627.     dev->leds = feedc;
  628.     (*controlProc)(dev, &feedc->ctrl);
  629.     return TRUE;
  630. }
  631.  
  632. Bool
  633. InitIntegerFeedbackClassDeviceStruct (dev, controlProc)
  634.     DeviceIntPtr dev;
  635.     void (*controlProc)();
  636. {
  637.     register IntegerFeedbackPtr feedc;
  638.  
  639.     feedc = (IntegerFeedbackPtr)xalloc(sizeof(IntegerFeedbackClassRec));
  640.     if (!feedc)
  641.     return FALSE;
  642.     feedc->CtrlProc = controlProc;
  643.     feedc->ctrl = defaultIntegerControl;
  644.     feedc->ctrl.id = 0;
  645.     if (feedc->next = dev->intfeed)
  646.     feedc->ctrl.id = dev->intfeed->ctrl.id + 1;
  647.     dev->intfeed = feedc;
  648.     (*controlProc)(dev, &feedc->ctrl);
  649.     return TRUE;
  650. }
  651.  
  652. Bool
  653. InitPointerDeviceStruct(device, map, numButtons, motionProc, controlProc,
  654.             numMotionEvents)
  655.     DevicePtr device;
  656.     CARD8 *map;
  657.     int numButtons;
  658.     void (*controlProc)();
  659.     int (*motionProc)();
  660.     int numMotionEvents;
  661. {
  662.     DeviceIntPtr dev = (DeviceIntPtr)device;
  663.  
  664.     return(InitButtonClassDeviceStruct(dev, numButtons, map) &&
  665.        InitValuatorClassDeviceStruct(dev, 2, motionProc,
  666.                      numMotionEvents, 0) &&
  667.        InitPtrFeedbackClassDeviceStruct(dev, controlProc));
  668. }
  669.  
  670. Bool
  671. InitKeyboardDeviceStruct(device, pKeySyms, pModifiers, bellProc, controlProc)
  672.     DevicePtr device;
  673.     KeySymsPtr pKeySyms;
  674.     CARD8 pModifiers[];
  675.     void (*bellProc)();
  676.     void (*controlProc)();
  677. {
  678.     DeviceIntPtr dev = (DeviceIntPtr)device;
  679.  
  680.     return(InitKeyClassDeviceStruct(dev, pKeySyms, pModifiers) &&
  681.        InitFocusClassDeviceStruct(dev) &&
  682.        InitKbdFeedbackClassDeviceStruct(dev, bellProc, controlProc));
  683. }
  684.  
  685. int
  686. SendMappingNotify(request, firstKeyCode, count)
  687.     CARD8 request, count;
  688.     KeyCode firstKeyCode;
  689. {
  690.     int i;
  691.     xEvent event;
  692.  
  693.     event.u.u.type = MappingNotify;
  694.     event.u.mappingNotify.request = request;
  695.     if (request == MappingKeyboard)
  696.     {
  697.         event.u.mappingNotify.firstKeyCode = firstKeyCode;
  698.         event.u.mappingNotify.count = count;
  699.     }
  700.     /* 0 is the server client */
  701.     for (i=1; i<currentMaxClients; i++)
  702.         if (clients[i] && ! clients[i]->clientGone &&
  703.         (clients[i]->requestVector != InitialVector))
  704.     {
  705.         event.u.u.sequenceNumber = clients[i]->sequence;
  706.             WriteEventsToClient(clients[i], 1, &event);
  707.     }
  708. }
  709.  
  710. /*
  711.  * n-squared algorithm. n < 255 and don't want to copy the whole thing and
  712.  * sort it to do the checking. How often is it called? Just being lazy?
  713.  */
  714. Bool
  715. BadDeviceMap(buff, length, low, high, errval)
  716.     register BYTE *buff;
  717.     int length;
  718.     unsigned low, high;
  719.     XID *errval;
  720. {
  721.     register int     i, j;
  722.  
  723.     for (i = 0; i < length; i++)
  724.     if (buff[i])               /* only check non-zero elements */
  725.     {
  726.         if ((low > buff[i]) || (high < buff[i]))
  727.         {
  728.         *errval = buff[i];
  729.         return TRUE;
  730.         }
  731.         for (j = i + 1; j < length; j++)
  732.         if (buff[i] == buff[j])
  733.         {
  734.             *errval = buff[i];
  735.             return TRUE;
  736.         }
  737.     }
  738.     return FALSE;
  739. }
  740.  
  741. Bool
  742. AllModifierKeysAreUp(dev, map1, per1, map2, per2)
  743.     register DeviceIntPtr dev;
  744.     register CARD8 *map1, *map2;
  745.     int per1, per2;
  746. {
  747.     register int i, j, k;
  748.     register CARD8 *down = dev->key->down;
  749.  
  750.     for (i = 8; --i >= 0; map2 += per2)
  751.     {
  752.     for (j = per1; --j >= 0; map1++)
  753.     {
  754.         if (*map1 && BitIsOn(down, *map1))
  755.         {
  756.         for (k = per2; (--k >= 0) && (*map1 != map2[k]);)
  757.           ;
  758.         if (k < 0)
  759.             return FALSE;
  760.         }
  761.     }
  762.     }
  763.     return TRUE;
  764. }
  765.  
  766. int 
  767. ProcSetModifierMapping(client)
  768.     ClientPtr client;
  769. {
  770.     xSetModifierMappingReply rep;
  771.     REQUEST(xSetModifierMappingReq);
  772.     KeyCode *inputMap;
  773.     int inputMapLen;
  774.     register int i;
  775.     DeviceIntPtr keybd = inputInfo.keyboard;
  776.     register KeyClassPtr keyc = keybd->key;
  777.     
  778.     REQUEST_AT_LEAST_SIZE(xSetModifierMappingReq);
  779.  
  780.     if (stuff->length != ((stuff->numKeyPerModifier<<1) +
  781.               (sizeof (xSetModifierMappingReq)>>2)))
  782.     return BadLength;
  783.  
  784.     inputMapLen = 8*stuff->numKeyPerModifier;
  785.     inputMap = (KeyCode *)&stuff[1];
  786.  
  787.     /*
  788.      *    Now enforce the restriction that "all of the non-zero keycodes must be
  789.      *    in the range specified by min-keycode and max-keycode in the
  790.      *    connection setup (else a Value error)"
  791.      */
  792.     i = inputMapLen;
  793.     while (i--)
  794.     {
  795.     if (inputMap[i]
  796.         && (inputMap[i] < keyc->curKeySyms.minKeyCode
  797.         || inputMap[i] > keyc->curKeySyms.maxKeyCode))
  798.     {
  799.         client->errorValue = inputMap[i];
  800.         return BadValue;
  801.     }
  802.     }
  803.     rep.type = X_Reply;
  804.     rep.length = 0;
  805.     rep.sequenceNumber = client->sequence;
  806.     rep.success = MappingSuccess;
  807.  
  808.     /*
  809.      *    Now enforce the restriction that none of the old or new
  810.      *    modifier keys may be down while we change the mapping,  and
  811.      *    that the DDX layer likes the choice.
  812.      */
  813.     if (!AllModifierKeysAreUp(keybd, keyc->modifierKeyMap,
  814.                   (int)keyc->maxKeysPerModifier,
  815.                   inputMap, (int)stuff->numKeyPerModifier)
  816.         ||
  817.     !AllModifierKeysAreUp(keybd, inputMap, (int)stuff->numKeyPerModifier,
  818.                   keyc->modifierKeyMap,
  819.                   (int)keyc->maxKeysPerModifier))
  820.     {
  821.     rep.success = MappingBusy;
  822.     }
  823.     else
  824.     {
  825.     for (i = 0; i < inputMapLen; i++)
  826.     {
  827.         if (inputMap[i] && !LegalModifier(inputMap[i], keybd))
  828.         {
  829.         rep.success = MappingFailed;
  830.         break;
  831.         }
  832.     }
  833.     }
  834.  
  835.     if (rep.success == MappingSuccess)
  836.     {
  837.     KeyCode *map;
  838.     /*
  839.      *    Now build the keyboard's modifier bitmap from the
  840.      *    list of keycodes.
  841.      */
  842.     map = (KeyCode *)xalloc(inputMapLen);
  843.     if (!map)
  844.         return BadAlloc;
  845.     if (keyc->modifierKeyMap)
  846.         xfree(keyc->modifierKeyMap);
  847.     keyc->modifierKeyMap = map;
  848.     bcopy((char *)inputMap, (char *)map, inputMapLen);
  849.  
  850.     keyc->maxKeysPerModifier = stuff->numKeyPerModifier;
  851.     for (i = 0; i < MAP_LENGTH; i++)
  852.         keyc->modifierMap[i] = 0;
  853.     for (i = 0; i < inputMapLen; i++)
  854.     {
  855.         if (inputMap[i])
  856.         keyc->modifierMap[inputMap[i]] |=
  857.             (1<<(i/keyc->maxKeysPerModifier));
  858.     }
  859.     }
  860.  
  861.     if (rep.success == MappingSuccess)
  862.         SendMappingNotify(MappingModifier, 0, 0);
  863.  
  864.     WriteReplyToClient(client, sizeof(xSetModifierMappingReply), &rep);
  865.  
  866.     return(client->noClientException);
  867. }
  868.  
  869. int
  870. ProcGetModifierMapping(client)
  871.     ClientPtr client;
  872. {
  873.     xGetModifierMappingReply rep;
  874.     REQUEST(xReq);
  875.     register KeyClassPtr keyc = inputInfo.keyboard->key;
  876.  
  877.     REQUEST_SIZE_MATCH(xReq);
  878.     rep.type = X_Reply;
  879.     rep.numKeyPerModifier = keyc->maxKeysPerModifier;
  880.     rep.sequenceNumber = client->sequence;
  881.     /* length counts 4 byte quantities - there are 8 modifiers 1 byte big */
  882.     rep.length = keyc->maxKeysPerModifier << 1;
  883.  
  884.     WriteReplyToClient(client, sizeof(xGetModifierMappingReply), &rep);
  885.  
  886.     /* Use the (modified by DDX) map that SetModifierMapping passed in */
  887.     (void)WriteToClient(client, (int)(keyc->maxKeysPerModifier << 3),
  888.             (char *)keyc->modifierKeyMap);
  889.     return client->noClientException;
  890. }
  891.  
  892. int
  893. ProcChangeKeyboardMapping(client)
  894.     ClientPtr client;
  895. {
  896.     REQUEST(xChangeKeyboardMappingReq);
  897.     unsigned len;
  898.     KeySymsRec keysyms;
  899.     register KeySymsPtr curKeySyms = &inputInfo.keyboard->key->curKeySyms;
  900.     REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq);
  901.  
  902.     len = stuff->length - (sizeof(xChangeKeyboardMappingReq) >> 2);  
  903.     if (len != (stuff->keyCodes * stuff->keySymsPerKeyCode))
  904.             return BadLength;
  905.     if ((stuff->firstKeyCode < curKeySyms->minKeyCode) ||
  906.     (stuff->firstKeyCode > curKeySyms->maxKeyCode))
  907.     {
  908.         client->errorValue = stuff->firstKeyCode;
  909.         return BadValue;
  910.     }
  911.     if ((stuff->firstKeyCode + stuff->keyCodes - 1 > curKeySyms->maxKeyCode) ||
  912.     (stuff->keySymsPerKeyCode == 0))
  913.     {
  914.         client->errorValue = stuff->keySymsPerKeyCode;
  915.         return BadValue;
  916.     }
  917.     keysyms.minKeyCode = stuff->firstKeyCode;
  918.     keysyms.maxKeyCode = stuff->firstKeyCode + stuff->keyCodes - 1;
  919.     keysyms.mapWidth = stuff->keySymsPerKeyCode;
  920.     keysyms.map = (KeySym *)&stuff[1];
  921.     if (!SetKeySymsMap(curKeySyms, &keysyms))
  922.     return BadAlloc;
  923.     SendMappingNotify(MappingKeyboard, stuff->firstKeyCode, stuff->keyCodes);
  924.     return client->noClientException;
  925.  
  926. }
  927.  
  928. int
  929. ProcSetPointerMapping(client)
  930.     ClientPtr client;
  931. {
  932.     REQUEST(xSetPointerMappingReq);
  933.     BYTE *map;
  934.     xSetPointerMappingReply rep;
  935.     register int i;
  936.     DeviceIntPtr mouse = inputInfo.pointer;
  937.  
  938.     REQUEST_AT_LEAST_SIZE(xSetPointerMappingReq);
  939.     if (stuff->length != (sizeof(xSetPointerMappingReq) + stuff->nElts + 3)>>2)
  940.     return BadLength;
  941.     rep.type = X_Reply;
  942.     rep.length = 0;
  943.     rep.sequenceNumber = client->sequence;
  944.     rep.success = MappingSuccess;
  945.     map = (BYTE *)&stuff[1];
  946.     if (stuff->nElts != mouse->button->numButtons)
  947.     {
  948.     client->errorValue = stuff->nElts;
  949.     return BadValue;
  950.     }
  951.     if (BadDeviceMap(&map[0], (int)stuff->nElts, 1, 255, &client->errorValue))
  952.     return BadValue;
  953.     for (i=0; i < stuff->nElts; i++)
  954.     if ((mouse->button->map[i + 1] != map[i]) &&
  955.         BitIsOn(mouse->button->down, i + 1))
  956.     {
  957.             rep.success = MappingBusy;
  958.         WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep);
  959.             return Success;
  960.     }
  961.     for (i = 0; i < stuff->nElts; i++)
  962.     mouse->button->map[i + 1] = map[i];
  963.     SendMappingNotify(MappingPointer, 0, 0);
  964.     WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep);
  965.     return Success;
  966. }
  967.  
  968. int
  969. ProcGetKeyboardMapping(client)
  970.     ClientPtr client;
  971. {
  972.     xGetKeyboardMappingReply rep;
  973.     REQUEST(xGetKeyboardMappingReq);
  974.     KeySymsPtr curKeySyms = &inputInfo.keyboard->key->curKeySyms;
  975.  
  976.     REQUEST_SIZE_MATCH(xGetKeyboardMappingReq);
  977.  
  978.     if ((stuff->firstKeyCode < curKeySyms->minKeyCode) ||
  979.         (stuff->firstKeyCode > curKeySyms->maxKeyCode))
  980.     {
  981.     client->errorValue = stuff->firstKeyCode;
  982.     return BadValue;
  983.     }
  984.     if (stuff->firstKeyCode + stuff->count > curKeySyms->maxKeyCode + 1)
  985.     {
  986.     client->errorValue = stuff->count;
  987.         return BadValue;
  988.     }
  989.  
  990.     rep.type = X_Reply;
  991.     rep.sequenceNumber = client->sequence;
  992.     rep.keySymsPerKeyCode = curKeySyms->mapWidth;
  993.     /* length is a count of 4 byte quantities and KeySyms are 4 bytes */
  994.     rep.length = (curKeySyms->mapWidth * stuff->count);
  995.     WriteReplyToClient(client, sizeof(xGetKeyboardMappingReply), &rep);
  996.     client->pSwapReplyFunc = CopySwap32Write;
  997.     WriteSwappedDataToClient(
  998.     client,
  999.     curKeySyms->mapWidth * stuff->count * sizeof(KeySym),
  1000.     &curKeySyms->map[(stuff->firstKeyCode - curKeySyms->minKeyCode) *
  1001.              curKeySyms->mapWidth]);
  1002.  
  1003.     return client->noClientException;
  1004. }
  1005.  
  1006. int
  1007. ProcGetPointerMapping(client)
  1008.     ClientPtr client;
  1009. {
  1010.     xGetPointerMappingReply rep;
  1011.     REQUEST(xReq);
  1012.     ButtonClassPtr butc = inputInfo.pointer->button;
  1013.  
  1014.     REQUEST_SIZE_MATCH(xReq);
  1015.     rep.type = X_Reply;
  1016.     rep.sequenceNumber = client->sequence;
  1017.     rep.nElts = butc->numButtons;
  1018.     rep.length = (rep.nElts + (4-1))/4;
  1019.     WriteReplyToClient(client, sizeof(xGetPointerMappingReply), &rep);
  1020.     (void)WriteToClient(client, (int)rep.nElts, (char *)&butc->map[1]);
  1021.     return Success;    
  1022. }
  1023.  
  1024. void
  1025. NoteLedState(keybd, led, on)
  1026.     DeviceIntPtr keybd;
  1027.     int        led;
  1028.     Bool    on;
  1029. {
  1030.     KeybdCtrl *ctrl = &keybd->kbdfeed->ctrl;
  1031.     if (on)
  1032.     ctrl->leds |= ((Leds)1 << (led - 1));
  1033.     else
  1034.     ctrl->leds &= ~((Leds)1 << (led - 1));
  1035. }
  1036.  
  1037. int
  1038. Ones(mask)                /* HACKMEM 169 */
  1039.     Mask mask;
  1040. {
  1041.     register Mask y;
  1042.  
  1043.     y = (mask >> 1) &033333333333;
  1044.     y = mask - y - ((y >>1) & 033333333333);
  1045.     return (((y + (y >> 3)) & 030707070707) % 077);
  1046. }
  1047.  
  1048. int
  1049. ProcChangeKeyboardControl (client)
  1050.     ClientPtr client;
  1051. {
  1052. #define DO_ALL    (-1)
  1053.     KeybdCtrl ctrl;
  1054.     DeviceIntPtr keybd = inputInfo.keyboard;
  1055.     XID *vlist;
  1056.     int t;
  1057.     int led = DO_ALL;
  1058.     int key = DO_ALL;
  1059.     BITS32 vmask, index;
  1060.     int mask, i;
  1061.     REQUEST(xChangeKeyboardControlReq);
  1062.  
  1063.     REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
  1064.     vmask = stuff->mask;
  1065.     if (stuff->length !=(sizeof(xChangeKeyboardControlReq)>>2) + Ones(vmask))
  1066.     return BadLength;
  1067.     vlist = (XID *)&stuff[1];        /* first word of values */
  1068.     ctrl = keybd->kbdfeed->ctrl;
  1069.     while (vmask)
  1070.     {
  1071.     index = (BITS32) lowbit (vmask);
  1072.     vmask &= ~index;
  1073.     switch (index)
  1074.     {
  1075.     case KBKeyClickPercent: 
  1076.         t = (INT8)*vlist;
  1077.         vlist++;
  1078.         if (t == -1)
  1079.         t = defaultKeyboardControl.click;
  1080.         else if (t < 0 || t > 100)
  1081.         {
  1082.         client->errorValue = t;
  1083.         return BadValue;
  1084.         }
  1085.         ctrl.click = t;
  1086.         break;
  1087.     case KBBellPercent:
  1088.         t = (INT8)*vlist;
  1089.         vlist++;
  1090.         if (t == -1)
  1091.         t = defaultKeyboardControl.bell;
  1092.         else if (t < 0 || t > 100)
  1093.         {
  1094.         client->errorValue = t;
  1095.         return BadValue;
  1096.         }
  1097.         ctrl.bell = t;
  1098.         break;
  1099.     case KBBellPitch:
  1100.         t = (INT16)*vlist;
  1101.         vlist++;
  1102.         if (t == -1)
  1103.         t = defaultKeyboardControl.bell_pitch;
  1104.         else if (t < 0)
  1105.         {
  1106.         client->errorValue = t;
  1107.         return BadValue;
  1108.         }
  1109.         ctrl.bell_pitch = t;
  1110.         break;
  1111.     case KBBellDuration:
  1112.         t = (INT16)*vlist;
  1113.         vlist++;
  1114.         if (t == -1)
  1115.         t = defaultKeyboardControl.bell_duration;
  1116.         else if (t < 0)
  1117.         {
  1118.         client->errorValue = t;
  1119.         return BadValue;
  1120.         }
  1121.         ctrl.bell_duration = t;
  1122.         break;
  1123.     case KBLed:
  1124.         led = (CARD8)*vlist;
  1125.         vlist++;
  1126.         if (led < 1 || led > 32)
  1127.         {
  1128.         client->errorValue = led;
  1129.         return BadValue;
  1130.         }
  1131.         if (!(stuff->mask & KBLedMode))
  1132.         return BadMatch;
  1133.         break;
  1134.     case KBLedMode:
  1135.         t = (CARD8)*vlist;
  1136.         vlist++;
  1137.         if (t == LedModeOff)
  1138.         {
  1139.         if (led == DO_ALL)
  1140.             ctrl.leds = 0x0;
  1141.         else
  1142.             ctrl.leds &= ~(((Leds)(1)) << (led - 1));
  1143.         }
  1144.         else if (t == LedModeOn)
  1145.         {
  1146.         if (led == DO_ALL)
  1147.             ctrl.leds = ~0L;
  1148.         else
  1149.             ctrl.leds |= (((Leds)(1)) << (led - 1));
  1150.         }
  1151.         else
  1152.         {
  1153.         client->errorValue = t;
  1154.         return BadValue;
  1155.         }
  1156.         break;
  1157.     case KBKey:
  1158.         key = (KeyCode)*vlist;
  1159.         vlist++;
  1160.         if (key < inputInfo.keyboard->key->curKeySyms.minKeyCode ||
  1161.         key > inputInfo.keyboard->key->curKeySyms.maxKeyCode)
  1162.         {
  1163.         client->errorValue = key;
  1164.         return BadValue;
  1165.         }
  1166.         if (!(stuff->mask & KBAutoRepeatMode))
  1167.         return BadMatch;
  1168.         break;
  1169.     case KBAutoRepeatMode:
  1170.         i = (key >> 3);
  1171.         mask = (1 << (key & 7));
  1172.         t = (CARD8)*vlist;
  1173.         vlist++;
  1174.         if (t == AutoRepeatModeOff)
  1175.         {
  1176.         if (key == DO_ALL)
  1177.             ctrl.autoRepeat = FALSE;
  1178.         else
  1179.             ctrl.autoRepeats[i] &= ~mask;
  1180.         }
  1181.         else if (t == AutoRepeatModeOn)
  1182.         {
  1183.         if (key == DO_ALL)
  1184.             ctrl.autoRepeat = TRUE;
  1185.         else
  1186.             ctrl.autoRepeats[i] |= mask;
  1187.         }
  1188.         else if (t == AutoRepeatModeDefault)
  1189.         {
  1190.         if (key == DO_ALL)
  1191.             ctrl.autoRepeat = defaultKeyboardControl.autoRepeat;
  1192.         else
  1193.             ctrl.autoRepeats[i] =
  1194.                 (ctrl.autoRepeats[i] & ~mask) |
  1195.                 (defaultKeyboardControl.autoRepeats[i] & mask);
  1196.         }
  1197.         else
  1198.         {
  1199.         client->errorValue = t;
  1200.         return BadValue;
  1201.         }
  1202.         break;
  1203.     default:
  1204.         client->errorValue = stuff->mask;
  1205.         return BadValue;
  1206.     }
  1207.     }
  1208.     keybd->kbdfeed->ctrl = ctrl;
  1209.     (*keybd->kbdfeed->CtrlProc)(keybd, &keybd->kbdfeed->ctrl);
  1210.     return Success;
  1211. #undef DO_ALL
  1212. } 
  1213.  
  1214. int
  1215. ProcGetKeyboardControl (client)
  1216.     ClientPtr client;
  1217. {
  1218.     int i;
  1219.     register KeybdCtrl *ctrl = &inputInfo.keyboard->kbdfeed->ctrl;
  1220.     xGetKeyboardControlReply rep;
  1221.     REQUEST(xReq);
  1222.  
  1223.     REQUEST_SIZE_MATCH(xReq);
  1224.     rep.type = X_Reply;
  1225.     rep.length = 5;
  1226.     rep.sequenceNumber = client->sequence;
  1227.     rep.globalAutoRepeat = ctrl->autoRepeat;
  1228.     rep.keyClickPercent = ctrl->click;
  1229.     rep.bellPercent = ctrl->bell;
  1230.     rep.bellPitch = ctrl->bell_pitch;
  1231.     rep.bellDuration = ctrl->bell_duration;
  1232.     rep.ledMask = ctrl->leds;
  1233.     for (i = 0; i < 32; i++)
  1234.     rep.map[i] = ctrl->autoRepeats[i];
  1235.     WriteReplyToClient(client, sizeof(xGetKeyboardControlReply), &rep);
  1236.     return Success;
  1237. } 
  1238.  
  1239. int
  1240. ProcBell(client)
  1241.     ClientPtr client;
  1242. {
  1243.     register DeviceIntPtr keybd = inputInfo.keyboard;
  1244.     int base = keybd->kbdfeed->ctrl.bell;
  1245.     int newpercent;
  1246.     REQUEST(xBellReq);
  1247.     REQUEST_SIZE_MATCH(xBellReq);
  1248.     if (stuff->percent < -100 || stuff->percent > 100)
  1249.     {
  1250.     client->errorValue = stuff->percent;
  1251.     return BadValue;
  1252.     }
  1253.     newpercent = (base * stuff->percent) / 100;
  1254.     if (stuff->percent < 0)
  1255.         newpercent = base + newpercent;
  1256.     else
  1257.         newpercent = base - newpercent + stuff->percent;
  1258.     (*keybd->kbdfeed->BellProc)(newpercent, keybd);
  1259.     return Success;
  1260. } 
  1261.  
  1262. int
  1263. ProcChangePointerControl(client)
  1264.     ClientPtr client;
  1265. {
  1266.     DeviceIntPtr mouse = inputInfo.pointer;
  1267.     PtrCtrl ctrl;        /* might get BadValue part way through */
  1268.     REQUEST(xChangePointerControlReq);
  1269.  
  1270.     REQUEST_SIZE_MATCH(xChangePointerControlReq);
  1271.     ctrl = mouse->ptrfeed->ctrl;
  1272.     if ((stuff->doAccel != xTrue) && (stuff->doAccel != xFalse))
  1273.     {
  1274.     client->errorValue = stuff->doAccel;
  1275.     return(BadValue);
  1276.     }
  1277.     if ((stuff->doThresh != xTrue) && (stuff->doThresh != xFalse))
  1278.     {
  1279.     client->errorValue = stuff->doThresh;
  1280.     return(BadValue);
  1281.     }
  1282.     if (stuff->doAccel)
  1283.     {
  1284.     if (stuff->accelNum == -1)
  1285.         ctrl.num = defaultPointerControl.num;
  1286.     else if (stuff->accelNum < 0)
  1287.     {
  1288.         client->errorValue = stuff->accelNum;
  1289.         return BadValue;
  1290.     }
  1291.     else ctrl.num = stuff->accelNum;
  1292.     if (stuff->accelDenum == -1)
  1293.         ctrl.den = defaultPointerControl.den;
  1294.     else if (stuff->accelDenum <= 0)
  1295.     {
  1296.         client->errorValue = stuff->accelDenum;
  1297.         return BadValue;
  1298.     }
  1299.     else ctrl.den = stuff->accelDenum;
  1300.     }
  1301.     if (stuff->doThresh)
  1302.     {
  1303.     if (stuff->threshold == -1)
  1304.         ctrl.threshold = defaultPointerControl.threshold;
  1305.     else if (stuff->threshold < 0)
  1306.     {
  1307.         client->errorValue = stuff->threshold;
  1308.         return BadValue;
  1309.     }
  1310.     else ctrl.threshold = stuff->threshold;
  1311.     }
  1312.     mouse->ptrfeed->ctrl = ctrl;
  1313.     (*mouse->ptrfeed->CtrlProc)(mouse, &mouse->ptrfeed->ctrl);
  1314.     return Success;
  1315. } 
  1316.  
  1317. int
  1318. ProcGetPointerControl(client)
  1319.     ClientPtr client;
  1320. {
  1321.     register PtrCtrl *ctrl = &inputInfo.pointer->ptrfeed->ctrl;
  1322.     REQUEST(xReq);
  1323.     xGetPointerControlReply rep;
  1324.  
  1325.     REQUEST_SIZE_MATCH(xReq);
  1326.     rep.type = X_Reply;
  1327.     rep.length = 0;
  1328.     rep.sequenceNumber = client->sequence;
  1329.     rep.threshold = ctrl->threshold;
  1330.     rep.accelNumerator = ctrl->num;
  1331.     rep.accelDenominator = ctrl->den;
  1332.     WriteReplyToClient(client, sizeof(xGenericReply), &rep);
  1333.     return Success;
  1334. }
  1335.  
  1336. void
  1337. MaybeStopHint(dev, client)
  1338.     register DeviceIntPtr dev;
  1339.     ClientPtr client;
  1340. {
  1341.     GrabPtr grab = dev->grab;
  1342.  
  1343.     if ((grab && SameClient(grab, client) &&
  1344.      ((grab->eventMask & PointerMotionHintMask) ||
  1345.       (grab->ownerEvents &&
  1346.        (EventMaskForClient(dev->valuator->motionHintWindow, client) &
  1347.         PointerMotionHintMask)))) ||
  1348.     (!grab &&
  1349.      (EventMaskForClient(dev->valuator->motionHintWindow, client) &
  1350.       PointerMotionHintMask)))
  1351.     dev->valuator->motionHintWindow = NullWindow;
  1352. }
  1353.  
  1354. int
  1355. ProcGetMotionEvents(client)
  1356.     ClientPtr client;
  1357. {
  1358.     WindowPtr pWin;
  1359.     xTimecoord * coords = (xTimecoord *) NULL;
  1360.     xGetMotionEventsReply rep;
  1361.     int     i, count, xmin, xmax, ymin, ymax;
  1362.     unsigned long nEvents;
  1363.     DeviceIntPtr mouse = inputInfo.pointer;
  1364.     TimeStamp start, stop;
  1365.     REQUEST(xGetMotionEventsReq);
  1366.  
  1367.     REQUEST_SIZE_MATCH(xGetMotionEventsReq);
  1368.     pWin = LookupWindow(stuff->window, client);
  1369.     if (!pWin)
  1370.     return BadWindow;
  1371.     if (mouse->valuator->motionHintWindow)
  1372.     MaybeStopHint(mouse, client);
  1373.     rep.type = X_Reply;
  1374.     rep.sequenceNumber = client->sequence;
  1375.     nEvents = 0;
  1376.     start = ClientTimeToServerTime(stuff->start);
  1377.     stop = ClientTimeToServerTime(stuff->stop);
  1378.     if ((CompareTimeStamps(start, stop) != LATER) &&
  1379.     (CompareTimeStamps(start, currentTime) != LATER) &&
  1380.     mouse->valuator->numMotionEvents)
  1381.     {
  1382.     if (CompareTimeStamps(stop, currentTime) == LATER)
  1383.         stop = currentTime;
  1384.     coords = (xTimecoord *)ALLOCATE_LOCAL(mouse->valuator->numMotionEvents
  1385.                           * sizeof(xTimecoord));
  1386.     if (!coords)
  1387.         return BadAlloc;
  1388.     count = (*mouse->valuator->GetMotionProc) (mouse, coords,
  1389.                            start.milliseconds,
  1390.                            stop.milliseconds,
  1391.                            pWin->drawable.pScreen);
  1392.     xmin = pWin->drawable.x - wBorderWidth (pWin);
  1393.     xmax = pWin->drawable.x + (int)pWin->drawable.width +
  1394.         wBorderWidth (pWin);
  1395.     ymin = pWin->drawable.y - wBorderWidth (pWin);
  1396.     ymax = pWin->drawable.y + (int)pWin->drawable.height +
  1397.         wBorderWidth (pWin);
  1398.     for (i = 0; i < count; i++)
  1399.         if ((xmin <= coords[i].x) && (coords[i].x < xmax) &&
  1400.             (ymin <= coords[i].y) && (coords[i].y < ymax))
  1401.         {
  1402.         coords[nEvents].time = coords[i].time;
  1403.         coords[nEvents].x = coords[i].x - pWin->drawable.x;
  1404.         coords[nEvents].y = coords[i].y - pWin->drawable.y;
  1405.         nEvents++;
  1406.         }
  1407.     }
  1408.     rep.length = nEvents * (sizeof(xTimecoord) >> 2);
  1409.     rep.nEvents = nEvents;
  1410.     WriteReplyToClient(client, sizeof(xGetMotionEventsReply), &rep);
  1411.     if (nEvents)
  1412.     {
  1413.     client->pSwapReplyFunc = SwapTimeCoordWrite;
  1414.     WriteSwappedDataToClient(client, nEvents * sizeof(xTimecoord),
  1415.                  (char *)coords);
  1416.     }
  1417.     if (coords)
  1418.     DEALLOCATE_LOCAL(coords);
  1419.     return Success;
  1420. }
  1421.  
  1422. int
  1423. ProcQueryKeymap(client)
  1424.     ClientPtr client;
  1425. {
  1426.     xQueryKeymapReply rep;
  1427.     int i;
  1428.     CARD8 *down = inputInfo.keyboard->key->down;
  1429.  
  1430.     rep.type = X_Reply;
  1431.     rep.sequenceNumber = client->sequence;
  1432.     rep.length = 2;
  1433.     for (i = 0; i<32; i++)
  1434.     rep.map[i] = down[i];
  1435.     WriteReplyToClient(client, sizeof(xQueryKeymapReply), &rep);
  1436.     return Success;
  1437. }
  1438.  
  1439.