File: | xkb/xkbLEDs.c |
Location: | line 612, column 17 |
Description: | Array access (via field 'names') results in a null pointer dereference |
1 | /************************************************************ | |||
2 | Copyright (c) 1995 by Silicon Graphics Computer Systems, Inc. | |||
3 | ||||
4 | Permission to use, copy, modify, and distribute this | |||
5 | software and its documentation for any purpose and without | |||
6 | fee is hereby granted, provided that the above copyright | |||
7 | notice appear in all copies and that both that copyright | |||
8 | notice and this permission notice appear in supporting | |||
9 | documentation, and that the name of Silicon Graphics not be | |||
10 | used in advertising or publicity pertaining to distribution | |||
11 | of the software without specific prior written permission. | |||
12 | Silicon Graphics makes no representation about the suitability | |||
13 | of this software for any purpose. It is provided "as is" | |||
14 | without any express or implied warranty. | |||
15 | ||||
16 | SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS | |||
17 | SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY | |||
18 | AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON | |||
19 | GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL | |||
20 | DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, | |||
21 | DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE | |||
22 | OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH | |||
23 | THE USE OR PERFORMANCE OF THIS SOFTWARE. | |||
24 | ||||
25 | ********************************************************/ | |||
26 | ||||
27 | #ifdef HAVE_DIX_CONFIG_H1 | |||
28 | #include <dix-config.h> | |||
29 | #endif | |||
30 | ||||
31 | #include <stdio.h> | |||
32 | #include <ctype.h> | |||
33 | #include <math.h> | |||
34 | #include <X11/X.h> | |||
35 | #include <X11/Xproto.h> | |||
36 | #include "misc.h" | |||
37 | #include "inputstr.h" | |||
38 | ||||
39 | #include <X11/extensions/XI.h> | |||
40 | #include <xkbsrv.h> | |||
41 | #include "xkb.h" | |||
42 | ||||
43 | /***====================================================================***/ | |||
44 | ||||
45 | /* | |||
46 | * unsigned | |||
47 | * XkbIndicatorsToUpdate(dev,changed,check_devs_rtrn) | |||
48 | * | |||
49 | * Given a keyboard and a set of state components that have changed, | |||
50 | * this function returns the indicators on the default keyboard | |||
51 | * feedback that might be affected. It also reports whether or not | |||
52 | * any extension devices might be affected in check_devs_rtrn. | |||
53 | */ | |||
54 | ||||
55 | unsigned | |||
56 | XkbIndicatorsToUpdate(DeviceIntPtr dev, | |||
57 | unsigned long state_changes, Bool enable_changes) | |||
58 | { | |||
59 | register unsigned update = 0; | |||
60 | XkbSrvLedInfoPtr sli; | |||
61 | ||||
62 | sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass0x0300, XkbDfltXIId0x0400, 0); | |||
63 | ||||
64 | if (!sli) | |||
65 | return update; | |||
66 | ||||
67 | if (state_changes & (XkbModifierStateMask(1L << 0) | XkbGroupStateMask(1L << 4))) | |||
68 | update |= sli->usesEffective; | |||
69 | if (state_changes & (XkbModifierBaseMask(1L << 1) | XkbGroupBaseMask(1L << 5))) | |||
70 | update |= sli->usesBase; | |||
71 | if (state_changes & (XkbModifierLatchMask(1L << 2) | XkbGroupLatchMask(1L << 6))) | |||
72 | update |= sli->usesLatched; | |||
73 | if (state_changes & (XkbModifierLockMask(1L << 3) | XkbGroupLockMask(1L << 7))) | |||
74 | update |= sli->usesLocked; | |||
75 | if (state_changes & XkbCompatStateMask(1L << 8)) | |||
76 | update |= sli->usesCompat; | |||
77 | if (enable_changes) | |||
78 | update |= sli->usesControls; | |||
79 | return update; | |||
80 | } | |||
81 | ||||
82 | /***====================================================================***/ | |||
83 | ||||
84 | /* | |||
85 | * Bool | |||
86 | *XkbApplyLEDChangeToKeyboard(xkbi,map,on,change) | |||
87 | * | |||
88 | * Some indicators "drive" the keyboard when their state is explicitly | |||
89 | * changed, as described in section 9.2.1 of the XKB protocol spec. | |||
90 | * This function updates the state and controls for the keyboard | |||
91 | * specified by 'xkbi' to reflect any changes that are required | |||
92 | * when the indicator described by 'map' is turned on or off. The | |||
93 | * extent of the changes is reported in change, which must be defined. | |||
94 | */ | |||
95 | static Bool | |||
96 | XkbApplyLEDChangeToKeyboard(XkbSrvInfoPtr xkbi, | |||
97 | XkbIndicatorMapPtr map, | |||
98 | Bool on, XkbChangesPtr change) | |||
99 | { | |||
100 | Bool ctrlChange, stateChange; | |||
101 | XkbStatePtr state; | |||
102 | ||||
103 | if ((map->flags & XkbIM_NoExplicit(1L << 7)) || | |||
104 | ((map->flags & XkbIM_LEDDrivesKB(1L << 5)) == 0)) | |||
105 | return FALSE0; | |||
106 | ctrlChange = stateChange = FALSE0; | |||
107 | if (map->ctrls) { | |||
108 | XkbControlsPtr ctrls = xkbi->desc->ctrls; | |||
109 | unsigned old; | |||
110 | ||||
111 | old = ctrls->enabled_ctrls; | |||
112 | if (on) | |||
113 | ctrls->enabled_ctrls |= map->ctrls; | |||
114 | else | |||
115 | ctrls->enabled_ctrls &= ~map->ctrls; | |||
116 | if (old != ctrls->enabled_ctrls) { | |||
117 | change->ctrls.changed_ctrls = XkbControlsEnabledMask(1L << 31); | |||
118 | change->ctrls.enabled_ctrls_changes = old ^ ctrls->enabled_ctrls; | |||
119 | ctrlChange = TRUE1; | |||
120 | } | |||
121 | } | |||
122 | state = &xkbi->state; | |||
123 | if ((map->groups) && ((map->which_groups & (~XkbIM_UseBase(1L << 0))) != 0)) { | |||
124 | register int i; | |||
125 | register unsigned bit, match; | |||
126 | ||||
127 | if (on) | |||
128 | match = (map->groups) & XkbAllGroupsMask(0xf); | |||
129 | else | |||
130 | match = (~map->groups) & XkbAllGroupsMask(0xf); | |||
131 | if (map->which_groups & (XkbIM_UseLocked(1L << 2) | XkbIM_UseEffective(1L << 3))) { | |||
132 | for (i = 0, bit = 1; i < XkbNumKbdGroups4; i++, bit <<= 1) { | |||
133 | if (bit & match) | |||
134 | break; | |||
135 | } | |||
136 | if (map->which_groups & XkbIM_UseLatched(1L << 1)) | |||
137 | XkbLatchGroupSrvXkbLatchGroup(xkbi->device, 0); /* unlatch group */ | |||
138 | state->locked_group = i; | |||
139 | stateChange = TRUE1; | |||
140 | } | |||
141 | else if (map->which_groups & (XkbIM_UseLatched(1L << 1) | XkbIM_UseEffective(1L << 3))) { | |||
142 | for (i = 0, bit = 1; i < XkbNumKbdGroups4; i++, bit <<= 1) { | |||
143 | if (bit & match) | |||
144 | break; | |||
145 | } | |||
146 | state->locked_group = 0; | |||
147 | XkbLatchGroupSrvXkbLatchGroup(xkbi->device, i); | |||
148 | stateChange = TRUE1; | |||
149 | } | |||
150 | } | |||
151 | if ((map->mods.mask) && ((map->which_mods & (~XkbIM_UseBase(1L << 0))) != 0)) { | |||
152 | if (map->which_mods & (XkbIM_UseLocked(1L << 2) | XkbIM_UseEffective(1L << 3))) { | |||
153 | register unsigned long old; | |||
154 | ||||
155 | old = state->locked_mods; | |||
156 | if (on) | |||
157 | state->locked_mods |= map->mods.mask; | |||
158 | else | |||
159 | state->locked_mods &= ~map->mods.mask; | |||
160 | if (state->locked_mods != old) | |||
161 | stateChange = TRUE1; | |||
162 | } | |||
163 | if (map->which_mods & (XkbIM_UseLatched(1L << 1) | XkbIM_UseEffective(1L << 3))) { | |||
164 | register unsigned long newmods; | |||
165 | ||||
166 | newmods = state->latched_mods; | |||
167 | if (on) | |||
168 | newmods |= map->mods.mask; | |||
169 | else | |||
170 | newmods &= ~map->mods.mask; | |||
171 | if (newmods != state->locked_mods) { | |||
172 | newmods &= map->mods.mask; | |||
173 | XkbLatchModifiersSrvXkbLatchModifiers(xkbi->device, map->mods.mask, newmods); | |||
174 | stateChange = TRUE1; | |||
175 | } | |||
176 | } | |||
177 | } | |||
178 | return stateChange || ctrlChange; | |||
179 | } | |||
180 | ||||
181 | /* | |||
182 | * Bool | |||
183 | * ComputeAutoState(map,state,ctrls) | |||
184 | * | |||
185 | * This function reports the effect of applying the specified | |||
186 | * indicator map given the specified state and controls, as | |||
187 | * described in section 9.2 of the XKB protocol specification. | |||
188 | */ | |||
189 | ||||
190 | static Bool | |||
191 | ComputeAutoState(XkbIndicatorMapPtr map, | |||
192 | XkbStatePtr state, XkbControlsPtr ctrls) | |||
193 | { | |||
194 | Bool on; | |||
195 | CARD8 mods, group; | |||
196 | ||||
197 | on = FALSE0; | |||
198 | mods = group = 0; | |||
199 | if (map->which_mods & XkbIM_UseAnyMods(((1L << 0)|(1L << 1)|(1L << 2) |(1L << 3))|(1L << 4))) { | |||
200 | if (map->which_mods & XkbIM_UseBase(1L << 0)) | |||
201 | mods |= state->base_mods; | |||
202 | if (map->which_mods & XkbIM_UseLatched(1L << 1)) | |||
203 | mods |= state->latched_mods; | |||
204 | if (map->which_mods & XkbIM_UseLocked(1L << 2)) | |||
205 | mods |= state->locked_mods; | |||
206 | if (map->which_mods & XkbIM_UseEffective(1L << 3)) | |||
207 | mods |= state->mods; | |||
208 | if (map->which_mods & XkbIM_UseCompat(1L << 4)) | |||
209 | mods |= state->compat_state; | |||
210 | on = ((map->mods.mask & mods) != 0); | |||
211 | on = on || ((mods == 0) && (map->mods.mask == 0) && | |||
212 | (map->mods.vmods == 0)); | |||
213 | } | |||
214 | if (map->which_groups & XkbIM_UseAnyGroup((1L << 0)|(1L << 1)|(1L << 2) |(1L << 3))) { | |||
215 | if (map->which_groups & XkbIM_UseBase(1L << 0)) | |||
216 | group |= (1L << state->base_group); | |||
217 | if (map->which_groups & XkbIM_UseLatched(1L << 1)) | |||
218 | group |= (1L << state->latched_group); | |||
219 | if (map->which_groups & XkbIM_UseLocked(1L << 2)) | |||
220 | group |= (1L << state->locked_group); | |||
221 | if (map->which_groups & XkbIM_UseEffective(1L << 3)) | |||
222 | group |= (1L << state->group); | |||
223 | on = on || (((map->groups & group) != 0) || (map->groups == 0)); | |||
224 | } | |||
225 | if (map->ctrls) | |||
226 | on = on || (ctrls->enabled_ctrls & map->ctrls); | |||
227 | return on; | |||
228 | } | |||
229 | ||||
230 | static void | |||
231 | XkbUpdateLedAutoState(DeviceIntPtr dev, | |||
232 | XkbSrvLedInfoPtr sli, | |||
233 | unsigned maps_to_check, | |||
234 | xkbExtensionDeviceNotify * ed, | |||
235 | XkbChangesPtr changes, XkbEventCausePtr cause) | |||
236 | { | |||
237 | DeviceIntPtr kbd; | |||
238 | XkbStatePtr state; | |||
239 | XkbControlsPtr ctrls; | |||
240 | XkbChangesRec my_changes; | |||
241 | xkbExtensionDeviceNotify my_ed; | |||
242 | register unsigned i, bit, affected; | |||
243 | register XkbIndicatorMapPtr map; | |||
244 | unsigned oldState; | |||
245 | ||||
246 | if ((maps_to_check == 0) || (sli->maps == NULL((void*)0)) || (sli->mapsPresent == 0)) | |||
247 | return; | |||
248 | ||||
249 | if (dev->key && dev->key->xkbInfo) | |||
250 | kbd = dev; | |||
251 | else | |||
252 | kbd = inputInfo.keyboard; | |||
253 | ||||
254 | state = &kbd->key->xkbInfo->state; | |||
255 | ctrls = kbd->key->xkbInfo->desc->ctrls; | |||
256 | affected = maps_to_check; | |||
257 | oldState = sli->effectiveState; | |||
258 | sli->autoState &= ~affected; | |||
259 | for (i = 0, bit = 1; (i < XkbNumIndicators32) && (affected); i++, bit <<= 1) { | |||
260 | if ((affected & bit) == 0) | |||
261 | continue; | |||
262 | affected &= ~bit; | |||
263 | map = &sli->maps[i]; | |||
264 | if ((!(map->flags & XkbIM_NoAutomatic(1L << 6))) && | |||
265 | ComputeAutoState(map, state, ctrls)) | |||
266 | sli->autoState |= bit; | |||
267 | } | |||
268 | sli->effectiveState = (sli->autoState | sli->explicitState); | |||
269 | affected = sli->effectiveState ^ oldState; | |||
270 | if (affected == 0) | |||
271 | return; | |||
272 | ||||
273 | if (ed == NULL((void*)0)) { | |||
274 | ed = &my_ed; | |||
275 | memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify))__builtin___memset_chk ((char *) ed, 0, sizeof(xkbExtensionDeviceNotify ), __builtin_object_size ((char *) ed, 0)); | |||
276 | } | |||
277 | else if ((ed->reason & XkbXI_IndicatorsMask(0x001c)) && | |||
278 | ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) { | |||
279 | XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause); | |||
280 | } | |||
281 | ||||
282 | if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault(1L<<0))) { | |||
283 | if (changes == NULL((void*)0)) { | |||
284 | changes = &my_changes; | |||
285 | memset((char *) changes, 0, sizeof(XkbChangesRec))__builtin___memset_chk ((char *) changes, 0, sizeof(XkbChangesRec ), __builtin_object_size ((char *) changes, 0)); | |||
286 | } | |||
287 | changes->indicators.state_changes |= affected; | |||
288 | } | |||
289 | ||||
290 | ed->reason |= XkbXI_IndicatorStateMask(1L << 4); | |||
291 | ed->ledClass = sli->class; | |||
292 | ed->ledID = sli->id; | |||
293 | ed->ledsDefined = sli->namesPresent | sli->mapsPresent; | |||
294 | ed->ledState = sli->effectiveState; | |||
295 | ed->unsupported = 0; | |||
296 | ed->supported = XkbXI_AllFeaturesMask(0x001f); | |||
297 | ||||
298 | if (changes != &my_changes) | |||
299 | changes = NULL((void*)0); | |||
300 | if (ed != &my_ed) | |||
301 | ed = NULL((void*)0); | |||
302 | if (changes || ed) | |||
303 | XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause); | |||
304 | return; | |||
305 | } | |||
306 | ||||
307 | static void | |||
308 | XkbUpdateAllDeviceIndicators(XkbChangesPtr changes, XkbEventCausePtr cause) | |||
309 | { | |||
310 | DeviceIntPtr edev; | |||
311 | XkbSrvLedInfoPtr sli; | |||
312 | ||||
313 | for (edev = inputInfo.devices; edev != NULL((void*)0); edev = edev->next) { | |||
314 | if (edev->kbdfeed) { | |||
315 | KbdFeedbackPtr kf; | |||
316 | ||||
317 | for (kf = edev->kbdfeed; kf != NULL((void*)0); kf = kf->next) { | |||
318 | if ((kf->xkb_sli == NULL((void*)0)) || (kf->xkb_sli->maps == NULL((void*)0))) | |||
319 | continue; | |||
320 | sli = kf->xkb_sli; | |||
321 | XkbUpdateLedAutoState(edev, sli, sli->mapsPresent, NULL((void*)0), | |||
322 | changes, cause); | |||
323 | ||||
324 | } | |||
325 | } | |||
326 | if (edev->leds) { | |||
327 | LedFeedbackPtr lf; | |||
328 | ||||
329 | for (lf = edev->leds; lf != NULL((void*)0); lf = lf->next) { | |||
330 | if ((lf->xkb_sli == NULL((void*)0)) || (lf->xkb_sli->maps == NULL((void*)0))) | |||
331 | continue; | |||
332 | sli = lf->xkb_sli; | |||
333 | XkbUpdateLedAutoState(edev, sli, sli->mapsPresent, NULL((void*)0), | |||
334 | changes, cause); | |||
335 | ||||
336 | } | |||
337 | } | |||
338 | } | |||
339 | return; | |||
340 | } | |||
341 | ||||
342 | /***====================================================================***/ | |||
343 | ||||
344 | /* | |||
345 | * void | |||
346 | * XkbSetIndicators(dev,affect,values,cause) | |||
347 | * | |||
348 | * Attempts to change the indicators specified in 'affect' to the | |||
349 | * states specified in 'values' for the default keyboard feedback | |||
350 | * on the keyboard specified by 'dev.' Attempts to change indicator | |||
351 | * state might be ignored or have no affect, depending on the XKB | |||
352 | * indicator map for any affected indicators, as described in section | |||
353 | * 9.2 of the XKB protocol specification. | |||
354 | * | |||
355 | * If 'changes' is non-NULL, this function notes any changes to the | |||
356 | * keyboard state, controls, or indicator state that result from this | |||
357 | * attempted change. If 'changes' is NULL, this function generates | |||
358 | * XKB events to report any such changes to interested clients. | |||
359 | * | |||
360 | * If 'cause' is non-NULL, it specifies the reason for the change, | |||
361 | * as reported in some XKB events. If it is NULL, this function | |||
362 | * assumes that the change is the result of a core protocol | |||
363 | * ChangeKeyboardMapping request. | |||
364 | */ | |||
365 | ||||
366 | void | |||
367 | XkbSetIndicators(DeviceIntPtr dev, | |||
368 | CARD32 affect, CARD32 values, XkbEventCausePtr cause) | |||
369 | { | |||
370 | XkbSrvLedInfoPtr sli; | |||
371 | XkbChangesRec changes; | |||
372 | xkbExtensionDeviceNotify ed; | |||
373 | unsigned side_affected; | |||
374 | ||||
375 | memset((char *) &changes, 0, sizeof(XkbChangesRec))__builtin___memset_chk ((char *) &changes, 0, sizeof(XkbChangesRec ), __builtin_object_size ((char *) &changes, 0)); | |||
376 | memset((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify))__builtin___memset_chk ((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify ), __builtin_object_size ((char *) &ed, 0)); | |||
377 | sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass0x0300, XkbDfltXIId0x0400, 0); | |||
378 | sli->explicitState &= ~affect; | |||
379 | sli->explicitState |= (affect & values); | |||
380 | XkbApplyLedStateChanges(dev, sli, affect, &ed, &changes, cause); | |||
381 | ||||
382 | side_affected = 0; | |||
383 | if (changes.state_changes != 0) | |||
| ||||
384 | side_affected |= | |||
385 | XkbIndicatorsToUpdate(dev, changes.state_changes, FALSE0); | |||
386 | if (changes.ctrls.enabled_ctrls_changes) | |||
387 | side_affected |= sli->usesControls; | |||
388 | ||||
389 | if (side_affected) { | |||
390 | XkbUpdateLedAutoState(dev, sli, side_affected, &ed, &changes, cause); | |||
391 | affect |= side_affected; | |||
392 | } | |||
393 | if (changes.state_changes || changes.ctrls.enabled_ctrls_changes) | |||
394 | XkbUpdateAllDeviceIndicators(NULL((void*)0), cause); | |||
395 | ||||
396 | XkbFlushLedEvents(dev, dev, sli, &ed, &changes, cause); | |||
397 | return; | |||
398 | } | |||
399 | ||||
400 | /***====================================================================***/ | |||
401 | ||||
402 | /***====================================================================***/ | |||
403 | ||||
404 | /* | |||
405 | * void | |||
406 | * XkbUpdateIndicators(dev,update,check_edevs,changes,cause) | |||
407 | * | |||
408 | * Applies the indicator maps for any indicators specified in | |||
409 | * 'update' from the default keyboard feedback on the device | |||
410 | * specified by 'dev.' | |||
411 | * | |||
412 | * If 'changes' is NULL, this function generates and XKB events | |||
413 | * required to report the necessary changes, otherwise it simply | |||
414 | * notes the indicators with changed state. | |||
415 | * | |||
416 | * If 'check_edevs' is TRUE, this function also checks the indicator | |||
417 | * maps for any open extension devices that have them, and updates | |||
418 | * the state of any extension device indicators as necessary. | |||
419 | */ | |||
420 | ||||
421 | void | |||
422 | XkbUpdateIndicators(DeviceIntPtr dev, | |||
423 | register CARD32 update, | |||
424 | Bool check_edevs, | |||
425 | XkbChangesPtr changes, XkbEventCausePtr cause) | |||
426 | { | |||
427 | XkbSrvLedInfoPtr sli; | |||
428 | ||||
429 | sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass0x0300, XkbDfltXIId0x0400, 0); | |||
430 | XkbUpdateLedAutoState(dev, sli, update, NULL((void*)0), changes, cause); | |||
431 | if (check_edevs) | |||
432 | XkbUpdateAllDeviceIndicators(changes, cause); | |||
433 | return; | |||
434 | } | |||
435 | ||||
436 | /***====================================================================***/ | |||
437 | ||||
438 | /***====================================================================***/ | |||
439 | ||||
440 | /* | |||
441 | * void | |||
442 | * XkbCheckIndicatorMaps(dev,sli,which) | |||
443 | * | |||
444 | * Updates the 'indicator accelerators' for the indicators specified | |||
445 | * by 'which' in the feedback specified by 'sli.' The indicator | |||
446 | * accelerators are internal to the server and are used to simplify | |||
447 | * and speed up the process of figuring out which indicators might | |||
448 | * be affected by a particular change in keyboard state or controls. | |||
449 | */ | |||
450 | ||||
451 | void | |||
452 | XkbCheckIndicatorMaps(DeviceIntPtr dev, XkbSrvLedInfoPtr sli, unsigned which) | |||
453 | { | |||
454 | register unsigned i, bit; | |||
455 | XkbIndicatorMapPtr map; | |||
456 | XkbDescPtr xkb; | |||
457 | ||||
458 | if ((sli->flags & XkbSLI_HasOwnState(1L<<1)) == 0) | |||
459 | return; | |||
460 | ||||
461 | sli->usesBase &= ~which; | |||
462 | sli->usesLatched &= ~which; | |||
463 | sli->usesLocked &= ~which; | |||
464 | sli->usesEffective &= ~which; | |||
465 | sli->usesCompat &= ~which; | |||
466 | sli->usesControls &= ~which; | |||
467 | sli->mapsPresent &= ~which; | |||
468 | ||||
469 | xkb = dev->key->xkbInfo->desc; | |||
470 | for (i = 0, bit = 1, map = sli->maps; i < XkbNumIndicators32; | |||
471 | i++, bit <<= 1, map++) { | |||
472 | if (which & bit) { | |||
473 | CARD8 what; | |||
474 | ||||
475 | if (!map || !XkbIM_InUse(map)((map)->flags || (map)->which_groups || (map)->which_mods || (map)->ctrls)) | |||
476 | continue; | |||
477 | sli->mapsPresent |= bit; | |||
478 | ||||
479 | what = (map->which_mods | map->which_groups); | |||
480 | if (what & XkbIM_UseBase(1L << 0)) | |||
481 | sli->usesBase |= bit; | |||
482 | if (what & XkbIM_UseLatched(1L << 1)) | |||
483 | sli->usesLatched |= bit; | |||
484 | if (what & XkbIM_UseLocked(1L << 2)) | |||
485 | sli->usesLocked |= bit; | |||
486 | if (what & XkbIM_UseEffective(1L << 3)) | |||
487 | sli->usesEffective |= bit; | |||
488 | if (what & XkbIM_UseCompat(1L << 4)) | |||
489 | sli->usesCompat |= bit; | |||
490 | if (map->ctrls) | |||
491 | sli->usesControls |= bit; | |||
492 | ||||
493 | map->mods.mask = map->mods.real_mods; | |||
494 | if (map->mods.vmods != 0) { | |||
495 | map->mods.mask |= XkbMaskForVMask(xkb, map->mods.vmods); | |||
496 | } | |||
497 | } | |||
498 | } | |||
499 | sli->usedComponents = 0; | |||
500 | if (sli->usesBase) | |||
501 | sli->usedComponents |= XkbModifierBaseMask(1L << 1) | XkbGroupBaseMask(1L << 5); | |||
502 | if (sli->usesLatched) | |||
503 | sli->usedComponents |= XkbModifierLatchMask(1L << 2) | XkbGroupLatchMask(1L << 6); | |||
504 | if (sli->usesLocked) | |||
505 | sli->usedComponents |= XkbModifierLockMask(1L << 3) | XkbGroupLockMask(1L << 7); | |||
506 | if (sli->usesEffective) | |||
507 | sli->usedComponents |= XkbModifierStateMask(1L << 0) | XkbGroupStateMask(1L << 4); | |||
508 | if (sli->usesCompat) | |||
509 | sli->usedComponents |= XkbCompatStateMask(1L << 8); | |||
510 | return; | |||
511 | } | |||
512 | ||||
513 | /***====================================================================***/ | |||
514 | ||||
515 | /* | |||
516 | * XkbSrvLedInfoPtr | |||
517 | * XkbAllocSrvLedInfo(dev,kf,lf,needed_parts) | |||
518 | * | |||
519 | * Allocates an XkbSrvLedInfoPtr for the feedback specified by either | |||
520 | * 'kf' or 'lf' on the keyboard specified by 'dev.' | |||
521 | * | |||
522 | * If 'needed_parts' is non-zero, this function makes sure that any | |||
523 | * of the parts speicified therein are allocated. | |||
524 | */ | |||
525 | XkbSrvLedInfoPtr | |||
526 | XkbAllocSrvLedInfo(DeviceIntPtr dev, | |||
527 | KbdFeedbackPtr kf, LedFeedbackPtr lf, unsigned needed_parts) | |||
528 | { | |||
529 | XkbSrvLedInfoPtr sli; | |||
530 | Bool checkAccel; | |||
531 | Bool checkNames; | |||
532 | ||||
533 | sli = NULL((void*)0); | |||
534 | checkAccel = checkNames = FALSE0; | |||
535 | if ((kf != NULL((void*)0)) && (kf->xkb_sli == NULL((void*)0))) { | |||
536 | kf->xkb_sli = sli = calloc(1, sizeof(XkbSrvLedInfoRec)); | |||
537 | if (sli == NULL((void*)0)) | |||
538 | return NULL((void*)0); /* ALLOCATION ERROR */ | |||
539 | if (dev->key && dev->key->xkbInfo) | |||
540 | sli->flags = XkbSLI_HasOwnState(1L<<1); | |||
541 | else | |||
542 | sli->flags = 0; | |||
543 | sli->class = KbdFeedbackClass0; | |||
544 | sli->id = kf->ctrl.id; | |||
545 | sli->fb.kf = kf; | |||
546 | ||||
547 | sli->autoState = 0; | |||
548 | sli->explicitState = kf->ctrl.leds; | |||
549 | sli->effectiveState = kf->ctrl.leds; | |||
550 | ||||
551 | if ((kf == dev->kbdfeed) && (dev->key) && (dev->key->xkbInfo)) { | |||
552 | XkbDescPtr xkb; | |||
553 | ||||
554 | xkb = dev->key->xkbInfo->desc; | |||
555 | sli->flags |= XkbSLI_IsDefault(1L<<0); | |||
556 | sli->physIndicators = xkb->indicators->phys_indicators; | |||
557 | sli->names = xkb->names->indicators; | |||
558 | sli->maps = xkb->indicators->maps; | |||
559 | checkNames = checkAccel = TRUE1; | |||
560 | } | |||
561 | else { | |||
562 | sli->physIndicators = XkbAllIndicatorsMask(0xffffffff); | |||
563 | sli->names = NULL((void*)0); | |||
564 | sli->maps = NULL((void*)0); | |||
565 | } | |||
566 | } | |||
567 | else if ((kf != NULL((void*)0)) && ((kf->xkb_sli->flags & XkbSLI_IsDefault(1L<<0)) != 0)) { | |||
568 | XkbDescPtr xkb; | |||
569 | ||||
570 | xkb = dev->key->xkbInfo->desc; | |||
571 | sli = kf->xkb_sli; | |||
572 | sli->physIndicators = xkb->indicators->phys_indicators; | |||
573 | if (xkb->names->indicators != sli->names) { | |||
574 | checkNames = TRUE1; | |||
575 | sli->names = xkb->names->indicators; | |||
576 | } | |||
577 | if (xkb->indicators->maps != sli->maps) { | |||
578 | checkAccel = TRUE1; | |||
579 | sli->maps = xkb->indicators->maps; | |||
580 | } | |||
581 | } | |||
582 | else if ((lf != NULL((void*)0)) && (lf->xkb_sli == NULL((void*)0))) { | |||
583 | lf->xkb_sli = sli = calloc(1, sizeof(XkbSrvLedInfoRec)); | |||
584 | if (sli == NULL((void*)0)) | |||
585 | return NULL((void*)0); /* ALLOCATION ERROR */ | |||
586 | if (dev->key && dev->key->xkbInfo) | |||
587 | sli->flags = XkbSLI_HasOwnState(1L<<1); | |||
588 | else | |||
589 | sli->flags = 0; | |||
590 | sli->class = LedFeedbackClass4; | |||
591 | sli->id = lf->ctrl.id; | |||
592 | sli->fb.lf = lf; | |||
593 | ||||
594 | sli->physIndicators = lf->ctrl.led_mask; | |||
595 | sli->autoState = 0; | |||
596 | sli->explicitState = lf->ctrl.led_values; | |||
597 | sli->effectiveState = lf->ctrl.led_values; | |||
598 | sli->maps = NULL((void*)0); | |||
599 | sli->names = NULL((void*)0); | |||
600 | } | |||
601 | else | |||
602 | return NULL((void*)0); | |||
603 | if ((sli->names == NULL((void*)0)) && (needed_parts & XkbXI_IndicatorNamesMask(1L << 2))) | |||
604 | sli->names = calloc(XkbNumIndicators32, sizeof(Atom)); | |||
605 | if ((sli->maps == NULL((void*)0)) && (needed_parts & XkbXI_IndicatorMapsMask(1L << 3))) | |||
606 | sli->maps = calloc(XkbNumIndicators32, sizeof(XkbIndicatorMapRec)); | |||
607 | if (checkNames) { | |||
608 | register unsigned i, bit; | |||
609 | ||||
610 | sli->namesPresent = 0; | |||
611 | for (i = 0, bit = 1; i < XkbNumIndicators32; i++, bit <<= 1) { | |||
612 | if (sli->names[i] != None0L) | |||
| ||||
613 | sli->namesPresent |= bit; | |||
614 | } | |||
615 | } | |||
616 | if (checkAccel) | |||
617 | XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask(0xffffffff)); | |||
618 | return sli; | |||
619 | } | |||
620 | ||||
621 | void | |||
622 | XkbFreeSrvLedInfo(XkbSrvLedInfoPtr sli) | |||
623 | { | |||
624 | if ((sli->flags & XkbSLI_IsDefault(1L<<0)) == 0) { | |||
625 | free(sli->maps); | |||
626 | free(sli->names); | |||
627 | } | |||
628 | sli->maps = NULL((void*)0); | |||
629 | sli->names = NULL((void*)0); | |||
630 | free(sli); | |||
631 | return; | |||
632 | } | |||
633 | ||||
634 | /* | |||
635 | * XkbSrvLedInfoPtr | |||
636 | * XkbCopySrvLedInfo(dev,src,kf,lf) | |||
637 | * | |||
638 | * Takes the given XkbSrvLedInfoPtr and duplicates it. A deep copy is made, | |||
639 | * thus the new copy behaves like the original one and can be freed with | |||
640 | * XkbFreeSrvLedInfo. | |||
641 | */ | |||
642 | XkbSrvLedInfoPtr | |||
643 | XkbCopySrvLedInfo(DeviceIntPtr from, | |||
644 | XkbSrvLedInfoPtr src, KbdFeedbackPtr kf, LedFeedbackPtr lf) | |||
645 | { | |||
646 | XkbSrvLedInfoPtr sli_new = NULL((void*)0); | |||
647 | ||||
648 | if (!src) | |||
649 | goto finish; | |||
650 | ||||
651 | sli_new = calloc(1, sizeof(XkbSrvLedInfoRec)); | |||
652 | if (!sli_new) | |||
653 | goto finish; | |||
654 | ||||
655 | memcpy(sli_new, src, sizeof(XkbSrvLedInfoRec))__builtin___memcpy_chk (sli_new, src, sizeof(XkbSrvLedInfoRec ), __builtin_object_size (sli_new, 0)); | |||
656 | if (sli_new->class == KbdFeedbackClass0) | |||
657 | sli_new->fb.kf = kf; | |||
658 | else | |||
659 | sli_new->fb.lf = lf; | |||
660 | ||||
661 | if (!(sli_new->flags & XkbSLI_IsDefault(1L<<0))) { | |||
662 | sli_new->names = calloc(XkbNumIndicators32, sizeof(Atom)); | |||
663 | sli_new->maps = calloc(XkbNumIndicators32, sizeof(XkbIndicatorMapRec)); | |||
664 | } /* else sli_new->names/maps is pointing to | |||
665 | dev->key->xkbInfo->desc->names->indicators; | |||
666 | dev->key->xkbInfo->desc->names->indicators; */ | |||
667 | ||||
668 | finish: | |||
669 | return sli_new; | |||
670 | } | |||
671 | ||||
672 | /***====================================================================***/ | |||
673 | ||||
674 | /* | |||
675 | * XkbSrvLedInfoPtr | |||
676 | * XkbFindSrvLedInfo(dev,class,id,needed_parts) | |||
677 | * | |||
678 | * Finds the XkbSrvLedInfoPtr for the specified 'class' and 'id' | |||
679 | * on the device specified by 'dev.' If the class and id specify | |||
680 | * a valid device feedback, this function returns the existing | |||
681 | * feedback or allocates a new one. | |||
682 | * | |||
683 | */ | |||
684 | ||||
685 | XkbSrvLedInfoPtr | |||
686 | XkbFindSrvLedInfo(DeviceIntPtr dev, | |||
687 | unsigned class, unsigned id, unsigned needed_parts) | |||
688 | { | |||
689 | XkbSrvLedInfoPtr sli; | |||
690 | ||||
691 | /* optimization to check for most common case */ | |||
692 | if (((class == XkbDfltXIClass0x0300) && (id == XkbDfltXIId0x0400)) && (dev->kbdfeed)) { | |||
693 | if (dev->kbdfeed->xkb_sli == NULL((void*)0)) { | |||
694 | dev->kbdfeed->xkb_sli = | |||
695 | XkbAllocSrvLedInfo(dev, dev->kbdfeed, NULL((void*)0), needed_parts); | |||
696 | } | |||
697 | return dev->kbdfeed->xkb_sli; | |||
698 | } | |||
699 | ||||
700 | sli = NULL((void*)0); | |||
701 | if (class == XkbDfltXIClass0x0300) { | |||
702 | if (dev->kbdfeed) | |||
703 | class = KbdFeedbackClass0; | |||
704 | else if (dev->leds) | |||
705 | class = LedFeedbackClass4; | |||
706 | else | |||
707 | return NULL((void*)0); | |||
708 | } | |||
709 | if (class == KbdFeedbackClass0) { | |||
710 | KbdFeedbackPtr kf; | |||
711 | ||||
712 | for (kf = dev->kbdfeed; kf != NULL((void*)0); kf = kf->next) { | |||
713 | if ((id == XkbDfltXIId0x0400) || (id == kf->ctrl.id)) { | |||
714 | if (kf->xkb_sli == NULL((void*)0)) | |||
715 | kf->xkb_sli = | |||
716 | XkbAllocSrvLedInfo(dev, kf, NULL((void*)0), needed_parts); | |||
717 | sli = kf->xkb_sli; | |||
718 | break; | |||
719 | } | |||
720 | } | |||
721 | } | |||
722 | else if (class == LedFeedbackClass4) { | |||
723 | LedFeedbackPtr lf; | |||
724 | ||||
725 | for (lf = dev->leds; lf != NULL((void*)0); lf = lf->next) { | |||
726 | if ((id == XkbDfltXIId0x0400) || (id == lf->ctrl.id)) { | |||
727 | if (lf->xkb_sli == NULL((void*)0)) | |||
728 | lf->xkb_sli = | |||
729 | XkbAllocSrvLedInfo(dev, NULL((void*)0), lf, needed_parts); | |||
730 | sli = lf->xkb_sli; | |||
731 | break; | |||
732 | } | |||
733 | } | |||
734 | } | |||
735 | if (sli) { | |||
736 | if ((sli->names == NULL((void*)0)) && (needed_parts & XkbXI_IndicatorNamesMask(1L << 2))) | |||
737 | sli->names = calloc(XkbNumIndicators32, sizeof(Atom)); | |||
738 | if ((sli->maps == NULL((void*)0)) && (needed_parts & XkbXI_IndicatorMapsMask(1L << 3))) | |||
739 | sli->maps = calloc(XkbNumIndicators32, sizeof(XkbIndicatorMapRec)); | |||
740 | } | |||
741 | return sli; | |||
742 | } | |||
743 | ||||
744 | /***====================================================================***/ | |||
745 | ||||
746 | void | |||
747 | XkbFlushLedEvents(DeviceIntPtr dev, | |||
748 | DeviceIntPtr kbd, | |||
749 | XkbSrvLedInfoPtr sli, | |||
750 | xkbExtensionDeviceNotify * ed, | |||
751 | XkbChangesPtr changes, XkbEventCausePtr cause) | |||
752 | { | |||
753 | if (changes) { | |||
754 | if (changes->indicators.state_changes) | |||
755 | XkbDDXUpdateDeviceIndicators(dev, sli, sli->effectiveState); | |||
756 | XkbSendNotification(kbd, changes, cause); | |||
757 | memset((char *) changes, 0, sizeof(XkbChangesRec))__builtin___memset_chk ((char *) changes, 0, sizeof(XkbChangesRec ), __builtin_object_size ((char *) changes, 0)); | |||
758 | ||||
759 | if (XkbAX_NeedFeedback((((kbd->key->xkbInfo->desc->ctrls))->enabled_ctrls &(1L << 8)) && (((kbd->key->xkbInfo-> desc->ctrls))->ax_options&(((1L << 4))))) | |||
760 | (kbd->key->xkbInfo->desc->ctrls, XkbAX_IndicatorFBMask)((((kbd->key->xkbInfo->desc->ctrls))->enabled_ctrls &(1L << 8)) && (((kbd->key->xkbInfo-> desc->ctrls))->ax_options&(((1L << 4)))))) { | |||
761 | if (sli->effectiveState) | |||
762 | /* it appears that the which parameter is not used */ | |||
763 | XkbDDXAccessXBeep(dev, _BEEP_LED_ON12, XkbAccessXFeedbackMask(1L << 8)); | |||
764 | else | |||
765 | XkbDDXAccessXBeep(dev, _BEEP_LED_OFF13, XkbAccessXFeedbackMask(1L << 8)); | |||
766 | } | |||
767 | } | |||
768 | if (ed) { | |||
769 | if (ed->reason) { | |||
770 | if ((dev != kbd) && (ed->reason & XkbXI_IndicatorStateMask(1L << 4))) | |||
771 | XkbDDXUpdateDeviceIndicators(dev, sli, sli->effectiveState); | |||
772 | XkbSendExtensionDeviceNotify(dev, cause->client, ed); | |||
773 | } | |||
774 | memset((char *) ed, 0, sizeof(XkbExtensionDeviceNotify))__builtin___memset_chk ((char *) ed, 0, sizeof(11), __builtin_object_size ((char *) ed, 0)); | |||
775 | } | |||
776 | return; | |||
777 | } | |||
778 | ||||
779 | /***====================================================================***/ | |||
780 | ||||
781 | void | |||
782 | XkbApplyLedNameChanges(DeviceIntPtr dev, | |||
783 | XkbSrvLedInfoPtr sli, | |||
784 | unsigned changed_names, | |||
785 | xkbExtensionDeviceNotify * ed, | |||
786 | XkbChangesPtr changes, XkbEventCausePtr cause) | |||
787 | { | |||
788 | DeviceIntPtr kbd; | |||
789 | XkbChangesRec my_changes; | |||
790 | xkbExtensionDeviceNotify my_ed; | |||
791 | ||||
792 | if (changed_names == 0) | |||
793 | return; | |||
794 | if (dev->key && dev->key->xkbInfo) | |||
795 | kbd = dev; | |||
796 | else | |||
797 | kbd = inputInfo.keyboard; | |||
798 | ||||
799 | if (ed == NULL((void*)0)) { | |||
800 | ed = &my_ed; | |||
801 | memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify))__builtin___memset_chk ((char *) ed, 0, sizeof(xkbExtensionDeviceNotify ), __builtin_object_size ((char *) ed, 0)); | |||
802 | } | |||
803 | else if ((ed->reason & XkbXI_IndicatorsMask(0x001c)) && | |||
804 | ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) { | |||
805 | XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause); | |||
806 | } | |||
807 | ||||
808 | if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault(1L<<0))) { | |||
809 | if (changes == NULL((void*)0)) { | |||
810 | changes = &my_changes; | |||
811 | memset((char *) changes, 0, sizeof(XkbChangesRec))__builtin___memset_chk ((char *) changes, 0, sizeof(XkbChangesRec ), __builtin_object_size ((char *) changes, 0)); | |||
812 | } | |||
813 | changes->names.changed |= XkbIndicatorNamesMask(1<<8); | |||
814 | changes->names.changed_indicators |= changed_names; | |||
815 | } | |||
816 | ||||
817 | ed->reason |= XkbXI_IndicatorNamesMask(1L << 2); | |||
818 | ed->ledClass = sli->class; | |||
819 | ed->ledID = sli->id; | |||
820 | ed->ledsDefined = sli->namesPresent | sli->mapsPresent; | |||
821 | ed->ledState = sli->effectiveState; | |||
822 | ed->unsupported = 0; | |||
823 | ed->supported = XkbXI_AllFeaturesMask(0x001f); | |||
824 | ||||
825 | if (changes != &my_changes) | |||
826 | changes = NULL((void*)0); | |||
827 | if (ed != &my_ed) | |||
828 | ed = NULL((void*)0); | |||
829 | if (changes || ed) | |||
830 | XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause); | |||
831 | return; | |||
832 | } | |||
833 | ||||
834 | /***====================================================================***/ | |||
835 | ||||
836 | /* | |||
837 | * void | |||
838 | * XkbApplyLedMapChanges(dev,sli,changed_maps,changes,cause) | |||
839 | * | |||
840 | * Handles all of the secondary effects of the changes to the | |||
841 | * feedback specified by 'sli' on the device specified by 'dev.' | |||
842 | * | |||
843 | * If 'changed_maps' specifies any indicators, this function generates | |||
844 | * XkbExtensionDeviceNotify events and possibly IndicatorMapNotify | |||
845 | * events to report the changes, and recalculates the effective | |||
846 | * state of each indicator with a changed map. If any indicators | |||
847 | * change state, the server generates XkbExtensionDeviceNotify and | |||
848 | * XkbIndicatorStateNotify events as appropriate. | |||
849 | * | |||
850 | * If 'changes' is non-NULL, this function updates it to reflect | |||
851 | * any changes to the keyboard state or controls or to the 'core' | |||
852 | * indicator names, maps, or state. If 'changes' is NULL, this | |||
853 | * function generates XKB events as needed to report the changes. | |||
854 | * If 'dev' is not a keyboard device, any changes are reported | |||
855 | * for the core keyboard. | |||
856 | * | |||
857 | * The 'cause' specifies the reason for the event (key event or | |||
858 | * request) for the change, as reported in some XKB events. | |||
859 | */ | |||
860 | ||||
861 | void | |||
862 | XkbApplyLedMapChanges(DeviceIntPtr dev, | |||
863 | XkbSrvLedInfoPtr sli, | |||
864 | unsigned changed_maps, | |||
865 | xkbExtensionDeviceNotify * ed, | |||
866 | XkbChangesPtr changes, XkbEventCausePtr cause) | |||
867 | { | |||
868 | DeviceIntPtr kbd; | |||
869 | XkbChangesRec my_changes; | |||
870 | xkbExtensionDeviceNotify my_ed; | |||
871 | ||||
872 | if (changed_maps == 0) | |||
873 | return; | |||
874 | if (dev->key && dev->key->xkbInfo) | |||
875 | kbd = dev; | |||
876 | else | |||
877 | kbd = inputInfo.keyboard; | |||
878 | ||||
879 | if (ed == NULL((void*)0)) { | |||
880 | ed = &my_ed; | |||
881 | memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify))__builtin___memset_chk ((char *) ed, 0, sizeof(xkbExtensionDeviceNotify ), __builtin_object_size ((char *) ed, 0)); | |||
882 | } | |||
883 | else if ((ed->reason & XkbXI_IndicatorsMask(0x001c)) && | |||
884 | ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) { | |||
885 | XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause); | |||
886 | } | |||
887 | ||||
888 | if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault(1L<<0))) { | |||
889 | if (changes == NULL((void*)0)) { | |||
890 | changes = &my_changes; | |||
891 | memset((char *) changes, 0, sizeof(XkbChangesRec))__builtin___memset_chk ((char *) changes, 0, sizeof(XkbChangesRec ), __builtin_object_size ((char *) changes, 0)); | |||
892 | } | |||
893 | changes->indicators.map_changes |= changed_maps; | |||
894 | } | |||
895 | ||||
896 | XkbCheckIndicatorMaps(dev, sli, changed_maps); | |||
897 | ||||
898 | ed->reason |= XkbXI_IndicatorMapsMask(1L << 3); | |||
899 | ed->ledClass = sli->class; | |||
900 | ed->ledID = sli->id; | |||
901 | ed->ledsDefined = sli->namesPresent | sli->mapsPresent; | |||
902 | ed->ledState = sli->effectiveState; | |||
903 | ed->unsupported = 0; | |||
904 | ed->supported = XkbXI_AllFeaturesMask(0x001f); | |||
905 | ||||
906 | XkbUpdateLedAutoState(dev, sli, changed_maps, ed, changes, cause); | |||
907 | ||||
908 | if (changes != &my_changes) | |||
909 | changes = NULL((void*)0); | |||
910 | if (ed != &my_ed) | |||
911 | ed = NULL((void*)0); | |||
912 | if (changes || ed) | |||
913 | XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause); | |||
914 | return; | |||
915 | } | |||
916 | ||||
917 | /***====================================================================***/ | |||
918 | ||||
919 | void | |||
920 | XkbApplyLedStateChanges(DeviceIntPtr dev, | |||
921 | XkbSrvLedInfoPtr sli, | |||
922 | unsigned changed_leds, | |||
923 | xkbExtensionDeviceNotify * ed, | |||
924 | XkbChangesPtr changes, XkbEventCausePtr cause) | |||
925 | { | |||
926 | XkbSrvInfoPtr xkbi; | |||
927 | DeviceIntPtr kbd; | |||
928 | XkbChangesRec my_changes; | |||
929 | xkbExtensionDeviceNotify my_ed; | |||
930 | register unsigned i, bit, affected; | |||
931 | XkbIndicatorMapPtr map; | |||
932 | unsigned oldState; | |||
933 | Bool kb_changed; | |||
934 | ||||
935 | if (changed_leds == 0) | |||
936 | return; | |||
937 | if (dev->key && dev->key->xkbInfo) | |||
938 | kbd = dev; | |||
939 | else | |||
940 | kbd = inputInfo.keyboard; | |||
941 | xkbi = kbd->key->xkbInfo; | |||
942 | ||||
943 | if (changes == NULL((void*)0)) { | |||
944 | changes = &my_changes; | |||
945 | memset((char *) changes, 0, sizeof(XkbChangesRec))__builtin___memset_chk ((char *) changes, 0, sizeof(XkbChangesRec ), __builtin_object_size ((char *) changes, 0)); | |||
946 | } | |||
947 | ||||
948 | kb_changed = FALSE0; | |||
949 | affected = changed_leds; | |||
950 | oldState = sli->effectiveState; | |||
951 | for (i = 0, bit = 1; (i < XkbNumIndicators32) && (affected); i++, bit <<= 1) { | |||
952 | if ((affected & bit) == 0) | |||
953 | continue; | |||
954 | affected &= ~bit; | |||
955 | map = &sli->maps[i]; | |||
956 | if (map->flags & XkbIM_NoExplicit(1L << 7)) { | |||
957 | sli->explicitState &= ~bit; | |||
958 | continue; | |||
959 | } | |||
960 | if (map->flags & XkbIM_LEDDrivesKB(1L << 5)) { | |||
961 | Bool on = ((sli->explicitState & bit) != 0); | |||
962 | ||||
963 | if (XkbApplyLEDChangeToKeyboard(xkbi, map, on, changes)) | |||
964 | kb_changed = TRUE1; | |||
965 | } | |||
966 | } | |||
967 | sli->effectiveState = (sli->autoState | sli->explicitState); | |||
968 | affected = sli->effectiveState ^ oldState; | |||
969 | ||||
970 | if (ed == NULL((void*)0)) { | |||
971 | ed = &my_ed; | |||
972 | memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify))__builtin___memset_chk ((char *) ed, 0, sizeof(xkbExtensionDeviceNotify ), __builtin_object_size ((char *) ed, 0)); | |||
973 | } | |||
974 | else if (affected && (ed->reason & XkbXI_IndicatorsMask(0x001c)) && | |||
975 | ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) { | |||
976 | XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause); | |||
977 | } | |||
978 | ||||
979 | if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault(1L<<0))) | |||
980 | changes->indicators.state_changes |= affected; | |||
981 | if (affected) { | |||
982 | ed->reason |= XkbXI_IndicatorStateMask(1L << 4); | |||
983 | ed->ledClass = sli->class; | |||
984 | ed->ledID = sli->id; | |||
985 | ed->ledsDefined = sli->namesPresent | sli->mapsPresent; | |||
986 | ed->ledState = sli->effectiveState; | |||
987 | ed->unsupported = 0; | |||
988 | ed->supported = XkbXI_AllFeaturesMask(0x001f); | |||
989 | } | |||
990 | ||||
991 | if (kb_changed) { | |||
992 | XkbComputeDerivedState(kbd->key->xkbInfo); | |||
993 | XkbUpdateLedAutoState(dev, sli, sli->mapsPresent, ed, changes, cause); | |||
994 | } | |||
995 | ||||
996 | if (changes != &my_changes) | |||
997 | changes = NULL((void*)0); | |||
998 | if (ed != &my_ed) | |||
999 | ed = NULL((void*)0); | |||
1000 | if (changes || ed) | |||
1001 | XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause); | |||
1002 | if (kb_changed) | |||
1003 | XkbUpdateAllDeviceIndicators(NULL((void*)0), cause); | |||
1004 | return; | |||
1005 | } |