XFree86: devices.c File Reference

00084 { 00085 register DeviceIntPtr dev; 00086 00087 if (inputInfo.numDevices >= MAX_DEVICES) 00088 return (DeviceIntPtr)NULL; 00089 dev = (DeviceIntPtr) xalloc(sizeof(DeviceIntRec)); 00090 if (!dev) 00091 return (DeviceIntPtr)NULL; 00092 dev->name = (char *)NULL; 00093 dev->type = 0; 00094 dev->id = inputInfo.numDevices; 00095 inputInfo.numDevices++; 00096 dev->public.on = FALSE; 00097 dev->public.processInputProc = (ProcessInputProc)NoopDDA; 00098 dev->public.realInputProc = (ProcessInputProc)NoopDDA; 00099 dev->public.enqueueInputProc = EnqueueEvent; 00100 dev->deviceProc = deviceProc; 00101 dev->startup = autoStart; 00102 dev->sync.frozen = FALSE; 00103 dev->sync.other = NullGrab; 00104 dev->sync.state = NOT_GRABBED; 00105 dev->sync.event = (xEvent *) NULL; 00106 dev->sync.evcount = 0; 00107 dev->grab = NullGrab; 00108 dev->grabTime = currentTime; 00109 dev->fromPassiveGrab = FALSE; 00110 dev->key = (KeyClassPtr)NULL; 00111 dev->valuator = (ValuatorClassPtr)NULL; 00112 dev->button = (ButtonClassPtr)NULL; 00113 dev->focus = (FocusClassPtr)NULL; 00114 dev->proximity = (ProximityClassPtr)NULL; 00115 dev->kbdfeed = (KbdFeedbackPtr)NULL; 00116 dev->ptrfeed = (PtrFeedbackPtr)NULL; 00117 dev->intfeed = (IntegerFeedbackPtr)NULL; 00118 dev->stringfeed = (StringFeedbackPtr)NULL; 00119 dev->bell = (BellFeedbackPtr)NULL; 00120 dev->leds = (LedFeedbackPtr)NULL; 00121 dev->next = inputInfo.off_devices; 00122 #ifdef XKB 00123 dev->xkb_interest= NULL; 00124 #endif 00125 inputInfo.off_devices = dev; 00126 return dev; 00127 }

00132 { 00133 register DeviceIntPtr *prev; 00134 00135 for (prev = &inputInfo.off_devices; 00136 *prev && (*prev != dev); 00137 prev = &(*prev)->next) 00138 ; 00139 if ((*prev != dev) || !dev->inited || 00140 ((*dev->deviceProc)(dev, DEVICE_ON) != Success)) 00141 return FALSE; 00142 *prev = dev->next; 00143 dev->next = inputInfo.devices; 00144 inputInfo.devices = dev; 00145 return TRUE; 00146 }

00151 { 00152 register DeviceIntPtr *prev; 00153 00154 for (prev = &inputInfo.devices; 00155 *prev && (*prev != dev); 00156 prev = &(*prev)->next) 00157 ; 00158 if (*prev != dev) 00159 return FALSE; 00160 (void)(*dev->deviceProc)(dev, DEVICE_OFF); 00161 *prev = dev->next; 00162 dev->next = inputInfo.off_devices; 00163 inputInfo.off_devices = dev; 00164 return TRUE; 00165 }

00169 { 00170 register DeviceIntPtr dev, next; 00171 00172 for (dev = inputInfo.off_devices; dev; dev = dev->next) 00173 dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success); 00174 for (dev = inputInfo.off_devices; dev; dev = next) 00175 { 00176 next = dev->next; 00177 if (dev->inited && dev->startup) 00178 (void)EnableDevice(dev); 00179 } 00180 for (dev = inputInfo.devices; 00181 dev && (dev != inputInfo.keyboard); 00182 dev = dev->next) 00183 ; 00184 if (!dev || (dev != inputInfo.keyboard)) { 00185 ErrorF("No core keyboard\n"); 00186 return BadImplementation; 00187 } 00188 for (dev = inputInfo.devices; 00189 dev && (dev != inputInfo.pointer); 00190 dev = dev->next) 00191 ; 00192 if (!dev || (dev != inputInfo.pointer)) { 00193 ErrorF("No core pointer\n"); 00194 return BadImplementation; 00195 } 00196 return Success; 00197 }

00746 { 00747 int i; 00748 register StringFeedbackPtr feedc; 00749 00750 feedc = (StringFeedbackPtr)xalloc(sizeof(StringFeedbackClassRec)); 00751 if (!feedc) 00752 return FALSE; 00753 feedc->CtrlProc = controlProc; 00754 feedc->ctrl.num_symbols_supported = num_symbols_supported; 00755 feedc->ctrl.num_symbols_displayed = 0; 00756 feedc->ctrl.max_symbols = max_symbols; 00757 feedc->ctrl.symbols_supported = (KeySym *) 00758 xalloc (sizeof (KeySym) * num_symbols_supported); 00759 feedc->ctrl.symbols_displayed = (KeySym *) 00760 xalloc (sizeof (KeySym) * max_symbols); 00761 if (!feedc->ctrl.symbols_supported || !feedc->ctrl.symbols_displayed) 00762 { 00763 if (feedc->ctrl.symbols_supported) 00764 xfree(feedc->ctrl.symbols_supported); 00765 if (feedc->ctrl.symbols_displayed) 00766 xfree(feedc->ctrl.symbols_displayed); 00767 xfree(feedc); 00768 return FALSE; 00769 } 00770 for (i=0; i<num_symbols_supported; i++) 00771 *(feedc->ctrl.symbols_supported+i) = *symbols++; 00772 for (i=0; i<max_symbols; i++) 00773 *(feedc->ctrl.symbols_displayed+i) = (KeySym) NULL; 00774 feedc->ctrl.id = 0; 00775 if ( (feedc->next = dev->stringfeed) ) 00776 feedc->ctrl.id = dev->stringfeed->ctrl.id + 1; 00777 dev->stringfeed = feedc; 00778 (*controlProc)(dev, &feedc->ctrl); 00779 return TRUE; 00780 }

