Debian Codegraph @

nx-X11/lib/src/xkb/XKBleds.c

raw
1 /************************************************************
2 Copyright (c) 1993 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 #define NEED_MAP_READERS
28 #ifdef HAVE_CONFIG_H
29 #include <config.h>
30 #endif
31 #include "Xlibint.h"
32 #include <nx-X11/extensions/XKBproto.h>
33 #include "XKBlibint.h"
34
35 Status
36 XkbGetIndicatorState(Display *dpy, unsigned deviceSpec, unsigned *pStateRtrn)
37 {
38 register xkbGetIndicatorStateReq *req;
39 xkbGetIndicatorStateReply rep;
40 XkbInfoPtr xkbi;
41 Bool ok;
42
43 if ((dpy->flags & XlibDisplayNoXkb) ||
44 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL, NULL)))
45 return BadAccess;
46 LockDisplay(dpy);
47 xkbi = dpy->xkb_info;
48 GetReq(kbGetIndicatorState, req);
49 req->reqType = xkbi->codes->major_opcode;
50 req->xkbReqType = X_kbGetIndicatorState;
51 req->deviceSpec = deviceSpec;
52 ok = _XReply(dpy, (xReply *) &rep, 0, xFalse);
53 if (ok && (pStateRtrn != NULL))
54 *pStateRtrn = rep.state;
55 UnlockDisplay(dpy);
56 SyncHandle();
57 return (ok ? Success : BadImplementation);
58 }
59
60 Status
61 _XkbReadGetIndicatorMapReply(Display *dpy,
62 xkbGetIndicatorMapReply *rep,
63 XkbDescPtr xkb,
64 int *nread_rtrn)
65 {
66 XkbIndicatorPtr leds;
67 XkbReadBufferRec buf;
68
69 if ((!xkb->indicators) && (XkbAllocIndicatorMaps(xkb) != Success))
70 return BadAlloc;
71 leds = xkb->indicators;
72
73 leds->phys_indicators = rep->realIndicators;
74 if (rep->length > 0) {
75 register int left;
76
77 if (!_XkbInitReadBuffer(dpy, &buf, (int) rep->length * 4))
78 return BadAlloc;
79 if (nread_rtrn)
80 *nread_rtrn = (int) rep->length * 4;
81 if (rep->which) {
82 register int i, bit;
83
84 left = (int) rep->which;
85 for (i = 0, bit = 1; (i < XkbNumIndicators) && (left);
86 i++, bit <<= 1) {
87 if (left & bit) {
88 xkbIndicatorMapWireDesc *wire;
89
90 wire = (xkbIndicatorMapWireDesc *)
91 _XkbGetReadBufferPtr(&buf,
92 SIZEOF(xkbIndicatorMapWireDesc));
93 if (wire == NULL) {
94 _XkbFreeReadBuffer(&buf);
95 return BadAlloc;
96 }
97 leds->maps[i].flags = wire->flags;
98 leds->maps[i].which_groups = wire->whichGroups;
99 leds->maps[i].groups = wire->groups;
100 leds->maps[i].which_mods = wire->whichMods;
101 leds->maps[i].mods.mask = wire->mods;
102 leds->maps[i].mods.real_mods = wire->realMods;
103 leds->maps[i].mods.vmods = wire->virtualMods;
104 leds->maps[i].ctrls = wire->ctrls;
105 left &= ~bit;
106 }
107 }
108 }
109 left = _XkbFreeReadBuffer(&buf);
110 }
111 return Success;
112 }
113
114 Bool
115 XkbGetIndicatorMap(Display *dpy, unsigned long which, XkbDescPtr xkb)
116 {
117 register xkbGetIndicatorMapReq *req;
118 xkbGetIndicatorMapReply rep;
119 XkbInfoPtr xkbi;
120 Status status;
121
122 if ((dpy->flags & XlibDisplayNoXkb) ||
123 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL, NULL)))
124 return BadAccess;
125 if ((!which) || (!xkb))
126 return BadValue;
127
128 LockDisplay(dpy);
129 xkbi = dpy->xkb_info;
130 if (!xkb->indicators) {
131 xkb->indicators = _XkbTypedCalloc(1, XkbIndicatorRec);
132 if (!xkb->indicators) {
133 UnlockDisplay(dpy);
134 SyncHandle();
135 return BadAlloc;
136 }
137 }
138 GetReq(kbGetIndicatorMap, req);
139 req->reqType = xkbi->codes->major_opcode;
140 req->xkbReqType = X_kbGetIndicatorMap;
141 req->deviceSpec = xkb->device_spec;
142 req->which = (CARD32) which;
143 if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
144 UnlockDisplay(dpy);
145 SyncHandle();
146 return BadValue;
147 }
148 status = _XkbReadGetIndicatorMapReply(dpy, &rep, xkb, NULL);
149 UnlockDisplay(dpy);
150 SyncHandle();
151 return status;
152 }
153
154 Bool
155 XkbSetIndicatorMap(Display *dpy, unsigned long which, XkbDescPtr xkb)
156 {
157 register xkbSetIndicatorMapReq *req;
158 register int i, bit;
159 int nMaps;
160 xkbIndicatorMapWireDesc *wire;
161 XkbInfoPtr xkbi;
162
163 if ((dpy->flags & XlibDisplayNoXkb) ||
164 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL, NULL)))
165 return False;
166 if ((!xkb) || (!which) || (!xkb->indicators))
167 return False;
168 LockDisplay(dpy);
169 xkbi = dpy->xkb_info;
170 GetReq(kbSetIndicatorMap, req);
171 req->reqType = xkbi->codes->major_opcode;
172 req->xkbReqType = X_kbSetIndicatorMap;
173 req->deviceSpec = xkb->device_spec;
174 req->which = (CARD32) which;
175 for (i = nMaps = 0, bit = 1; i < 32; i++, bit <<= 1) {
176 if (which & bit)
177 nMaps++;
178 }
179 req->length += (nMaps * sizeof(XkbIndicatorMapRec)) / 4;
180 BufAlloc(xkbIndicatorMapWireDesc *, wire,
181 (nMaps * SIZEOF(xkbIndicatorMapWireDesc)));
182 for (i = 0, bit = 1; i < 32; i++, bit <<= 1) {
183 if (which & bit) {
184 wire->flags = xkb->indicators->maps[i].flags;
185 wire->whichGroups = xkb->indicators->maps[i].which_groups;
186 wire->groups = xkb->indicators->maps[i].groups;
187 wire->whichMods = xkb->indicators->maps[i].which_mods;
188 wire->mods = xkb->indicators->maps[i].mods.real_mods;
189 wire->virtualMods = xkb->indicators->maps[i].mods.vmods;
190 wire->ctrls = xkb->indicators->maps[i].ctrls;
191 wire++;
192 }
193 }
194 UnlockDisplay(dpy);
195 SyncHandle();
196 return True;
197 }
198
199 Bool
200 XkbGetNamedDeviceIndicator(Display *dpy,
201 unsigned device,
202 unsigned class,
203 unsigned id,
204 Atom name,
205 int *pNdxRtrn,
206 Bool *pStateRtrn,
207 XkbIndicatorMapPtr pMapRtrn,
208 Bool *pRealRtrn)
209 {
210 register xkbGetNamedIndicatorReq *req;
211 xkbGetNamedIndicatorReply rep;
212 XkbInfoPtr xkbi;
213
214 if ((dpy->flags & XlibDisplayNoXkb) || (name == None) ||
215 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL, NULL)))
216 return False;
217 LockDisplay(dpy);
218 xkbi = dpy->xkb_info;
219 GetReq(kbGetNamedIndicator, req);
220 req->reqType = xkbi->codes->major_opcode;
221 req->xkbReqType = X_kbGetNamedIndicator;
222 req->deviceSpec = device;
223 req->ledClass = class;
224 req->ledID = id;
225 req->indicator = (CARD32) name;
226 if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
227 UnlockDisplay(dpy);
228 SyncHandle();
229 return False;
230 }
231 UnlockDisplay(dpy);
232 SyncHandle();
233 if ((!rep.found) || (!rep.supported))
234 return False;
235 if (pNdxRtrn != NULL)
236 *pNdxRtrn = rep.ndx;
237 if (pStateRtrn != NULL)
238 *pStateRtrn = rep.on;
239 if (pMapRtrn != NULL) {
240 pMapRtrn->flags = rep.flags;
241 pMapRtrn->which_groups = rep.whichGroups;
242 pMapRtrn->groups = rep.groups;
243 pMapRtrn->which_mods = rep.whichMods;
244 pMapRtrn->mods.mask = rep.mods;
245 pMapRtrn->mods.real_mods = rep.realMods;
246 pMapRtrn->mods.vmods = rep.virtualMods;
247 pMapRtrn->ctrls = rep.ctrls;
248 }
249 if (pRealRtrn != NULL)
250 *pRealRtrn = rep.realIndicator;
251 return True;
252 }
253
254 Bool
255 XkbGetNamedIndicator(Display *dpy,
256 Atom name,
257 int *pNdxRtrn,
258 Bool *pStateRtrn,
259 XkbIndicatorMapPtr pMapRtrn,
260 Bool *pRealRtrn)
261 {
262 return XkbGetNamedDeviceIndicator(dpy, XkbUseCoreKbd,
263 XkbDfltXIClass, XkbDfltXIId,
264 name, pNdxRtrn, pStateRtrn,
265 pMapRtrn, pRealRtrn);
266 }
267
268 Bool
269 XkbSetNamedDeviceIndicator(Display *dpy,
270 unsigned device,
271 unsigned class,
272 unsigned id,
273 Atom name,
274 Bool changeState,
275 Bool state,
276 Bool createNewMap,
277 XkbIndicatorMapPtr pMap)
278 {
279 register xkbSetNamedIndicatorReq *req;
280 XkbInfoPtr xkbi;
281
282 if ((dpy->flags & XlibDisplayNoXkb) || (name == None) ||
283 (!dpy->xkb_info && !XkbUseExtension(dpy, NULL, NULL)))
284 return False;
285 LockDisplay(dpy);
286 xkbi = dpy->xkb_info;
287 GetReq(kbSetNamedIndicator, req);
288 req->reqType = xkbi->codes->major_opcode;
289 req->xkbReqType = X_kbSetNamedIndicator;
290 req->deviceSpec = device;
291 req->ledClass = class;
292 req->ledID = id;
293 req->indicator = (CARD32) name;
294 req->setState = changeState;
295 if (req->setState)
296 req->on = state;
297 else
298 req->on = False;
299 if (pMap != NULL) {
300 req->setMap = True;
301 req->createMap = createNewMap;
302 req->flags = pMap->flags;
303 req->whichGroups = pMap->which_groups;
304 req->groups = pMap->groups;
305 req->whichMods = pMap->which_mods;
306 req->realMods = pMap->mods.real_mods;
307 req->virtualMods = pMap->mods.vmods;
308 req->ctrls = pMap->ctrls;
309 }
310 else {
311 req->setMap = False;
312 req->createMap = False;
313 req->flags = 0;
314 req->whichGroups = 0;
315 req->groups = 0;
316 req->whichMods = 0;
317 req->realMods = 0;
318 req->virtualMods = 0;
319 req->ctrls = 0;
320 }
321 UnlockDisplay(dpy);
322 SyncHandle();
323 return True;
324 }
325
326 Bool
327 XkbSetNamedIndicator(Display *dpy,
328 Atom name,
329 Bool changeState,
330 Bool state,
331 Bool createNewMap,
332 XkbIndicatorMapPtr pMap)
333 {
334 return XkbSetNamedDeviceIndicator(dpy, XkbUseCoreKbd,
335 XkbDfltXIClass, XkbDfltXIId,
336 name, changeState, state,
337 createNewMap, pMap);
338 }