Lines Matching refs:wire
1002 xkbKeyTypeWireDesc *wire;
1007 wire= (xkbKeyTypeWireDesc *)buf;
1008 wire->mask = type->mods.mask;
1009 wire->realMods = type->mods.real_mods;
1010 wire->virtualMods = type->mods.vmods;
1011 wire->numLevels = type->num_levels;
1012 wire->nMapEntries = type->map_count;
1013 wire->preserve = (type->preserve!=NULL);
1016 swaps(&wire->virtualMods,n);
1019 buf= (char *)&wire[1];
1020 if (wire->nMapEntries>0) {
1021 xkbKTMapEntryWireDesc * wire;
1023 wire= (xkbKTMapEntryWireDesc *)buf;
1025 for (n=0;n<type->map_count;n++,wire++,entry++) {
1026 wire->active= entry->active;
1027 wire->mask= entry->mods.mask;
1028 wire->level= entry->level;
1029 wire->realMods= entry->mods.real_mods;
1030 wire->virtualMods= entry->mods.vmods;
1033 swaps(&wire->virtualMods,n);
1036 buf= (char *)wire;
1222 xkbBehaviorWireDesc *wire;
1225 wire = (xkbBehaviorWireDesc *)buf;
1229 wire->key= i+rep->firstKeyBehavior;
1230 wire->type= pBhvr->type;
1231 wire->data= pBhvr->data;
1232 wire++;
1235 buf = (char *)wire;
1346 xkbVModMapWireDesc * wire;
1349 wire= (xkbVModMapWireDesc *)buf;
1353 wire->key= i+rep->firstVModMapKey;
1354 wire->vmods= *pMap;
1355 wire++;
1358 return (char *)wire;
1572 register xkbKeyTypeWireDesc *wire = *wireRtrn;
1607 swaps(&wire->virtualMods,s);
1610 width= wire->numLevels;
1626 if (wire->nMapEntries>0) {
1629 mapWire= (xkbKTSetMapEntryWireDesc *)&wire[1];
1630 preWire= (xkbModsWireDesc *)&mapWire[wire->nMapEntries];
1631 for (n=0;n<wire->nMapEntries;n++) {
1636 if (mapWire[n].realMods&(~wire->realMods)) {
1638 wire->realMods);
1641 if (mapWire[n].virtualMods&(~wire->virtualMods)) {
1645 if (mapWire[n].level>=wire->numLevels) {
1646 *nMapsRtrn= _XkbErrCode4(0x08,n,wire->numLevels,
1650 if (wire->preserve) {
1666 if (wire->preserve)
1667 map= (CARD8 *)&preWire[wire->nMapEntries];
1668 else map= (CARD8 *)&mapWire[wire->nMapEntries];
1670 else map= (CARD8 *)&wire[1];
1671 mapWidthRtrn[i+req->firstType] = wire->numLevels;
1672 wire= (xkbKeyTypeWireDesc *)map;
1678 *wireRtrn = wire;
1695 xkbSymMapWireDesc* wire = *wireRtrn;
1704 swaps(&wire->nSyms,nG);
1706 nG = XkbNumGroups(wire->groupInfo);
1714 if (wire->ktIndex[g]>=(unsigned)nTypes) {
1716 wire->ktIndex[g]);
1719 if (mapWidths[wire->ktIndex[g]]>w)
1720 w= mapWidths[wire->ktIndex[g]];
1722 if (wire->width!=w) {
1723 *errorRtrn= _XkbErrCode3(0x16,i+req->firstKeySym,wire->width);
1728 if (w!=wire->nSyms) {
1729 *errorRtrn=_XkbErrCode4(0x16,i+req->firstKeySym,wire->nSyms,w);
1733 else if (wire->nSyms!=0) {
1734 *errorRtrn = _XkbErrCode3(0x17,i+req->firstKeySym,wire->nSyms);
1737 pSyms = (KeySym *)&wire[1];
1738 wire = (xkbSymMapWireDesc *)&pSyms[wire->nSyms];
1755 *wireRtrn = wire;
1769 CARD8 * wire = *wireRtrn;
1776 if (wire[0]!=0) {
1777 if (wire[0]==symsPerKey[i+req->firstKeyAct])
1778 nActs+= wire[0];
1780 *nActsRtrn= _XkbErrCode3(0x23,i+req->firstKeyAct,wire[0]);
1784 wire++;
1787 wire+= 4-(req->nKeyActs%4);
1788 *wireRtrn = (CARD8 *)(((XkbAnyAction *)wire)+nActs);
1799 register xkbBehaviorWireDesc * wire = *wireRtrn;
1820 for (i=0;i<req->totalKeyBehaviors;i++,wire++) {
1821 if ((wire->key<first)||(wire->key>last)) {
1822 *errorRtrn = _XkbErrCode4(0x33,first,last,wire->key);
1825 if ((wire->type&XkbKB_Permanent)&&
1826 ((server->behaviors[wire->key].type!=wire->type)||
1827 (server->behaviors[wire->key].data!=wire->data))) {
1828 *errorRtrn = _XkbErrCode3(0x33,wire->key,wire->type);
1831 if ((wire->type==XkbKB_RadioGroup)&&
1832 ((wire->data&(~XkbKB_RGAllowNone))>XkbMaxRadioGroups)) {
1833 *errorRtrn= _XkbErrCode4(0x34,wire->key,wire->data,
1837 if ((wire->type==XkbKB_Overlay1)||(wire->type==XkbKB_Overlay2)) {
1838 CHK_KEY_RANGE2(0x35,wire->key,1,xkb,*errorRtrn,0);
1841 *wireRtrn = wire;
1851 register CARD8 *wire = *wireRtrn;
1860 *wireRtrn= (wire+XkbPaddedSize(nMods));
1870 register CARD8 * wire = *wireRtrn;
1890 start= wire;
1891 for (i=0;i<req->totalKeyExplicit;i++,wire+=2) {
1892 if ((wire[0]<first)||(wire[0]>last)) {
1893 *errorRtrn = _XkbErrCode4(0x53,first,last,wire[0]);
1896 if (wire[1]&(~XkbAllExplicitMask)) {
1897 *errorRtrn= _XkbErrCode3(0x52,~XkbAllExplicitMask,wire[1]);
1901 wire+= XkbPaddedSize(wire-start)-(wire-start);
1902 *wireRtrn= wire;
1909 register CARD8 * wire = *wireRtrn;
1929 start= wire;
1930 for (i=0;i<req->totalModMapKeys;i++,wire+=2) {
1931 if ((wire[0]<first)||(wire[0]>last)) {
1932 *errRtrn = _XkbErrCode4(0x63,first,last,wire[0]);
1936 wire+= XkbPaddedSize(wire-start)-(wire-start);
1937 *wireRtrn= wire;
1947 register xkbVModMapWireDesc * wire = *wireRtrn;
1966 for (i=0;i<req->totalVModMapKeys;i++,wire++) {
1967 if ((wire->key<first)||(wire->key>last)) {
1968 *errRtrn = _XkbErrCode4(0x73,first,last,wire->key);
1972 *wireRtrn= wire;
1979 xkbKeyTypeWireDesc * wire,
1999 if (XkbResizeKeyType(xkb,i+req->firstType,wire->nMapEntries,
2000 wire->preserve,wire->numLevels)!=Success) {
2004 map = (CARD8 *)&wire[1];
2006 pOld->mods.real_mods = wire->realMods;
2007 pOld->mods.vmods= wire->virtualMods;
2008 pOld->num_levels = wire->numLevels;
2009 pOld->map_count= wire->nMapEntries;
2014 if (wire->nMapEntries) {
2019 preWire= (xkbModsWireDesc *)&mapWire[wire->nMapEntries];
2020 for (n=0;n<wire->nMapEntries;n++) {
2031 if (wire->preserve) {
2038 if (wire->preserve)
2039 map= (CARD8 *)&preWire[wire->nMapEntries];
2040 else map= (CARD8 *)&mapWire[wire->nMapEntries];
2042 else map= (CARD8 *)&wire[1];
2043 wire = (xkbKeyTypeWireDesc *)map;
2058 return (char *)wire;
2065 xkbSymMapWireDesc * wire,
2077 pSyms = (KeySym *)&wire[1];
2078 if (wire->nSyms>0) {
2079 newSyms = XkbResizeKeySyms(xkb,i+req->firstKeySym,wire->nSyms);
2080 for (s=0;s<wire->nSyms;s++) {
2085 for (s=0;s<wire->nSyms;s++) {
2090 oldMap->kt_index[0] = wire->ktIndex[0];
2091 oldMap->kt_index[1] = wire->ktIndex[1];
2092 oldMap->kt_index[2] = wire->ktIndex[2];
2093 oldMap->kt_index[3] = wire->ktIndex[3];
2094 oldMap->group_info = wire->groupInfo;
2095 oldMap->width = wire->width;
2096 wire= (xkbSymMapWireDesc *)&pSyms[wire->nSyms];
2128 return (char *)wire;
2134 CARD8 * wire,
2138 CARD8 * nActs = wire;
2141 wire+= XkbPaddedSize(req->nKeyActs);
2147 memcpy((char *)newActs,(char *)wire,
2149 wire+= nActs[i]*SIZEOF(xkbActionWireDesc);
2165 return (char *)wire;
2171 xkbBehaviorWireDesc *wire,
2184 if ((server->behaviors[wire->key].type&XkbKB_Permanent)==0) {
2185 server->behaviors[wire->key].type= wire->type;
2186 server->behaviors[wire->key].data= wire->data;
2187 if ((wire->type==XkbKB_RadioGroup)&&(((int)wire->data)>maxRG))
2188 maxRG= wire->data + 1;
2190 wire++;
2219 return (char *)wire;
2223 SetVirtualMods(XkbSrvInfoPtr xkbi,xkbSetMapReq *req,CARD8 *wire,
2230 return (char *)wire;
2233 if (srv->vmods[i]!=wire[nMods]) {
2236 srv->vmods[i]= wire[nMods];
2241 return (char *)(wire+XkbPaddedSize(nMods));
2245 SetKeyExplicit(XkbSrvInfoPtr xkbi,xkbSetMapReq *req,CARD8 *wire,
2252 start= wire;
2256 for (i=0;i<req->totalKeyExplicit;i++,wire+= 2) {
2257 xkb->explicit[wire[0]]= wire[1];
2272 wire+= XkbPaddedSize(wire-start)-(wire-start);
2273 return (char *)wire;
2279 CARD8 * wire,
2286 start= wire;
2290 for (i=0;i<req->totalModMapKeys;i++,wire+= 2) {
2291 xkb->modmap[wire[0]]= wire[1];
2306 wire+= XkbPaddedSize(wire-start)-(wire-start);
2307 return (char *)wire;
2313 xkbVModMapWireDesc * wire,
2322 for (i=0;i<req->totalVModMapKeys;i++,wire++) {
2323 srv->vmodmap[wire->key]= wire->vmods;
2338 return (char *)wire;
2757 xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *)data;
2758 for (i=0;i<rep->nSI;i++,sym++,wire++) {
2759 wire->sym= sym->sym;
2760 wire->mods= sym->mods;
2761 wire->match= sym->match;
2762 wire->virtualMod= sym->virtual_mod;
2763 wire->flags= sym->flags;
2764 memcpy((char*)&wire->act,(char*)&sym->act,sz_xkbActionWireDesc);
2767 swapl(&wire->sym,n);
2771 grp = (xkbModsWireDesc *)wire;
2784 wire= (xkbSymInterpretWireDesc*)grp;
2868 xkbSymInterpretWireDesc *wire;
2873 wire= (xkbSymInterpretWireDesc *)data;
2874 wire+= req->nSI;
2875 data = (char *)wire;
2896 xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *)data;
2911 for (i=0;i<req->nSI;i++,wire++,sym++) {
2914 swapl(&wire->sym,n);
2916 sym->sym= wire->sym;
2917 sym->mods= wire->mods;
2918 sym->match= wire->match;
2919 sym->flags= wire->flags;
2920 sym->virtual_mod= wire->virtualMod;
2921 memcpy((char *)&sym->act,(char *)&wire->act,
2924 data = (char *)wire;
2932 xkbModsWireDesc *wire = (xkbModsWireDesc *)data;
2937 swaps(&wire->virtualMods,n);
2939 compat->groups[i].mask= wire->realMods;
2940 compat->groups[i].real_mods= wire->realMods;
2941 compat->groups[i].vmods= wire->virtualMods;
2942 if (wire->virtualMods!=0) {
2944 tmp= XkbMaskForVMask(xkb,wire->virtualMods);
2948 wire= (xkbModsWireDesc *)data;
3120 xkbIndicatorMapWireDesc *wire = (xkbIndicatorMapWireDesc *)to;
3123 wire->flags= indicators->maps[i].flags;
3124 wire->whichGroups= indicators->maps[i].which_groups;
3125 wire->groups= indicators->maps[i].groups;
3126 wire->whichMods= indicators->maps[i].which_mods;
3127 wire->mods= indicators->maps[i].mods.mask;
3128 wire->realMods= indicators->maps[i].mods.real_mods;
3129 wire->virtualMods= indicators->maps[i].mods.vmods;
3130 wire->ctrls= indicators->maps[i].ctrls;
3133 swaps(&wire->virtualMods,n);
3134 swapl(&wire->ctrls,n);
3136 wire++;
3139 to = (CARD8 *)wire;
3614 _XkbWriteAtoms(char *wire,Atom *atoms,int maxAtoms,int swap)
3619 atm = (Atom *)wire;
3924 _XkbCheckAtoms(CARD32 *wire,int nAtoms,int swapped,Atom *pError)
3928 for (i=0;i<nAtoms;i++,wire++) {
3931 swapl(wire,n);
3933 if ((((Atom)*wire)!=None)&&(!ValidAtom((Atom)*wire))) {
3934 *pError= ((Atom)*wire);
3938 return wire;
3942 _XkbCheckMaskedAtoms(CARD32 *wire,int nAtoms,CARD32 present,int swapped,
3952 swapl(wire,n);
3954 if ((((Atom)*wire)!=None)&&(!ValidAtom(((Atom)*wire)))) {
3955 *pError= (Atom)*wire;
3958 wire++;
3960 return wire;
3964 _XkbCopyMaskedAtoms( Atom *wire,
3974 dest[i]= *wire++;
3976 return wire;
4455 XkbWriteCountedString(char *wire,char *str,Bool swap)
4460 return wire;
4463 pLen= (CARD16 *)wire;
4470 strncpy(&wire[sizeof(len)],str,paddedLen);
4471 wire+= sizeof(len)+paddedLen;
4472 return wire;
4489 XkbWriteGeomProperties(char *wire,XkbGeometryPtr geom,Bool swap)
4495 wire= XkbWriteCountedString(wire,prop->name,swap);
4496 wire= XkbWriteCountedString(wire,prop->value,swap);
4498 return wire;
4508 XkbWriteGeomKeyAliases(char *wire,XkbGeometryPtr geom,Bool swap)
4514 memcpy(wire,(char *)geom->key_aliases,sz);
4515 wire+= sz;
4517 return wire;
4533 XkbWriteGeomColors(char *wire,XkbGeometryPtr geom,Bool swap)
4539 wire= XkbWriteCountedString(wire,color->spec,swap);
4541 return wire;
4563 XkbWriteGeomShapes(char *wire,XkbGeometryPtr geom,Bool swap)
4573 shapeWire= (xkbShapeWireDesc *)wire;
4587 wire= (char *)&shapeWire[1];
4592 olWire= (xkbOutlineWireDesc *)wire;
4596 wire= (char *)&olWire[1];
4597 ptWire= (xkbPointWireDesc *)wire;
4607 wire= (char *)&ptWire[ol->num_points];
4610 return wire;
4632 XkbWriteGeomDoodads(char *wire,int num_doodads,XkbDoodadPtr doodad,Bool swap)
4638 doodadWire= (xkbDoodadWireDesc *)wire;
4639 wire= (char *)&doodadWire[1];
4674 wire= XkbWriteCountedString(wire,doodad->text.text,swap);
4675 wire= XkbWriteCountedString(wire,doodad->text.font,swap);
4687 wire= XkbWriteCountedString(wire,doodad->logo.logo_name,swap);
4696 return wire;
4700 XkbWriteGeomOverlay(char *wire,XkbOverlayPtr ol,Bool swap)
4706 olWire= (xkbOverlayWireDesc *)wire;
4715 wire= (char *)&olWire[1];
4720 rowWire= (xkbOverlayRowWireDesc *)wire;
4724 wire= (char *)&rowWire[1];
4727 keyWire= (xkbOverlayKeyWireDesc *)wire;
4730 wire= (char *)&keyWire[1];
4733 return wire;
4772 XkbWriteGeomSections(char *wire,XkbGeometryPtr geom,Bool swap)
4779 sectionWire= (xkbSectionWireDesc *)wire;
4800 wire= (char *)§ionWire[1];
4806 rowWire= (xkbRowWireDesc *)wire;
4817 wire= (char *)&rowWire[1];
4822 keyWire= (xkbKeyWireDesc *)wire;
4833 wire= (char *)&keyWire[row->num_keys];
4838 wire= XkbWriteGeomDoodads(wire,
4845 wire= XkbWriteGeomOverlay(wire,§ion->overlays[o],swap);
4849 return wire;
4989 char *wire, *next;
4992 wire = *wire_inout;
4993 len = *(CARD16 *) wire;
4998 next = wire + XkbPaddedSize(len + 2);
5006 memcpy(*str, &wire[2], len);
5018 char * wire;
5024 wire= (char *)&dWire[1];
5071 status = _GetCountedString(&wire, client, &doodad->text.text);
5074 status = _GetCountedString(&wire, client, &doodad->text.font);
5113 status = _GetCountedString(&wire, client, &doodad->logo.logo_name);
5121 *wire_inout= wire;
5132 char * wire;
5137 wire= *wire_inout;
5138 olWire= (xkbOverlayWireDesc *)wire;
5168 wire= (char *)olWire;
5169 *wire_inout= wire;
5181 char * wire;
5185 wire= *wire_inout;
5188 sWire= (xkbSectionWireDesc *)wire;
5251 wire= (char *)rWire;
5255 status=_CheckSetDoodad(&wire,geom,section,client);
5263 status= _CheckSetOverlay(&wire,geom,section,client);
5268 sWire= (xkbSectionWireDesc *)wire;
5270 wire= (char *)sWire;
5271 *wire_inout= wire;
5282 char * wire;
5284 wire= *wire_inout;
5293 shapeWire= (xkbShapeWireDesc *)wire;
5329 wire= (char *)shapeWire;
5336 *wire_inout= wire;
5347 char * wire;
5349 wire= (char *)&req[1];
5350 status = _GetCountedString(&wire, client, &geom->label_font);
5357 status = _GetCountedString(&wire, client, &name);
5360 status = _GetCountedString(&wire, client, &val);
5394 status = _GetCountedString(&wire, client, &name);
5410 if ((status=_CheckSetShapes(geom,req,&wire,client))!=Success)
5413 if ((status=_CheckSetSections(geom,req,&wire,client))!=Success)
5417 status=_CheckSetDoodad(&wire,geom,NULL,client);
5423 if (XkbAddGeomKeyAlias(geom,&wire[XkbKeyNameLength],wire)==NULL)
5425 wire+= 2*XkbKeyNameLength;
5622 unsigned char *wire,*str,*tmp,*legal;
5627 wire= *pWire;
5628 len= (*(unsigned char *)wire++);
5634 if (legal[(*wire)/8]&(1<<((*wire)%8)))
5635 *tmp++= *wire++;
5636 else wire++;
5652 *pWire= wire;
6164 xkbDeviceLedsWireDesc wire;
6168 wire.ledClass= sli->class;
6169 wire.ledID= sli->id;
6170 wire.namesPresent= sli->namesPresent;
6171 wire.mapsPresent= sli->mapsPresent;
6172 wire.physIndicators= sli->physIndicators;
6173 wire.state= sli->effectiveState;
6176 swaps(&wire.ledClass,n);
6177 swaps(&wire.ledID,n);
6178 swapl(&wire.namesPresent,n);
6179 swapl(&wire.mapsPresent,n);
6180 swapl(&wire.physIndicators,n);
6181 swapl(&wire.state,n);
6183 WriteToClient(client,SIZEOF(xkbDeviceLedsWireDesc),(char *)&wire);
6413 CheckSetDeviceIndicators( char * wire,
6423 ledWire= (xkbDeviceLedsWireDesc *)wire;
6491 SetDeviceIndicators( char * wire,
6511 ledWire= (xkbDeviceLedsWireDesc *)wire;
6605 char *wire;
6607 wire= (char *)&stuff[1];
6618 wire+= (stuff->nBtns*SIZEOF(xkbActionWireDesc));
6622 wire= CheckSetDeviceIndicators(wire,dev,stuff->nDeviceLedFBs,
6627 if (((wire-((char *)stuff))/4)!=stuff->length)
6637 char *wire;
6642 wire= (char *)&stuff[1];
6659 if (!_XkbCheckRequestBounds(client, stuff, wire, (char *) wire + sz))
6661 memcpy((char *)&acts[stuff->firstBtn],(char *)wire,sz);
6662 wire+= sz;
6677 wire= SetDeviceIndicators(wire,dev,stuff->change,