Lines Matching refs:wire
1023 xkbKeyTypeWireDesc *wire;
1029 wire = (xkbKeyTypeWireDesc *) buf;
1030 wire->mask = type->mods.mask;
1031 wire->realMods = type->mods.real_mods;
1032 wire->virtualMods = type->mods.vmods;
1033 wire->numLevels = type->num_levels;
1034 wire->nMapEntries = type->map_count;
1035 wire->preserve = (type->preserve != NULL);
1037 swaps(&wire->virtualMods);
1040 buf = (char *) &wire[1];
1041 if (wire->nMapEntries > 0) {
1248 xkbBehaviorWireDesc *wire;
1251 wire = (xkbBehaviorWireDesc *) buf;
1255 wire->key = i + rep->firstKeyBehavior;
1256 wire->type = pBhvr->type;
1257 wire->data = pBhvr->data;
1258 wire++;
1261 buf = (char *) wire;
1374 xkbVModMapWireDesc *wire;
1377 wire = (xkbVModMapWireDesc *) buf;
1381 wire->key = i + rep->firstVModMapKey;
1382 wire->vmods = *pMap;
1383 wire++;
1386 return (char *) wire;
1608 register xkbKeyTypeWireDesc *wire = *wireRtrn;
1643 swaps(&wire->virtualMods);
1646 width = wire->numLevels;
1662 if (wire->nMapEntries > 0) {
1666 mapWire = (xkbKTSetMapEntryWireDesc *) &wire[1];
1667 preWire = (xkbModsWireDesc *) &mapWire[wire->nMapEntries];
1668 for (n = 0; n < wire->nMapEntries; n++) {
1672 if (mapWire[n].realMods & (~wire->realMods)) {
1674 wire->realMods);
1677 if (mapWire[n].virtualMods & (~wire->virtualMods)) {
1681 if (mapWire[n].level >= wire->numLevels) {
1682 *nMapsRtrn = _XkbErrCode4(0x08, n, wire->numLevels,
1686 if (wire->preserve) {
1702 if (wire->preserve)
1703 map = (CARD8 *) &preWire[wire->nMapEntries];
1705 map = (CARD8 *) &mapWire[wire->nMapEntries];
1708 map = (CARD8 *) &wire[1];
1709 mapWidthRtrn[i + req->firstType] = wire->numLevels;
1710 wire = (xkbKeyTypeWireDesc *) map;
1716 *wireRtrn = wire;
1730 xkbSymMapWireDesc *wire = *wireRtrn;
1741 swaps(&wire->nSyms);
1743 nG = XkbNumGroups(wire->groupInfo);
1752 if (wire->ktIndex[g] >= (unsigned) nTypes) {
1754 wire->ktIndex[g]);
1757 if (mapWidths[wire->ktIndex[g]] > w)
1758 w = mapWidths[wire->ktIndex[g]];
1760 if (wire->width != w) {
1762 _XkbErrCode3(0x16, i + req->firstKeySym, wire->width);
1767 if (w != wire->nSyms) {
1769 _XkbErrCode4(0x16, i + req->firstKeySym, wire->nSyms, w);
1773 else if (wire->nSyms != 0) {
1774 *errorRtrn = _XkbErrCode3(0x17, i + req->firstKeySym, wire->nSyms);
1777 pSyms = (KeySym *) &wire[1];
1778 wire = (xkbSymMapWireDesc *) &pSyms[wire->nSyms];
1796 *wireRtrn = wire;
1808 CARD8 *wire = *wireRtrn;
1816 if (wire[0] != 0) {
1817 if (wire[0] == symsPerKey[i + req->firstKeyAct])
1818 nActs += wire[0];
1820 *nActsRtrn = _XkbErrCode3(0x23, i + req->firstKeyAct, wire[0]);
1824 wire++;
1827 wire += 4 - (req->nKeyActs % 4);
1828 *wireRtrn = (CARD8 *) (((XkbAnyAction *) wire) + nActs);
1838 register xkbBehaviorWireDesc *wire = *wireRtrn;
1859 for (i = 0; i < req->totalKeyBehaviors; i++, wire++) {
1860 if ((wire->key < first) || (wire->key > last)) {
1861 *errorRtrn = _XkbErrCode4(0x33, first, last, wire->key);
1864 if ((wire->type & XkbKB_Permanent) &&
1865 ((server->behaviors[wire->key].type != wire->type) ||
1866 (server->behaviors[wire->key].data != wire->data))) {
1867 *errorRtrn = _XkbErrCode3(0x33, wire->key, wire->type);
1870 if ((wire->type == XkbKB_RadioGroup) &&
1871 ((wire->data & (~XkbKB_RGAllowNone)) > XkbMaxRadioGroups)) {
1872 *errorRtrn = _XkbErrCode4(0x34, wire->key, wire->data,
1876 if ((wire->type == XkbKB_Overlay1) || (wire->type == XkbKB_Overlay2)) {
1877 CHK_KEY_RANGE2(0x35, wire->key, 1, xkb, *errorRtrn, 0);
1880 *wireRtrn = wire;
1888 register CARD8 *wire = *wireRtrn;
1897 *wireRtrn = (wire + XkbPaddedSize(nMods));
1905 register CARD8 *wire = *wireRtrn;
1926 start = wire;
1927 for (i = 0; i < req->totalKeyExplicit; i++, wire += 2) {
1928 if ((wire[0] < first) || (wire[0] > last)) {
1929 *errorRtrn = _XkbErrCode4(0x53, first, last, wire[0]);
1932 if (wire[1] & (~XkbAllExplicitMask)) {
1933 *errorRtrn = _XkbErrCode3(0x52, ~XkbAllExplicitMask, wire[1]);
1937 wire += XkbPaddedSize(wire - start) - (wire - start);
1938 *wireRtrn = wire;
1946 register CARD8 *wire = *wireRtrn;
1966 start = wire;
1967 for (i = 0; i < req->totalModMapKeys; i++, wire += 2) {
1968 if ((wire[0] < first) || (wire[0] > last)) {
1969 *errRtrn = _XkbErrCode4(0x63, first, last, wire[0]);
1973 wire += XkbPaddedSize(wire - start) - (wire - start);
1974 *wireRtrn = wire;
1983 register xkbVModMapWireDesc *wire = *wireRtrn;
2002 for (i = 0; i < req->totalVModMapKeys; i++, wire++) {
2003 if ((wire->key < first) || (wire->key > last)) {
2004 *errRtrn = _XkbErrCode4(0x73, first, last, wire->key);
2008 *wireRtrn = wire;
2015 xkbKeyTypeWireDesc * wire, XkbChangesPtr changes)
2034 if (XkbResizeKeyType(xkb, i + req->firstType, wire->nMapEntries,
2035 wire->preserve, wire->numLevels) != Success) {
2039 map = (CARD8 *) &wire[1];
2041 pOld->mods.real_mods = wire->realMods;
2042 pOld->mods.vmods = wire->virtualMods;
2043 pOld->num_levels = wire->numLevels;
2044 pOld->map_count = wire->nMapEntries;
2049 if (wire->nMapEntries) {
2055 preWire = (xkbModsWireDesc *) &mapWire[wire->nMapEntries];
2056 for (n = 0; n < wire->nMapEntries; n++) {
2067 if (wire->preserve) {
2074 if (wire->preserve)
2075 map = (CARD8 *) &preWire[wire->nMapEntries];
2077 map = (CARD8 *) &mapWire[wire->nMapEntries];
2080 map = (CARD8 *) &wire[1];
2081 wire = (xkbKeyTypeWireDesc *) map;
2097 return (char *) wire;
2104 xkbSymMapWireDesc * wire, XkbChangesPtr changes, DeviceIntPtr dev)
2114 pSyms = (KeySym *) &wire[1];
2115 if (wire->nSyms > 0) {
2116 newSyms = XkbResizeKeySyms(xkb, i + req->firstKeySym, wire->nSyms);
2117 for (s = 0; s < wire->nSyms; s++) {
2121 for (s = 0; s < wire->nSyms; s++) {
2128 XkbNumGroups(wire->groupInfo) * wire->width);
2129 oldMap->kt_index[0] = wire->ktIndex[0];
2130 oldMap->kt_index[1] = wire->ktIndex[1];
2131 oldMap->kt_index[2] = wire->ktIndex[2];
2132 oldMap->kt_index[3] = wire->ktIndex[3];
2133 oldMap->group_info = wire->groupInfo;
2134 oldMap->width = wire->width;
2135 wire = (xkbSymMapWireDesc *) &pSyms[wire->nSyms];
2169 return (char *) wire;
2174 xkbSetMapReq * req, CARD8 *wire, XkbChangesPtr changes)
2177 CARD8 *nActs = wire;
2180 wire += XkbPaddedSize(req->nKeyActs);
2186 memcpy((char *) newActs, (char *) wire,
2188 wire += nActs[i] * SIZEOF(xkbActionWireDesc);
2205 return (char *) wire;
2211 xkbBehaviorWireDesc * wire, XkbChangesPtr changes)
2224 if ((server->behaviors[wire->key].type & XkbKB_Permanent) == 0) {
2225 server->behaviors[wire->key].type = wire->type;
2226 server->behaviors[wire->key].data = wire->data;
2227 if ((wire->type == XkbKB_RadioGroup) &&
2228 (((int) wire->data) > maxRG))
2229 maxRG = wire->data + 1;
2231 wire++;
2263 return (char *) wire;
2267 SetVirtualMods(XkbSrvInfoPtr xkbi, xkbSetMapReq * req, CARD8 *wire,
2274 return (char *) wire;
2277 if (srv->vmods[i] != wire[nMods]) {
2280 srv->vmods[i] = wire[nMods];
2285 return (char *) (wire + XkbPaddedSize(nMods));
2289 SetKeyExplicit(XkbSrvInfoPtr xkbi, xkbSetMapReq * req, CARD8 *wire,
2296 start = wire;
2300 for (i = 0; i < req->totalKeyExplicit; i++, wire += 2) {
2301 xkb->explicit[wire[0]] = wire[1];
2317 wire += XkbPaddedSize(wire - start) - (wire - start);
2318 return (char *) wire;
2323 xkbSetMapReq * req, CARD8 *wire, XkbChangesPtr changes)
2329 start = wire;
2333 for (i = 0; i < req->totalModMapKeys; i++, wire += 2) {
2334 xkb->modmap[wire[0]] = wire[1];
2350 wire += XkbPaddedSize(wire - start) - (wire - start);
2351 return (char *) wire;
2357 xkbVModMapWireDesc * wire, XkbChangesPtr changes)
2365 for (i = 0; i < req->totalVModMapKeys; i++, wire++) {
2366 srv->vmodmap[wire->key] = wire->vmods;
2382 return (char *) wire;
2846 xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *) data;
2850 for (i = 0; i < rep->nSI; i++, sym++, wire++) {
2851 wire->sym = sym->sym;
2852 wire->mods = sym->mods;
2853 wire->match = sym->match;
2854 wire->virtualMod = sym->virtual_mod;
2855 wire->flags = sym->flags;
2856 memcpy((char *) &wire->act, (char *) &sym->act,
2859 swapl(&wire->sym);
2863 grp = (xkbModsWireDesc *) wire;
2875 wire = (xkbSymInterpretWireDesc *) grp;
2962 xkbSymInterpretWireDesc *wire;
2968 wire = (xkbSymInterpretWireDesc *) data;
2969 wire += req->nSI;
2970 data = (char *) wire;
2991 xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *) data;
3009 for (i = 0; i < req->nSI; i++, wire++) {
3011 swapl(&wire->sym);
3013 if (wire->sym == NoSymbol && wire->match == XkbSI_AnyOfOrNone &&
3014 (wire->mods & 0xff) == 0xff &&
3015 wire->act.type == XkbSA_XFree86Private) {
3021 sym->sym = wire->sym;
3022 sym->mods = wire->mods;
3023 sym->match = wire->match;
3024 sym->flags = wire->flags;
3025 sym->virtual_mod = wire->virtualMod;
3026 memcpy((char *) &sym->act, (char *) &wire->act,
3037 data = (char *) wire;
3044 xkbModsWireDesc *wire = (xkbModsWireDesc *) data;
3049 swaps(&wire->virtualMods);
3051 compat->groups[i].mask = wire->realMods;
3052 compat->groups[i].real_mods = wire->realMods;
3053 compat->groups[i].vmods = wire->virtualMods;
3054 if (wire->virtualMods != 0) {
3057 tmp = XkbMaskForVMask(xkb, wire->virtualMods);
3061 wire = (xkbModsWireDesc *) data;
3232 xkbIndicatorMapWireDesc *wire = (xkbIndicatorMapWireDesc *) to;
3238 wire->flags = indicators->maps[i].flags;
3239 wire->whichGroups = indicators->maps[i].which_groups;
3240 wire->groups = indicators->maps[i].groups;
3241 wire->whichMods = indicators->maps[i].which_mods;
3242 wire->mods = indicators->maps[i].mods.mask;
3243 wire->realMods = indicators->maps[i].mods.real_mods;
3244 wire->virtualMods = indicators->maps[i].mods.vmods;
3245 wire->ctrls = indicators->maps[i].ctrls;
3247 swaps(&wire->virtualMods);
3248 swapl(&wire->ctrls);
3250 wire++;
3253 to = (CARD8 *) wire;
3732 _XkbWriteAtoms(char *wire, Atom *atoms, int maxAtoms, int swap)
3737 atm = (Atom *) wire;
4056 _XkbCheckAtoms(CARD32 *wire, int nAtoms, int swapped, Atom *pError)
4060 for (i = 0; i < nAtoms; i++, wire++) {
4062 swapl(wire);
4064 if ((((Atom) *wire) != None) && (!ValidAtom((Atom) *wire))) {
4065 *pError = ((Atom) *wire);
4069 return wire;
4073 _XkbCheckMaskedAtoms(CARD32 *wire, int nAtoms, CARD32 present, int swapped,
4082 swapl(wire);
4084 if ((((Atom) *wire) != None) && (!ValidAtom(((Atom) *wire)))) {
4085 *pError = (Atom) *wire;
4088 wire++;
4090 return wire;
4094 _XkbCopyMaskedAtoms(Atom *wire, Atom *dest, int nAtoms, CARD32 present)
4101 dest[i] = *wire++;
4103 return wire;
4585 * Write the zero-terminated string str into wire as a pascal string with a
4588 * @param wire The destination array, usually the wire struct
4596 XkbWriteCountedString(char *wire, const char *str, Bool swap)
4601 return wire;
4604 pLen = (CARD16 *) wire;
4610 strncpy(&wire[sizeof(len)], str, paddedLen);
4611 wire += sizeof(len) + paddedLen;
4612 return wire;
4630 XkbWriteGeomProperties(char *wire, XkbGeometryPtr geom, Bool swap)
4636 wire = XkbWriteCountedString(wire, prop->name, swap);
4637 wire = XkbWriteCountedString(wire, prop->value, swap);
4639 return wire;
4649 XkbWriteGeomKeyAliases(char *wire, XkbGeometryPtr geom, Bool swap)
4655 memcpy(wire, (char *) geom->key_aliases, sz);
4656 wire += sz;
4658 return wire;
4674 XkbWriteGeomColors(char *wire, XkbGeometryPtr geom, Bool swap)
4680 wire = XkbWriteCountedString(wire, color->spec, swap);
4682 return wire;
4705 XkbWriteGeomShapes(char *wire, XkbGeometryPtr geom, Bool swap)
4716 shapeWire = (xkbShapeWireDesc *) wire;
4731 wire = (char *) &shapeWire[1];
4737 olWire = (xkbOutlineWireDesc *) wire;
4741 wire = (char *) &olWire[1];
4742 ptWire = (xkbPointWireDesc *) wire;
4751 wire = (char *) &ptWire[ol->num_points];
4754 return wire;
4776 XkbWriteGeomDoodads(char *wire, int num_doodads, XkbDoodadPtr doodad, Bool swap)
4782 doodadWire = (xkbDoodadWireDesc *) wire;
4783 wire = (char *) &doodadWire[1];
4815 wire = XkbWriteCountedString(wire, doodad->text.text, swap);
4816 wire = XkbWriteCountedString(wire, doodad->text.font, swap);
4827 wire = XkbWriteCountedString(wire, doodad->logo.logo_name, swap);
4836 return wire;
4840 XkbWriteGeomOverlay(char *wire, XkbOverlayPtr ol, Bool swap)
4846 olWire = (xkbOverlayWireDesc *) wire;
4854 wire = (char *) &olWire[1];
4860 rowWire = (xkbOverlayRowWireDesc *) wire;
4864 wire = (char *) &rowWire[1];
4868 keyWire = (xkbOverlayKeyWireDesc *) wire;
4871 wire = (char *) &keyWire[1];
4874 return wire;
4918 XkbWriteGeomSections(char *wire, XkbGeometryPtr geom, Bool swap)
4926 sectionWire = (xkbSectionWireDesc *) wire;
4946 wire = (char *) §ionWire[1];
4953 rowWire = (xkbRowWireDesc *) wire;
4963 wire = (char *) &rowWire[1];
4969 keyWire = (xkbKeyWireDesc *) wire;
4980 wire = (char *) &keyWire[row->num_keys];
4985 wire = XkbWriteGeomDoodads(wire,
4993 wire = XkbWriteGeomOverlay(wire, §ion->overlays[o], swap);
4997 return wire;
5136 char *wire, *next;
5139 wire = *wire_inout;
5142 bytes_to_int32(wire + 2 - (char *) client->requestBuffer))
5145 len = *(CARD16 *) wire;
5149 next = wire + XkbPaddedSize(len + 2);
5157 memcpy(*str, &wire[2], len);
5167 char *wire;
5179 wire = (char *) &dWire[1];
5225 status = _GetCountedString(&wire, client, &doodad->text.text);
5228 status = _GetCountedString(&wire, client, &doodad->text.font);
5267 status = _GetCountedString(&wire, client, &doodad->logo.logo_name);
5275 *wire_inout = wire;
5284 char *wire;
5289 wire = *wire_inout;
5290 olWire = (xkbOverlayWireDesc *) wire;
5329 wire = (char *) olWire;
5330 *wire_inout = wire;
5340 char *wire;
5344 wire = *wire_inout;
5347 sWire = (xkbSectionWireDesc *) wire;
5420 wire = (char *) rWire;
5425 status = _CheckSetDoodad(&wire, req, geom, section, client);
5434 status = _CheckSetOverlay(&wire, req, geom, section, client);
5439 sWire = (xkbSectionWireDesc *) wire;
5441 wire = (char *) sWire;
5442 *wire_inout = wire;
5451 char *wire;
5453 wire = *wire_inout;
5463 shapeWire = (xkbShapeWireDesc *) wire;
5509 wire = (char *) shapeWire;
5516 *wire_inout = wire;
5525 char *wire;
5527 wire = (char *) &req[1];
5528 status = _GetCountedString(&wire, client, &geom->label_font);
5535 status = _GetCountedString(&wire, client, &name);
5538 status = _GetCountedString(&wire, client, &val);
5575 status = _GetCountedString(&wire, client, &name);
5591 if ((status = _CheckSetShapes(geom, req, &wire, client)) != Success)
5594 if ((status = _CheckSetSections(geom, req, &wire, client)) != Success)
5598 status = _CheckSetDoodad(&wire, req, geom, NULL, client);
5604 if (!_XkbCheckRequestBounds(client, req, wire, wire + XkbKeyNameLength))
5607 if (XkbAddGeomKeyAlias(geom, &wire[XkbKeyNameLength], wire) == NULL)
5609 wire += 2 * XkbKeyNameLength;
5806 unsigned char *wire, *str, *tmp, *legal;
5813 wire = *pWire;
5814 len = (*(unsigned char *) wire++);
5820 if (legal[(*wire) / 8] & (1 << ((*wire) % 8)))
5821 *tmp++ = *wire++;
5823 wire++;
5839 *pWire = wire;
6352 xkbDeviceLedsWireDesc wire;
6356 wire.ledClass = sli->class;
6357 wire.ledID = sli->id;
6358 wire.namesPresent = sli->namesPresent;
6359 wire.mapsPresent = sli->mapsPresent;
6360 wire.physIndicators = sli->physIndicators;
6361 wire.state = sli->effectiveState;
6363 swaps(&wire.ledClass);
6364 swaps(&wire.ledID);
6365 swapl(&wire.namesPresent);
6366 swapl(&wire.mapsPresent);
6367 swapl(&wire.physIndicators);
6368 swapl(&wire.state);
6370 WriteToClient(client, SIZEOF(xkbDeviceLedsWireDesc), &wire);
6603 CheckSetDeviceIndicators(char *wire,
6612 ledWire = (xkbDeviceLedsWireDesc *) wire;
6689 SetDeviceIndicators(char *wire,
6709 ledWire = (xkbDeviceLedsWireDesc *) wire;
6790 char *wire;
6792 wire = (char *) &stuff[1];
6795 if (!_XkbCheckRequestBounds(client, stuff, wire, (char *) wire + sz))
6808 wire += sz;
6813 wire = CheckSetDeviceIndicators(wire, dev, stuff->nDeviceLedFBs,
6818 if (((wire - ((char *) stuff)) / 4) != stuff->length)
6828 char *wire;
6833 wire = (char *) &stuff[1];
6850 memcpy((char *) &acts[stuff->firstBtn], (char *) wire, sz);
6851 wire += sz;
6869 wire = SetDeviceIndicators(wire, dev, stuff->change,