git.sesse.net Git - rdpsrv/blob - Xserver/programs/Xserver/dix/devices.c

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