File: | xkb/xkbLEDs.c |
Location: | line 391, column 9 |
Description: | Value stored to 'affect' is never read |
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 | 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; |
Value stored to 'affect' is never read | |
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 | } |