00787 { 00788 register BellFeedbackPtr feedc; 00789 00790 feedc = (BellFeedbackPtr)xalloc(sizeof(BellFeedbackClassRec)); 00791 if (!feedc) 00792 return FALSE; 00793 feedc->CtrlProc = controlProc; 00794 feedc->BellProc = bellProc; 00795 feedc->ctrl = defaultBellControl; 00796 feedc->ctrl.id = 0; 00797 if ( (feedc->next = dev->bell) ) 00798 feedc->ctrl.id = dev->bell->ctrl.id + 1; 00799 dev->bell = feedc; 00800 (*controlProc)(dev, &feedc->ctrl); 00801 return TRUE; 00802 }

00808 { 00809 register LedFeedbackPtr feedc; 00810 00811 feedc = (LedFeedbackPtr)xalloc(sizeof(LedFeedbackClassRec)); 00812 if (!feedc) 00813 return FALSE; 00814 feedc->CtrlProc = controlProc; 00815 feedc->ctrl = defaultLedControl; 00816 feedc->ctrl.id = 0; 00817 if ( (feedc->next = dev->leds) ) 00818 feedc->ctrl.id = dev->leds->ctrl.id + 1; 00819 #ifdef XKB 00820 feedc->xkb_sli= NULL; 00821 #endif 00822 dev->leds = feedc; 00823 (*controlProc)(dev, &feedc->ctrl); 00824 return TRUE; 00825 }

00831 { 00832 register IntegerFeedbackPtr feedc; 00833 00834 feedc = (IntegerFeedbackPtr)xalloc(sizeof(IntegerFeedbackClassRec)); 00835 if (!feedc) 00836 return FALSE; 00837 feedc->CtrlProc = controlProc; 00838 feedc->ctrl = defaultIntegerControl; 00839 feedc->ctrl.id = 0; 00840 if ( (feedc->next = dev->intfeed) ) 00841 feedc->ctrl.id = dev->intfeed->ctrl.id + 1; 00842 dev->intfeed = feedc; 00843 (*controlProc)(dev, &feedc->ctrl); 00844 return TRUE; 00845 }

00856 { 00857 DeviceIntPtr dev = (DeviceIntPtr)device; 00858 00859 return(InitButtonClassDeviceStruct(dev, numButtons, map) && 00860 InitValuatorClassDeviceStruct(dev, 2, motionProc, 00861 numMotionEvents, 0) && 00862 InitPtrFeedbackClassDeviceStruct(dev, controlProc)); 00863 }

00872 { 00873 DeviceIntPtr dev = (DeviceIntPtr)device; 00874 00875 return(InitKeyClassDeviceStruct(dev, pKeySyms, pModifiers) && 00876 InitFocusClassDeviceStruct(dev) && 00877 InitKbdFeedbackClassDeviceStruct(dev, bellProc, controlProc)); 00878 }

00885 { 00886 int i; 00887 xEvent event; 00888 00889 event.u.u.type = MappingNotify; 00890 event.u.mappingNotify.request = request; 00891 if (request == MappingKeyboard) 00892 { 00893 event.u.mappingNotify.firstKeyCode = firstKeyCode; 00894 event.u.mappingNotify.count = count; 00895 } 00896 #ifdef XKB 00897 if (!noXkbExtension && 00898 ((request == MappingKeyboard) || (request == MappingModifier))) { 00899 XkbApplyMappingChange(inputInfo.keyboard,request,firstKeyCode,count, 00900 client); 00901 } 00902 #endif 00903 00904 /* 0 is the server client */ 00905 for (i=1; i<currentMaxClients; i++) 00906 { 00907 if (clients[i] && clients[i]->clientState == ClientStateRunning) 00908 { 00909 #ifdef XKB 00910 if (!noXkbExtension && 00911 (request == MappingKeyboard) && 00912 (clients[i]->xkbClientFlags != 0) && 00913 (clients[i]->mapNotifyMask&XkbKeySymsMask)) 00914 continue; 00915 #endif 00916 event.u.u.sequenceNumber = clients[i]->sequence; 00917 WriteEventsToClient(clients[i], 1, &event); 00918 } 00919 } 00920 }

00932 { 00933 register int i, j; 00934 00935 for (i = 0; i < length; i++) 00936 if (buff[i]) /* only check non-zero elements */ 00937 { 00938 if ((low > buff[i]) || (high < buff[i])) 00939 { 00940 *errval = buff[i]; 00941 return TRUE; 00942 } 00943 for (j = i + 1; j < length; j++) 00944 if (buff[i] == buff[j]) 00945 { 00946 *errval = buff[i]; 00947 return TRUE; 00948 } 00949 } 00950 return FALSE; 00951 }

00958 { 00959 register int i, j, k; 00960 register CARD8 *down = dev->key->down; 00961 00962 for (i = 8; --i >= 0; map2 += per2) 00963 { 00964 for (j = per1; --j >= 0; map1++) 00965 { 00966 if (*map1 && BitIsOn(down, *map1)) 00967 { 00968 for (k = per2; (--k >= 0) && (*map1 != map2[k]);) 00969 ; 00970 if (k < 0) 00971 return FALSE; 00972 } 00973 } 00974 } 00975 return TRUE; 00976 }

00981 { 00982 xSetModifierMappingReply rep; 00983 REQUEST(xSetModifierMappingReq); 00984 KeyCode *inputMap; 00985 int inputMapLen; 00986 register int i; 00987 DeviceIntPtr keybd = inputInfo.keyboard; 00988 register KeyClassPtr keyc = keybd->key; 00989 00990 REQUEST_AT_LEAST_SIZE(xSetModifierMappingReq); 00991 00992 if (client->req_len != ((stuff->numKeyPerModifier<<1) + 00993 (sizeof (xSetModifierMappingReq)>>2))) 00994 return BadLength; 00995 00996 inputMapLen = 8*stuff->numKeyPerModifier; 00997 inputMap = (KeyCode *)&stuff[1]; 00998 00999 /* 01000 * Now enforce the restriction that "all of the non-zero keycodes must be 01001 * in the range specified by min-keycode and max-keycode in the 01002 * connection setup (else a Value error)" 01003 */ 01004 i = inputMapLen; 01005 while (i--) 01006 { 01007 if (inputMap[i] 01008 && (inputMap[i] < keyc->curKeySyms.minKeyCode 01009 || inputMap[i] > keyc->curKeySyms.maxKeyCode)) 01010 { 01011 client->errorValue = inputMap[i]; 01012 return BadValue; 01013 } 01014 } 01015 01016 #ifdef XCSECURITY 01017 if (!SecurityCheckDeviceAccess(client, keybd, TRUE)) 01018 return BadAccess; 01019 #endif 01020 01021 #ifdef LBX 01022 LbxFlushModifierMapTag(); 01023 #endif 01024 rep.type = X_Reply; 01025 rep.length = 0; 01026 rep.sequenceNumber = client->sequence; 01027 rep.success = MappingSuccess; 01028 01029 /* 01030 * Now enforce the restriction that none of the old or new 01031 * modifier keys may be down while we change the mapping, and 01032 * that the DDX layer likes the choice. 01033 */ 01034 if (!AllModifierKeysAreUp(keybd, keyc->modifierKeyMap, 01035 (int)keyc->maxKeysPerModifier, 01036 inputMap, (int)stuff->numKeyPerModifier) 01037 || 01038 !AllModifierKeysAreUp(keybd, inputMap, (int)stuff->numKeyPerModifier, 01039 keyc->modifierKeyMap, 01040 (int)keyc->maxKeysPerModifier)) 01041 { 01042 rep.success = MappingBusy; 01043 } 01044 else 01045 { 01046 for (i = 0; i < inputMapLen; i++) 01047 { 01048 if (inputMap[i] && !LegalModifier(inputMap[i], (DevicePtr)keybd)) 01049 { 01050 rep.success = MappingFailed; 01051 break; 01052 } 01053 } 01054 } 01055 01056 if (rep.success == MappingSuccess) 01057 { 01058 KeyCode *map; 01059 /* 01060 * Now build the keyboard's modifier bitmap from the 01061 * list of keycodes. 01062 */ 01063 map = (KeyCode *)xalloc(inputMapLen); 01064 if (!map && inputMapLen) 01065 return BadAlloc; 01066 if (keyc->modifierKeyMap) 01067 xfree(keyc->modifierKeyMap); 01068 keyc->modifierKeyMap = map; 01069 memmove((char *)map, (char *)inputMap, inputMapLen); 01070 01071 keyc->maxKeysPerModifier = stuff->numKeyPerModifier; 01072 for (i = 0; i < MAP_LENGTH; i++) 01073 keyc->modifierMap[i] = 0; 01074 for (i = 0; i < inputMapLen; i++) 01075 { 01076 if (inputMap[i]) 01077 keyc->modifierMap[inputMap[i]] |= 01078 (1<<(((unsigned int)i)/keyc->maxKeysPerModifier)); 01079 } 01080 } 01081 01082 if (rep.success == MappingSuccess) 01083 SendMappingNotify(MappingModifier, 0, 0, client); 01084 01085 WriteReplyToClient(client, sizeof(xSetModifierMappingReply), &rep); 01086 01087 return(client->noClientException); 01088 }

01093 { 01094 xGetModifierMappingReply rep; 01095 register KeyClassPtr keyc = inputInfo.keyboard->key; 01096 01097 REQUEST_SIZE_MATCH(xReq); 01098 rep.type = X_Reply; 01099 rep.numKeyPerModifier = keyc->maxKeysPerModifier; 01100 rep.sequenceNumber = client->sequence; 01101 /* length counts 4 byte quantities - there are 8 modifiers 1 byte big */ 01102 rep.length = keyc->maxKeysPerModifier << 1; 01103 01104 WriteReplyToClient(client, sizeof(xGetModifierMappingReply), &rep); 01105 01106 /* Use the (modified by DDX) map that SetModifierMapping passed in */ 01107 (void)WriteToClient(client, (int)(keyc->maxKeysPerModifier << 3), 01108 (char *)keyc->modifierKeyMap); 01109 return client->noClientException; 01110 }

01115 { 01116 REQUEST(xChangeKeyboardMappingReq); 01117 unsigned len; 01118 KeySymsRec keysyms; 01119 register KeySymsPtr curKeySyms = &inputInfo.keyboard->key->curKeySyms; 01120 REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq); 01121 01122 len = client->req_len - (sizeof(xChangeKeyboardMappingReq) >> 2); 01123 if (len != (stuff->keyCodes * stuff->keySymsPerKeyCode)) 01124 return BadLength; 01125 if ((stuff->firstKeyCode < curKeySyms->minKeyCode) || 01126 (stuff->firstKeyCode > curKeySyms->maxKeyCode)) 01127 { 01128 client->errorValue = stuff->firstKeyCode; 01129 return BadValue; 01130 } 01131 if ( ((unsigned)(stuff->firstKeyCode + stuff->keyCodes - 1) > 01132 curKeySyms->maxKeyCode) || 01133 (stuff->keySymsPerKeyCode == 0)) 01134 { 01135 client->errorValue = stuff->keySymsPerKeyCode; 01136 return BadValue; 01137 } 01138 #ifdef XCSECURITY 01139 if (!SecurityCheckDeviceAccess(client, inputInfo.keyboard, 01140 TRUE)) 01141 return BadAccess; 01142 #endif 01143 keysyms.minKeyCode = stuff->firstKeyCode; 01144 keysyms.maxKeyCode = stuff->firstKeyCode + stuff->keyCodes - 1; 01145 keysyms.mapWidth = stuff->keySymsPerKeyCode; 01146 keysyms.map = (KeySym *)&stuff[1]; 01147 if (!SetKeySymsMap(curKeySyms, &keysyms)) 01148 return BadAlloc; 01149 #ifdef LBX 01150 LbxFlushKeyboardMapTag(); 01151 #endif 01152 SendMappingNotify(MappingKeyboard, stuff->firstKeyCode, stuff->keyCodes, 01153 client); 01154 return client->noClientException; 01155 01156 }

01161 { 01162 REQUEST(xSetPointerMappingReq); 01163 BYTE *map; 01164 xSetPointerMappingReply rep; 01165 register unsigned int i; 01166 DeviceIntPtr mouse = inputInfo.pointer; 01167 01168 REQUEST_AT_LEAST_SIZE(xSetPointerMappingReq); 01169 if (client->req_len != (sizeof(xSetPointerMappingReq)+stuff->nElts+3) >> 2) 01170 return BadLength; 01171 rep.type = X_Reply; 01172 rep.length = 0; 01173 rep.sequenceNumber = client->sequence; 01174 rep.success = MappingSuccess; 01175 map = (BYTE *)&stuff[1]; 01176 if (stuff->nElts != mouse->button->numButtons) 01177 { 01178 client->errorValue = stuff->nElts; 01179 return BadValue; 01180 } 01181 if (BadDeviceMap(&map[0], (int)stuff->nElts, 1, 255, &client->errorValue)) 01182 return BadValue; 01183 for (i=0; i < stuff->nElts; i++) 01184 if ((mouse->button->map[i + 1] != map[i]) && 01185 BitIsOn(mouse->button->down, i + 1)) 01186 { 01187 rep.success = MappingBusy; 01188 WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep); 01189 return Success; 01190 } 01191 for (i = 0; i < stuff->nElts; i++) 01192 mouse->button->map[i + 1] = map[i]; 01193 SendMappingNotify(MappingPointer, 0, 0, client); 01194 WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep); 01195 return Success; 01196 }

01201 { 01202 xGetKeyboardMappingReply rep; 01203 REQUEST(xGetKeyboardMappingReq); 01204 KeySymsPtr curKeySyms = &inputInfo.keyboard->key->curKeySyms; 01205 01206 REQUEST_SIZE_MATCH(xGetKeyboardMappingReq); 01207 01208 if ((stuff->firstKeyCode < curKeySyms->minKeyCode) || 01209 (stuff->firstKeyCode > curKeySyms->maxKeyCode)) 01210 { 01211 client->errorValue = stuff->firstKeyCode; 01212 return BadValue; 01213 } 01214 if (stuff->firstKeyCode + stuff->count > 01215 (unsigned)(curKeySyms->maxKeyCode + 1)) 01216 { 01217 client->errorValue = stuff->count; 01218 return BadValue; 01219 } 01220 01221 rep.type = X_Reply; 01222 rep.sequenceNumber = client->sequence; 01223 rep.keySymsPerKeyCode = curKeySyms->mapWidth; 01224 /* length is a count of 4 byte quantities and KeySyms are 4 bytes */ 01225 rep.length = (curKeySyms->mapWidth * stuff->count); 01226 WriteReplyToClient(client, sizeof(xGetKeyboardMappingReply), &rep); 01227 client->pSwapReplyFunc = (ReplySwapPtr) CopySwap32Write; 01228 WriteSwappedDataToClient( 01229 client, 01230 curKeySyms->mapWidth * stuff->count * sizeof(KeySym), 01231 &curKeySyms->map[(stuff->firstKeyCode - curKeySyms->minKeyCode) * 01232 curKeySyms->mapWidth]); 01233 01234 return client->noClientException; 01235 }

01240 { 01241 xGetPointerMappingReply rep; 01242 ButtonClassPtr butc = inputInfo.pointer->button; 01243 01244 REQUEST_SIZE_MATCH(xReq); 01245 rep.type = X_Reply; 01246 rep.sequenceNumber = client->sequence; 01247 rep.nElts = butc->numButtons; 01248 rep.length = ((unsigned)rep.nElts + (4-1))/4; 01249 WriteReplyToClient(client, sizeof(xGetPointerMappingReply), &rep); 01250 (void)WriteToClient(client, (int)rep.nElts, (char *)&butc->map[1]); 01251 return Success; 01252 }

01259 { 01260 KeybdCtrl *ctrl = &keybd->kbdfeed->ctrl; 01261 if (on) 01262 ctrl->leds |= ((Leds)1 << (led - 1)); 01263 else 01264 ctrl->leds &= ~((Leds)1 << (led - 1)); 01265 }

01270 { 01271 register unsigned long y; 01272 01273 y = (mask >> 1) &033333333333; 01274 y = mask - y - ((y >>1) & 033333333333); 01275 return (((y + (y >> 3)) & 030707070707) % 077); 01276 }

01281 { 01282 #define DO_ALL (-1) 01283 KeybdCtrl ctrl; 01284 DeviceIntPtr keybd = inputInfo.keyboard; 01285 XID *vlist; 01286 int t; 01287 int led = DO_ALL; 01288 int key = DO_ALL; 01289 BITS32 vmask, index2; 01290 int mask, i; 01291 REQUEST(xChangeKeyboardControlReq); 01292 01293 REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq); 01294 vmask = stuff->mask; 01295 if (client->req_len != (sizeof(xChangeKeyboardControlReq)>>2)+Ones(vmask)) 01296 return BadLength; 01297 #ifdef XCSECURITY 01298 if (!SecurityCheckDeviceAccess(client, keybd, TRUE)) 01299 return BadAccess; 01300 #endif 01301 vlist = (XID *)&stuff[1]; /* first word of values */ 01302 ctrl = keybd->kbdfeed->ctrl; 01303 while (vmask) 01304 { 01305 index2 = (BITS32) lowbit (vmask); 01306 vmask &= ~index2; 01307 switch (index2) 01308 { 01309 case KBKeyClickPercent: 01310 t = (INT8)*vlist; 01311 vlist++; 01312 if (t == -1) 01313 t = defaultKeyboardControl.click; 01314 else if (t < 0 || t > 100) 01315 { 01316 client->errorValue = t; 01317 return BadValue; 01318 } 01319 ctrl.click = t; 01320 break; 01321 case KBBellPercent: 01322 t = (INT8)*vlist; 01323 vlist++; 01324 if (t == -1) 01325 t = defaultKeyboardControl.bell; 01326 else if (t < 0 || t > 100) 01327 { 01328 client->errorValue = t; 01329 return BadValue; 01330 } 01331 ctrl.bell = t; 01332 break; 01333 case KBBellPitch: 01334 t = (INT16)*vlist; 01335 vlist++; 01336 if (t == -1) 01337 t = defaultKeyboardControl.bell_pitch; 01338 else if (t < 0) 01339 { 01340 client->errorValue = t; 01341 return BadValue; 01342 } 01343 ctrl.bell_pitch = t; 01344 break; 01345 case KBBellDuration: 01346 t = (INT16)*vlist; 01347 vlist++; 01348 if (t == -1) 01349 t = defaultKeyboardControl.bell_duration; 01350 else if (t < 0) 01351 { 01352 client->errorValue = t; 01353 return BadValue; 01354 } 01355 ctrl.bell_duration = t; 01356 break; 01357 case KBLed: 01358 led = (CARD8)*vlist; 01359 vlist++; 01360 if (led < 1 || led > 32) 01361 { 01362 client->errorValue = led; 01363 return BadValue; 01364 } 01365 if (!(stuff->mask & KBLedMode)) 01366 return BadMatch; 01367 break; 01368 case KBLedMode: 01369 t = (CARD8)*vlist; 01370 vlist++; 01371 if (t == LedModeOff) 01372 { 01373 if (led == DO_ALL) 01374 ctrl.leds = 0x0; 01375 else 01376 ctrl.leds &= ~(((Leds)(1)) << (led - 1)); 01377 } 01378 else if (t == LedModeOn) 01379 { 01380 if (led == DO_ALL) 01381 ctrl.leds = ~0L; 01382 else 01383 ctrl.leds |= (((Leds)(1)) << (led - 1)); 01384 } 01385 else 01386 { 01387 client->errorValue = t; 01388 return BadValue; 01389 } 01390 #ifdef XKB 01391 if (!noXkbExtension) { 01392 XkbEventCauseRec cause; 01393 XkbSetCauseCoreReq(&cause,X_ChangeKeyboardControl,client); 01394 XkbSetIndicators(keybd,((led == DO_ALL) ? ~0L : (1L<<(led-1))), 01395 ctrl.leds, &cause); 01396 ctrl.leds = keybd->kbdfeed->ctrl.leds; 01397 } 01398 #endif 01399 break; 01400 case KBKey: 01401 key = (KeyCode)*vlist; 01402 vlist++; 01403 if ((KeyCode)key < inputInfo.keyboard->key->curKeySyms.minKeyCode || 01404 (KeyCode)key > inputInfo.keyboard->key->curKeySyms.maxKeyCode) 01405 { 01406 client->errorValue = key; 01407 return BadValue; 01408 } 01409 if (!(stuff->mask & KBAutoRepeatMode)) 01410 return BadMatch; 01411 break; 01412 case KBAutoRepeatMode: 01413 i = (key >> 3); 01414 mask = (1 << (key & 7)); 01415 t = (CARD8)*vlist; 01416 vlist++; 01417 #ifdef XKB 01418 if (!noXkbExtension && key != DO_ALL) 01419 XkbDisableComputedAutoRepeats(keybd,key); 01420 #endif 01421 if (t == AutoRepeatModeOff) 01422 { 01423 if (key == DO_ALL) 01424 ctrl.autoRepeat = FALSE; 01425 else 01426 ctrl.autoRepeats[i] &= ~mask; 01427 } 01428 else if (t == AutoRepeatModeOn) 01429 { 01430 if (key == DO_ALL) 01431 ctrl.autoRepeat = TRUE; 01432 else 01433 ctrl.autoRepeats[i] |= mask; 01434 } 01435 else if (t == AutoRepeatModeDefault) 01436 { 01437 if (key == DO_ALL) 01438 ctrl.autoRepeat = defaultKeyboardControl.autoRepeat; 01439 else 01440 ctrl.autoRepeats[i] = 01441 (ctrl.autoRepeats[i] & ~mask) | 01442 (defaultKeyboardControl.autoRepeats[i] & mask); 01443 } 01444 else 01445 { 01446 client->errorValue = t; 01447 return BadValue; 01448 } 01449 break; 01450 default: 01451 client->errorValue = stuff->mask; 01452 return BadValue; 01453 } 01454 } 01455 keybd->kbdfeed->ctrl = ctrl; 01456 #ifdef XKB 01457 /* The XKB RepeatKeys control and core protocol global autorepeat */ 01458 /* value are linked */ 01459 if (!noXkbExtension) { 01460 XkbSetRepeatKeys(keybd,key,keybd->kbdfeed->ctrl.autoRepeat); 01461 } 01462 else 01463 #endif 01464 (*keybd->kbdfeed->CtrlProc)(keybd, &keybd->kbdfeed->ctrl); 01465 return Success; 01466 #undef DO_ALL 01467 }

01472 { 01473 int i; 01474 register KeybdCtrl *ctrl = &inputInfo.keyboard->kbdfeed->ctrl; 01475 xGetKeyboardControlReply rep; 01476 01477 REQUEST_SIZE_MATCH(xReq); 01478 rep.type = X_Reply; 01479 rep.length = 5; 01480 rep.sequenceNumber = client->sequence; 01481 rep.globalAutoRepeat = ctrl->autoRepeat; 01482 rep.keyClickPercent = ctrl->click; 01483 rep.bellPercent = ctrl->bell; 01484 rep.bellPitch = ctrl->bell_pitch; 01485 rep.bellDuration = ctrl->bell_duration; 01486 rep.ledMask = ctrl->leds; 01487 for (i = 0; i < 32; i++) 01488 rep.map[i] = ctrl->autoRepeats[i]; 01489 WriteReplyToClient(client, sizeof(xGetKeyboardControlReply), &rep); 01490 return Success; 01491 }

01496 { 01497 register DeviceIntPtr keybd = inputInfo.keyboard; 01498 int base = keybd->kbdfeed->ctrl.bell; 01499 int newpercent; 01500 REQUEST(xBellReq); 01501 REQUEST_SIZE_MATCH(xBellReq); 01502 if (stuff->percent < -100 || stuff->percent > 100) 01503 { 01504 client->errorValue = stuff->percent; 01505 return BadValue; 01506 } 01507 newpercent = (base * stuff->percent) / 100; 01508 if (stuff->percent < 0) 01509 newpercent = base + newpercent; 01510 else 01511 newpercent = base - newpercent + stuff->percent; 01512 #ifdef XKB 01513 if (!noXkbExtension) 01514 XkbHandleBell(FALSE,FALSE, keybd, newpercent, &keybd->kbdfeed->ctrl, 0, 01515 None, NULL, client); 01516 else 01517 #endif 01518 (*keybd->kbdfeed->BellProc)(newpercent, keybd, 01519 (pointer) &keybd->kbdfeed->ctrl, 0); 01520 return Success; 01521 }

01526 { 01527 DeviceIntPtr mouse = inputInfo.pointer; 01528 PtrCtrl ctrl; /* might get BadValue part way through */ 01529 REQUEST(xChangePointerControlReq); 01530 01531 REQUEST_SIZE_MATCH(xChangePointerControlReq); 01532 ctrl = mouse->ptrfeed->ctrl; 01533 if ((stuff->doAccel != xTrue) && (stuff->doAccel != xFalse)) 01534 { 01535 client->errorValue = stuff->doAccel; 01536 return(BadValue); 01537 } 01538 if ((stuff->doThresh != xTrue) && (stuff->doThresh != xFalse)) 01539 { 01540 client->errorValue = stuff->doThresh; 01541 return(BadValue); 01542 } 01543 if (stuff->doAccel) 01544 { 01545 if (stuff->accelNum == -1) 01546 ctrl.num = defaultPointerControl.num; 01547 else if (stuff->accelNum < 0) 01548 { 01549 client->errorValue = stuff->accelNum; 01550 return BadValue; 01551 } 01552 else ctrl.num = stuff->accelNum; 01553 if (stuff->accelDenum == -1) 01554 ctrl.den = defaultPointerControl.den; 01555 else if (stuff->accelDenum <= 0) 01556 { 01557 client->errorValue = stuff->accelDenum; 01558 return BadValue; 01559 } 01560 else ctrl.den = stuff->accelDenum; 01561 } 01562 if (stuff->doThresh) 01563 { 01564 if (stuff->threshold == -1) 01565 ctrl.threshold = defaultPointerControl.threshold; 01566 else if (stuff->threshold < 0) 01567 { 01568 client->errorValue = stuff->threshold; 01569 return BadValue; 01570 } 01571 else ctrl.threshold = stuff->threshold; 01572 } 01573 mouse->ptrfeed->ctrl = ctrl; 01574 (*mouse->ptrfeed->CtrlProc)(mouse, &mouse->ptrfeed->ctrl); 01575 return Success; 01576 }

01581 { 01582 register PtrCtrl *ctrl = &inputInfo.pointer->ptrfeed->ctrl; 01583 xGetPointerControlReply rep; 01584 01585 REQUEST_SIZE_MATCH(xReq); 01586 rep.type = X_Reply; 01587 rep.length = 0; 01588 rep.sequenceNumber = client->sequence; 01589 rep.threshold = ctrl->threshold; 01590 rep.accelNumerator = ctrl->num; 01591 rep.accelDenominator = ctrl->den; 01592 WriteReplyToClient(client, sizeof(xGenericReply), &rep); 01593 return Success; 01594 }

01600 { 01601 GrabPtr grab = dev->grab; 01602 01603 if ((grab && SameClient(grab, client) && 01604 ((grab->eventMask & PointerMotionHintMask) || 01605 (grab->ownerEvents && 01606 (EventMaskForClient(dev->valuator->motionHintWindow, client) & 01607 PointerMotionHintMask)))) || 01608 (!grab && 01609 (EventMaskForClient(dev->valuator->motionHintWindow, client) & 01610 PointerMotionHintMask))) 01611 dev->valuator->motionHintWindow = NullWindow; 01612 }

01617 { 01618 WindowPtr pWin; 01619 xTimecoord * coords = (xTimecoord *) NULL; 01620 xGetMotionEventsReply rep; 01621 int i, count, xmin, xmax, ymin, ymax; 01622 unsigned long nEvents; 01623 DeviceIntPtr mouse = inputInfo.pointer; 01624 TimeStamp start, stop; 01625 REQUEST(xGetMotionEventsReq); 01626 01627 REQUEST_SIZE_MATCH(xGetMotionEventsReq); 01628 pWin = SecurityLookupWindow(stuff->window, client, TRUE); 01629 if (!pWin) 01630 return BadWindow; 01631 if (mouse->valuator->motionHintWindow) 01632 MaybeStopHint(mouse, client); 01633 rep.type = X_Reply; 01634 rep.sequenceNumber = client->sequence; 01635 nEvents = 0; 01636 start = ClientTimeToServerTime(stuff->start); 01637 stop = ClientTimeToServerTime(stuff->stop); 01638 if ((CompareTimeStamps(start, stop) != LATER) && 01639 (CompareTimeStamps(start, currentTime) != LATER) && 01640 mouse->valuator->numMotionEvents) 01641 { 01642 if (CompareTimeStamps(stop, currentTime) == LATER) 01643 stop = currentTime; 01644 coords = (xTimecoord *)ALLOCATE_LOCAL(mouse->valuator->numMotionEvents 01645 * sizeof(xTimecoord)); 01646 if (!coords) 01647 return BadAlloc; 01648 count = (*mouse->valuator->GetMotionProc) (mouse, coords, 01649 start.milliseconds, 01650 stop.milliseconds, 01651 pWin->drawable.pScreen); 01652 xmin = pWin->drawable.x - wBorderWidth (pWin); 01653 xmax = pWin->drawable.x + (int)pWin->drawable.width + 01654 wBorderWidth (pWin); 01655 ymin = pWin->drawable.y - wBorderWidth (pWin); 01656 ymax = pWin->drawable.y + (int)pWin->drawable.height + 01657 wBorderWidth (pWin); 01658 for (i = 0; i < count; i++) 01659 if ((xmin <= coords[i].x) && (coords[i].x < xmax) && 01660 (ymin <= coords[i].y) && (coords[i].y < ymax)) 01661 { 01662 coords[nEvents].time = coords[i].time; 01663 coords[nEvents].x = coords[i].x - pWin->drawable.x; 01664 coords[nEvents].y = coords[i].y - pWin->drawable.y; 01665 nEvents++; 01666 } 01667 } 01668 rep.length = nEvents * (sizeof(xTimecoord) >> 2); 01669 rep.nEvents = nEvents; 01670 WriteReplyToClient(client, sizeof(xGetMotionEventsReply), &rep); 01671 if (nEvents) 01672 { 01673 client->pSwapReplyFunc = (ReplySwapPtr) SwapTimeCoordWrite; 01674 WriteSwappedDataToClient(client, nEvents * sizeof(xTimecoord), 01675 (char *)coords); 01676 } 01677 if (coords) 01678 DEALLOCATE_LOCAL(coords); 01679 return Success; 01680 }

01685 { 01686 xQueryKeymapReply rep; 01687 int i; 01688 CARD8 *down = inputInfo.keyboard->key->down; 01689 01690 REQUEST_SIZE_MATCH(xReq); 01691 rep.type = X_Reply; 01692 rep.sequenceNumber = client->sequence; 01693 rep.length = 2; 01694 #ifdef XCSECURITY 01695 if (!SecurityCheckDeviceAccess(client, inputInfo.keyboard, TRUE)) 01696 { 01697 bzero((char *)&rep.map[0], 32); 01698 } 01699 else 01700 #endif 01701 for (i = 0; i<32; i++) 01702 rep.map[i] = down[i]; 01703 WriteReplyToClient(client, sizeof(xQueryKeymapReply), &rep); 01704 return Success; 01705 }

{ DEFAULT_BELL, DEFAULT_BELL_PITCH, DEFAULT_BELL_DURATION, 0}

{ DEFAULT_INT_RESOLUTION, DEFAULT_INT_MIN_VALUE, DEFAULT_INT_MAX_VALUE, DEFAULT_INT_DISPLAYED, 0}


Functions
DeviceIntPtr	_AddInputDevice (DeviceProc deviceProc, Bool autoStart)
Bool	EnableDevice (DeviceIntPtr dev)
Bool	DisableDevice (DeviceIntPtr dev)
int	InitAndStartDevices ()
void	CloseDevice (register DeviceIntPtr dev) CloseDevice(dev) register DeviceIntPtr dev
Bool	InitStringFeedbackClassDeviceStruct (DeviceIntPtr dev, StringCtrlProcPtr controlProc, int max_symbols, int num_symbols_supported, KeySym *symbols)
Bool	InitBellFeedbackClassDeviceStruct (DeviceIntPtr dev, BellProcPtr bellProc, BellCtrlProcPtr controlProc)
Bool	InitLedFeedbackClassDeviceStruct (DeviceIntPtr dev, LedCtrlProcPtr controlProc)
Bool	InitIntegerFeedbackClassDeviceStruct (DeviceIntPtr dev, IntegerCtrlProcPtr controlProc)
Bool	InitPointerDeviceStruct (DevicePtr device, CARD8 *map, int numButtons, ValuatorMotionProcPtr motionProc, PtrCtrlProcPtr controlProc, int numMotionEvents)
Bool	InitKeyboardDeviceStruct (DevicePtr device, KeySymsPtr pKeySyms, pModifiers, BellProcPtr bellProc, KbdCtrlProcPtr controlProc)
void	SendMappingNotify (unsigned int request, unsigned int firstKeyCode, unsigned int count, ClientPtr client)
Bool	BadDeviceMap (BYTE buff, int length, unsigned low, unsigned high, XID errval)
Bool	AllModifierKeysAreUp (DeviceIntPtr dev, CARD8 map1, int per1, CARD8 map2, int per2)
int	ProcSetModifierMapping (ClientPtr client)
int	ProcGetModifierMapping (ClientPtr client)
int	ProcChangeKeyboardMapping (ClientPtr client)
int	ProcSetPointerMapping (ClientPtr client)
int	ProcGetKeyboardMapping (ClientPtr client)
int	ProcGetPointerMapping (ClientPtr client)
void	NoteLedState (DeviceIntPtr keybd, int led, Bool on)
int	Ones (unsigned long mask)
int	ProcChangeKeyboardControl (ClientPtr client)
int	ProcGetKeyboardControl (ClientPtr client)
int	ProcBell (ClientPtr client)
int	ProcChangePointerControl (ClientPtr client)
int	ProcGetPointerControl (ClientPtr client)
void	MaybeStopHint (DeviceIntPtr dev, ClientPtr client)
int	ProcGetMotionEvents (ClientPtr client)
int	ProcQueryKeymap (ClientPtr client)
DevicePtr	AddInputDevice (DeviceProc deviceProc, Bool autoStart) DevicePtr AddInputDevice(deviceProc
Variables
*	maxCode
	src
KeySymsPtr	pKeySyms
CARD8	pModifiers []
int	numButtons
CARD8 *	map
ValuatorMotionProcPtr	motionProc
int	numAxes
int	numMotionEvents
int	mode
BellProcPtr	bellProc
KbdCtrlProcPtr	controlProc
BellCtrl	defaultBellControl
IntegerCtrl	defaultIntegerControl
DevicePtr autoStart DeviceProc	deviceProc
Bool	autoStart

e:/XFree86 for RH 8.0/XFree86-4.2.0/xc/programs/Xserver/dix/devices.c File Reference

Functions

Variables

Function Documentation

Variable Documentation