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