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