dos -> unix

1 files changed, 591 insertions, 591 deletions

diff --git a/libX11/src/xkb/XKBSetMap.c b/libX11/src/xkb/XKBSetMap.c
index 8adfe5446..cad9364b7 100644
--- a/libX11/src/xkb/XKBSetMap.c
+++ b/libX11/src/xkb/XKBSetMap.c
@@ -1,591 +1,591 @@
-/************************************************************

-Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.

-

-Permission to use, copy, modify, and distribute this

-software and its documentation for any purpose and without

-fee is hereby granted, provided that the above copyright

-notice appear in all copies and that both that copyright

-notice and this permission notice appear in supporting

-documentation, and that the name of Silicon Graphics not be

-used in advertising or publicity pertaining to distribution

-of the software without specific prior written permission.

-Silicon Graphics makes no representation about the suitability

-of this software for any purpose. It is provided "as is"

-without any express or implied warranty.

-

-SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

-SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY

-AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON

-GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL

-DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

-DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE

-OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH

-THE USE OR PERFORMANCE OF THIS SOFTWARE.

-

-********************************************************/

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include <stdio.h>

-#include "Xlibint.h"

-#include <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

-static int

-_XkbSizeKeyTypes(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-    XkbKeyTypePtr	map;

-    int			i,len;

-

-    if (((req->present&XkbKeyTypesMask)==0)||(req->nTypes==0)) {

-	req->present&= ~XkbKeyTypesMask;

-	req->firstType= req->nTypes= 0;

-	return 0;

-    }

-    len= 0;

-    map= &xkb->map->types[req->firstType];

-    for (i=0;i<req->nTypes;i++,map++){

-	len+= SIZEOF(xkbKeyTypeWireDesc);

-	len+= map->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);

-	if (map->preserve)

-	    len+= map->map_count*SIZEOF(xkbModsWireDesc);

-    }

-    return len;

-}

-

-static void

-_XkbWriteKeyTypes(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-    char *		buf;

-    XkbKeyTypePtr 	type;

-    int			i,n,sz;

-    xkbKeyTypeWireDesc *desc;

-

-    if ((req->present&XkbKeyTypesMask)==0)

-	return;

-    type= &xkb->map->types[req->firstType];

-    for (i=0;i<req->nTypes;i++,type++) {

-	sz= SIZEOF(xkbKeyTypeWireDesc);

-	sz+= type->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);

-	if (type->preserve)

-	    sz+= type->map_count*SIZEOF(xkbModsWireDesc);

-	BufAlloc(xkbKeyTypeWireDesc *,desc,sz);

-	desc->mask = type->mods.mask;

-	desc->realMods = type->mods.real_mods;

-	desc->virtualMods = type->mods.vmods;

-	desc->numLevels = type->num_levels;

-	desc->nMapEntries = type->map_count;

-	desc->preserve = (type->preserve!=NULL);

-	buf= (char *)&desc[1];

-	if (desc->nMapEntries>0) {

-	    xkbKTSetMapEntryWireDesc *wire;

-	    wire= (xkbKTSetMapEntryWireDesc *)buf;

-	    for (n=0;n<type->map_count;n++,wire++) {

-		wire->level= type->map[n].level;

-		wire->realMods= type->map[n].mods.real_mods;

-		wire->virtualMods= type->map[n].mods.vmods;

-	    }

-	    buf= (char *)wire;

-	    if (type->preserve) {

-		xkbModsWireDesc *pwire;

-		pwire= (xkbModsWireDesc *)buf;

-		for (n=0;n<type->map_count;n++,pwire++) {

-		    pwire->realMods= type->preserve[n].real_mods;

-		    pwire->virtualMods= type->preserve[n].vmods;

-		}

-	    }

-	}

-    }

-    return;

-}

-

-static int

-_XkbSizeKeySyms(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-    int			i,len;

-    unsigned		nSyms;

-

-    if (((req->present&XkbKeySymsMask)==0)||(req->nKeySyms==0)) {

-	req->present&= ~XkbKeySymsMask;

-	req->firstKeySym= req->nKeySyms= 0;

-	req->totalSyms= 0;

-	return 0;

-    }

-    len= (int)(req->nKeySyms*sizeof(XkbSymMapRec));

-    for (i=nSyms=0;i<req->nKeySyms;i++) {

-	nSyms+= XkbKeyNumSyms(xkb,i+req->firstKeySym);

-    }

-    len+= nSyms*sizeof(CARD32);

-    req->totalSyms= nSyms;

-    return len;

-}

-

-static void

-_XkbWriteKeySyms(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register KeySym *	pSym;

-CARD32 *		outSym;

-XkbSymMapPtr		symMap;

-xkbSymMapWireDesc *desc;

-register int	i;

-

-    if ((req->present&XkbKeySymsMask)==0)

-	return;

-    symMap = &xkb->map->key_sym_map[req->firstKeySym];

-    for (i=0;i<req->nKeySyms;i++,symMap++) {

-	BufAlloc(xkbSymMapWireDesc *,desc,

-		 SIZEOF(xkbSymMapWireDesc)+

-		 (XkbKeyNumSyms(xkb,i+req->firstKeySym)*sizeof(CARD32)));

-	desc->ktIndex[0] = symMap->kt_index[0];

-	desc->ktIndex[1] = symMap->kt_index[1];

-	desc->ktIndex[2] = symMap->kt_index[2];

-	desc->ktIndex[3] = symMap->kt_index[3];

-	desc->groupInfo = symMap->group_info;

-	desc->width = symMap->width;

-	desc->nSyms = XkbKeyNumSyms(xkb,i+req->firstKeySym);

-	outSym = (CARD32 *)&desc[1];

-	if (desc->nSyms>0) {

-	     pSym = XkbKeySymsPtr(xkb,i+req->firstKeySym);

-	    _XkbWriteCopyKeySyms(pSym,outSym,desc->nSyms);

-	}

-    }

-    return;

-}

-

-static int

-_XkbSizeKeyActions(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-    int			i,len,nActs;

-

-    if (((req->present&XkbKeyActionsMask)==0)||(req->nKeyActs==0)) {

-	req->present&= ~XkbKeyActionsMask;

-	req->firstKeyAct= req->nKeyActs= 0;

-	req->totalActs= 0;

-	return 0;

-    }

-    for (nActs=i=0;i<req->nKeyActs;i++) {

-	if (xkb->server->key_acts[i+req->firstKeyAct]!=0)

-	    nActs+= XkbKeyNumActions(xkb,i+req->firstKeyAct);

-    }

-    len= XkbPaddedSize(req->nKeyActs)+(nActs*SIZEOF(xkbActionWireDesc));

-    req->totalActs= nActs;

-    return len;

-}

-

-static void

-_XkbWriteKeyActions(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-    register int	 i;

-    int	 		 n;

-    CARD8		*numDesc;

-    XkbAction		*actDesc;

-

-    if ((req->present&XkbKeyActionsMask)==0)

-	return;

-    n = XkbPaddedSize(req->nKeyActs);

-    n+= (req->totalActs*SIZEOF(xkbActionWireDesc));

-

-    BufAlloc(CARD8 *,numDesc,n);

-    for (i=0;i<req->nKeyActs;i++) {

-	if (xkb->server->key_acts[i+req->firstKeyAct]==0)

-	     numDesc[i] = 0;

-	else numDesc[i] = XkbKeyNumActions(xkb,(i+req->firstKeyAct));

-    }

-    actDesc = (XkbAction *)&numDesc[XkbPaddedSize(req->nKeyActs)];

-    for (i=0;i<req->nKeyActs;i++) {

-	if (xkb->server->key_acts[i+req->firstKeyAct]!=0) {

-	    n = XkbKeyNumActions(xkb,(i+req->firstKeyAct));

-	    memcpy(actDesc,XkbKeyActionsPtr(xkb,(i+req->firstKeyAct)),

-                                                   n*SIZEOF(xkbActionWireDesc));

-	    actDesc+= n;

-	}

-    }

-    return;

-}

-

-static int

-_XkbSizeKeyBehaviors(XkbDescPtr	xkb,xkbSetMapReq *req)

-{

-register int i,first,last,nFound;

-

-    if (((req->present&XkbKeyBehaviorsMask)==0)||(req->nKeyBehaviors<1)) {

-	req->present&= ~XkbKeyBehaviorsMask;

-	req->firstKeyBehavior= req->nKeyBehaviors= 0;

-	req->totalKeyBehaviors= 0;

-	return 0;

-    }

-    first= req->firstKeyBehavior;

-    last= first+req->nKeyBehaviors-1;

-    for (i=first,nFound=0;i<=last;i++) {

-	if (xkb->server->behaviors[i].type!=XkbKB_Default)

-	    nFound++;

-    }

-    req->totalKeyBehaviors= nFound;

-    return (nFound*SIZEOF(xkbBehaviorWireDesc));

-}

-

-static void

-_XkbWriteKeyBehaviors(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int 		i,first,last;

-xkbBehaviorWireDesc *	wire;

-char *			buf;

-

-    if ((req->present&XkbKeyBehaviorsMask)==0)

-	return;

-    first= req->firstKeyBehavior;

-    last= first+req->nKeyBehaviors-1;

-

-    i= req->totalKeyBehaviors*SIZEOF(xkbBehaviorWireDesc);

-    BufAlloc(char *,buf,i);

-    wire= (xkbBehaviorWireDesc *)buf;

-    for (i=first;i<=last;i++) {

-	if (xkb->server->behaviors[i].type!=XkbKB_Default) {

-	    wire->key= i;

-	    wire->type= xkb->server->behaviors[i].type;

-	    wire->data= xkb->server->behaviors[i].data;

-	    buf+= SIZEOF(xkbBehaviorWireDesc);

-	    wire= (xkbBehaviorWireDesc *)buf;

-	}

-    }

-    return;

-}

-

-static unsigned

-_XkbSizeVirtualMods(xkbSetMapReq *req)

-{

-register int i,bit,nMods;

-

-   if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0)) {

-	req->present&= ~XkbVirtualModsMask;

-	req->virtualMods= 0;

-	return 0;

-   }

-   for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {

-	if (req->virtualMods&bit)

-	    nMods++;

-   }

-   return XkbPaddedSize(nMods);

-}

-

-static void

-_XkbWriteVirtualMods(	Display *	dpy,

-			XkbDescPtr 	xkb,

-			xkbSetMapReq *	req,

-			unsigned 	size)

-{

-    register int	 i,bit;

-    CARD8		*vmods;

-

-    /* This was req->present&XkbVirtualModsMask==0, and '==' beats '&' */

-    if (((req->present & XkbVirtualModsMask) == 0) || (size < 1))

-	return;

-    BufAlloc(CARD8 *,vmods,size);

-    for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {

-	if (req->virtualMods&bit)

-	    *vmods++= xkb->server->vmods[i];

-    }

-    return;

-}

-

-static int

-_XkbSizeKeyExplicit(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int i,first,last,nFound;

-

-    if (((req->present&XkbExplicitComponentsMask)==0)||(req->nKeyExplicit==0)) {

-	req->present&= ~XkbExplicitComponentsMask;

-	req->firstKeyExplicit= req->nKeyExplicit= 0;

-	req->totalKeyExplicit= 0;

-	return 0;

-    }

-    first= req->firstKeyExplicit;

-    last= first+req->nKeyExplicit-1;

-

-    for (i=first,nFound=0;i<=last;i++) {

-	if (xkb->server->explicit[i]!=0)

-	    nFound++;

-    }

-    req->totalKeyExplicit= nFound;

-    return XkbPaddedSize((nFound*2));

-}

-

-static void

-_XkbWriteKeyExplicit(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int	i,first,last;

-CARD8 *		wire;

-

-    if ((req->present&XkbExplicitComponentsMask)==0)

-	return;

-    first= req->firstKeyExplicit;

-    last= first+req->nKeyExplicit - 1;

-    i= XkbPaddedSize((req->totalKeyExplicit*2));

-    BufAlloc(CARD8 *,wire,i);

-    for (i=first;i<=last;i++) {

-	if (xkb->server->explicit[i]!=0) {

-	    wire[0]= i;

-	    wire[1]= xkb->server->explicit[i];

-	    wire+= 2;

-	}

-    }

-    return;

-}

-

-static int

-_XkbSizeModifierMap(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int i,first,last,nFound;

-

-    if (((req->present&XkbModifierMapMask)==0)||(req->nModMapKeys==0)) {

-	req->present&= ~XkbModifierMapMask;

-	req->firstModMapKey= req->nModMapKeys= 0;

-	req->totalModMapKeys= 0;

-	return 0;

-    }

-    first= req->firstModMapKey;

-    last= first+req->nModMapKeys-1;

-

-    for (i=first,nFound=0;i<=last;i++) {

-	if (xkb->map->modmap[i]!=0)

-	    nFound++;

-    }

-    req->totalModMapKeys= nFound;

-    return XkbPaddedSize((nFound*2));

-}

-

-static void

-_XkbWriteModifierMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int	i,first,last;

-CARD8 *		wire;

-

-    if ((req->present&XkbModifierMapMask)==0)

-	return;

-    first= req->firstModMapKey;

-    last= first+req->nModMapKeys-1;

-    if (req->totalModMapKeys>0) {

-	i= XkbPaddedSize((req->totalModMapKeys*2));

-	BufAlloc(CARD8 *,wire,i);

-	for (i=first;i<=last;i++) {

-	    if (xkb->map->modmap[i]!=0) {

-		wire[0]= i;

-		wire[1]= xkb->map->modmap[i];

-		wire+= 2;

-	    }

-	}

-    }

-    return;

-}

-

-static int

-_XkbSizeVirtualModMap(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int i,first,last,nFound;

-

-    if (((req->present&XkbVirtualModMapMask)==0)||(req->nVModMapKeys==0)) {

-	req->present&= ~XkbVirtualModMapMask;

-	req->firstVModMapKey= req->nVModMapKeys= 0;

-	req->totalVModMapKeys= 0;

-	return 0;

-    }

-    first= req->firstVModMapKey;

-    last= first+req->nVModMapKeys-1;

-

-    for (i=first,nFound=0;i<=last;i++) {

-	if (xkb->server->vmodmap[i]!=0)

-	    nFound++;

-    }

-    req->totalVModMapKeys= nFound;

-    return nFound*SIZEOF(xkbVModMapWireDesc);

-}

-

-static void

-_XkbWriteVirtualModMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int		i,first,last;

-xkbVModMapWireDesc *	wire;

-

-    if ((req->present&XkbVirtualModMapMask)==0)

-	return;

-    first= req->firstVModMapKey;

-    last= first+req->nVModMapKeys-1;

-    if (req->totalVModMapKeys>0) {

-	i= req->totalVModMapKeys*SIZEOF(xkbVModMapWireDesc);

-	BufAlloc(xkbVModMapWireDesc *,wire,i);

-	for (i=first;i<=last;i++) {

-	    if (xkb->server->vmodmap[i]!=0) {

-		wire->key= i;

-		wire->vmods= xkb->server->vmodmap[i];

-		wire++;

-	    }

-	}

-    }

-    return;

-}

-

-static void

-SendSetMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-xkbSetMapReq tmp;

-unsigned szMods;

-

-    req->length+= _XkbSizeKeyTypes(xkb,req)/4;

-    req->length+= _XkbSizeKeySyms(xkb,req)/4;

-    req->length+= _XkbSizeKeyActions(xkb,req)/4;

-    req->length+= _XkbSizeKeyBehaviors(xkb,req)/4;

-    szMods= _XkbSizeVirtualMods(req);

-    req->length+= szMods/4;

-    req->length+= _XkbSizeKeyExplicit(xkb,req)/4;

-    req->length+= _XkbSizeModifierMap(xkb,req)/4;

-    req->length+= _XkbSizeVirtualModMap(xkb,req)/4;

-

-    tmp= *req;

-    if ( tmp.nTypes>0 )

-	_XkbWriteKeyTypes(dpy,xkb,&tmp);

-    if ( tmp.nKeySyms>0 )

-	_XkbWriteKeySyms(dpy,xkb,&tmp);

-    if ( tmp.nKeyActs )

-	_XkbWriteKeyActions(dpy,xkb,&tmp);

-    if ( tmp.totalKeyBehaviors>0 )

-	_XkbWriteKeyBehaviors(dpy,xkb,&tmp);

-    if ( tmp.virtualMods )

-	_XkbWriteVirtualMods(dpy,xkb,&tmp,szMods);

-    if ( tmp.totalKeyExplicit>0)

-	_XkbWriteKeyExplicit(dpy,xkb,&tmp);

-    if ( tmp.totalModMapKeys>0)

-	_XkbWriteModifierMap(dpy,xkb,&tmp);

-    if ( tmp.totalVModMapKeys>0)

-	_XkbWriteVirtualModMap(dpy,xkb,&tmp);

-    return;

-}

-

-Bool

-XkbSetMap(Display *dpy,unsigned which,XkbDescPtr xkb)

-{

-register xkbSetMapReq *	req;

-XkbInfoPtr 		xkbi;

-XkbServerMapPtr		srv;

-XkbClientMapPtr		map;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||

-	(!xkb))

-	return False;

-    map= xkb->map;

-    srv= xkb->server;

-

-    if (((which&XkbKeyTypesMask)&&((!map)||(!map->types)))||

-	((which&XkbKeySymsMask)&&((!map)||(!map->syms)||(!map->key_sym_map)))||

-	((which&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||

-	((which&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||

-	((which&XkbVirtualModsMask)&&(!srv))||

-	((which&XkbExplicitComponentsMask)&&((!srv)||(!srv->explicit)))||

-	((which&XkbModifierMapMask)&&((!map)||(!map->modmap)))||

-	((which&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))

-	return False;

-

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetMap, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbSetMap;

-    req->deviceSpec = xkb->device_spec;

-    req->present = which;

-    req->flags = XkbSetMapAllFlags;

-    req->minKeyCode= xkb->min_key_code;

-    req->maxKeyCode= xkb->max_key_code;

-    req->firstType = 0;

-    if (which&XkbKeyTypesMask)	req->nTypes = map->num_types;

-    else			req->nTypes = 0;

-    if (which&XkbKeySymsMask) {

-	req->firstKeySym = xkb->min_key_code;

-	req->nKeySyms = XkbNumKeys(xkb);

-    }

-    if (which&XkbKeyActionsMask) {

-	req->firstKeyAct = xkb->min_key_code;

-	req->nKeyActs = XkbNumKeys(xkb);

-    }

-    if (which&XkbKeyBehaviorsMask) {

-	req->firstKeyBehavior = xkb->min_key_code;

-	req->nKeyBehaviors = XkbNumKeys(xkb);

-    }

-    if (which&XkbVirtualModsMask)

-	req->virtualMods= ~0;

-    if (which&XkbExplicitComponentsMask) {

-	req->firstKeyExplicit= xkb->min_key_code;

-	req->nKeyExplicit = XkbNumKeys(xkb);

-    }

-    if (which&XkbModifierMapMask) {

-	req->firstModMapKey= xkb->min_key_code;

-	req->nModMapKeys = XkbNumKeys(xkb);

-    }

-    if (which&XkbVirtualModMapMask) {

-	req->firstVModMapKey= xkb->min_key_code;

-	req->nVModMapKeys = XkbNumKeys(xkb);

-    }

-    SendSetMap(dpy,xkb,req);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbChangeMap(Display *dpy,XkbDescPtr xkb,XkbMapChangesPtr changes)

-{

-register xkbSetMapReq *	req;

-XkbInfoPtr 		xkbi;

-XkbServerMapPtr		srv;

-XkbClientMapPtr		map;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||

-	(!xkb)||(!changes))

-	return False;

-    srv= xkb->server;

-    map= xkb->map;

-

-    if (((changes->changed&XkbKeyTypesMask)&&((!map)||(!map->types)))||

-	((changes->changed&XkbKeySymsMask)&&((!map)||(!map->syms)||

-				(!map->key_sym_map)))||

-	((changes->changed&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||

-	((changes->changed&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||

-	((changes->changed&XkbVirtualModsMask)&&(!srv))||

-	((changes->changed&XkbExplicitComponentsMask)&&

-				((!srv)||(!srv->explicit)))||

-	((changes->changed&XkbModifierMapMask)&&((!map)||(!map->modmap)))||

-	((changes->changed&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))

-	return False;

-

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetMap, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbSetMap;

-    req->deviceSpec = xkb->device_spec;

-    req->present = changes->changed;

-    req->flags = XkbSetMapRecomputeActions;

-    req->minKeyCode= xkb->min_key_code;

-    req->maxKeyCode= xkb->max_key_code;

-    req->firstType = changes->first_type;

-    req->nTypes = changes->num_types;

-    req->firstKeySym = changes->first_key_sym;

-    req->nKeySyms = changes->num_key_syms;

-    req->firstKeyAct = changes->first_key_act;

-    req->nKeyActs = changes->num_key_acts;

-    req->firstKeyBehavior = changes->first_key_behavior;

-    req->nKeyBehaviors = changes->num_key_behaviors;

-    req->virtualMods = changes->vmods;

-    req->firstKeyExplicit = changes->first_key_explicit;

-    req->nKeyExplicit = changes->num_key_explicit;

-    req->firstModMapKey = changes->first_modmap_key;

-    req->nModMapKeys = changes->num_modmap_keys;

-    req->firstVModMapKey = changes->first_vmodmap_key;

-    req->nVModMapKeys = changes->num_vmodmap_keys;

-    SendSetMap(dpy,xkb,req);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+static int
+_XkbSizeKeyTypes(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+    XkbKeyTypePtr	map;
+    int			i,len;
+
+    if (((req->present&XkbKeyTypesMask)==0)||(req->nTypes==0)) {
+	req->present&= ~XkbKeyTypesMask;
+	req->firstType= req->nTypes= 0;
+	return 0;
+    }
+    len= 0;
+    map= &xkb->map->types[req->firstType];
+    for (i=0;i<req->nTypes;i++,map++){
+	len+= SIZEOF(xkbKeyTypeWireDesc);
+	len+= map->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);
+	if (map->preserve)
+	    len+= map->map_count*SIZEOF(xkbModsWireDesc);
+    }
+    return len;
+}
+
+static void
+_XkbWriteKeyTypes(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+    char *		buf;
+    XkbKeyTypePtr 	type;
+    int			i,n,sz;
+    xkbKeyTypeWireDesc *desc;
+
+    if ((req->present&XkbKeyTypesMask)==0)
+	return;
+    type= &xkb->map->types[req->firstType];
+    for (i=0;i<req->nTypes;i++,type++) {
+	sz= SIZEOF(xkbKeyTypeWireDesc);
+	sz+= type->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);
+	if (type->preserve)
+	    sz+= type->map_count*SIZEOF(xkbModsWireDesc);
+	BufAlloc(xkbKeyTypeWireDesc *,desc,sz);
+	desc->mask = type->mods.mask;
+	desc->realMods = type->mods.real_mods;
+	desc->virtualMods = type->mods.vmods;
+	desc->numLevels = type->num_levels;
+	desc->nMapEntries = type->map_count;
+	desc->preserve = (type->preserve!=NULL);
+	buf= (char *)&desc[1];
+	if (desc->nMapEntries>0) {
+	    xkbKTSetMapEntryWireDesc *wire;
+	    wire= (xkbKTSetMapEntryWireDesc *)buf;
+	    for (n=0;n<type->map_count;n++,wire++) {
+		wire->level= type->map[n].level;
+		wire->realMods= type->map[n].mods.real_mods;
+		wire->virtualMods= type->map[n].mods.vmods;
+	    }
+	    buf= (char *)wire;
+	    if (type->preserve) {
+		xkbModsWireDesc *pwire;
+		pwire= (xkbModsWireDesc *)buf;
+		for (n=0;n<type->map_count;n++,pwire++) {
+		    pwire->realMods= type->preserve[n].real_mods;
+		    pwire->virtualMods= type->preserve[n].vmods;
+		}
+	    }
+	}
+    }
+    return;
+}
+
+static int
+_XkbSizeKeySyms(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+    int			i,len;
+    unsigned		nSyms;
+
+    if (((req->present&XkbKeySymsMask)==0)||(req->nKeySyms==0)) {
+	req->present&= ~XkbKeySymsMask;
+	req->firstKeySym= req->nKeySyms= 0;
+	req->totalSyms= 0;
+	return 0;
+    }
+    len= (int)(req->nKeySyms*sizeof(XkbSymMapRec));
+    for (i=nSyms=0;i<req->nKeySyms;i++) {
+	nSyms+= XkbKeyNumSyms(xkb,i+req->firstKeySym);
+    }
+    len+= nSyms*sizeof(CARD32);
+    req->totalSyms= nSyms;
+    return len;
+}
+
+static void
+_XkbWriteKeySyms(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register KeySym *	pSym;
+CARD32 *		outSym;
+XkbSymMapPtr		symMap;
+xkbSymMapWireDesc *desc;
+register int	i;
+
+    if ((req->present&XkbKeySymsMask)==0)
+	return;
+    symMap = &xkb->map->key_sym_map[req->firstKeySym];
+    for (i=0;i<req->nKeySyms;i++,symMap++) {
+	BufAlloc(xkbSymMapWireDesc *,desc,
+		 SIZEOF(xkbSymMapWireDesc)+
+		 (XkbKeyNumSyms(xkb,i+req->firstKeySym)*sizeof(CARD32)));
+	desc->ktIndex[0] = symMap->kt_index[0];
+	desc->ktIndex[1] = symMap->kt_index[1];
+	desc->ktIndex[2] = symMap->kt_index[2];
+	desc->ktIndex[3] = symMap->kt_index[3];
+	desc->groupInfo = symMap->group_info;
+	desc->width = symMap->width;
+	desc->nSyms = XkbKeyNumSyms(xkb,i+req->firstKeySym);
+	outSym = (CARD32 *)&desc[1];
+	if (desc->nSyms>0) {
+	     pSym = XkbKeySymsPtr(xkb,i+req->firstKeySym);
+	    _XkbWriteCopyKeySyms(pSym,outSym,desc->nSyms);
+	}
+    }
+    return;
+}
+
+static int
+_XkbSizeKeyActions(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+    int			i,len,nActs;
+
+    if (((req->present&XkbKeyActionsMask)==0)||(req->nKeyActs==0)) {
+	req->present&= ~XkbKeyActionsMask;
+	req->firstKeyAct= req->nKeyActs= 0;
+	req->totalActs= 0;
+	return 0;
+    }
+    for (nActs=i=0;i<req->nKeyActs;i++) {
+	if (xkb->server->key_acts[i+req->firstKeyAct]!=0)
+	    nActs+= XkbKeyNumActions(xkb,i+req->firstKeyAct);
+    }
+    len= XkbPaddedSize(req->nKeyActs)+(nActs*SIZEOF(xkbActionWireDesc));
+    req->totalActs= nActs;
+    return len;
+}
+
+static void
+_XkbWriteKeyActions(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+    register int	 i;
+    int	 		 n;
+    CARD8		*numDesc;
+    XkbAction		*actDesc;
+
+    if ((req->present&XkbKeyActionsMask)==0)
+	return;
+    n = XkbPaddedSize(req->nKeyActs);
+    n+= (req->totalActs*SIZEOF(xkbActionWireDesc));
+
+    BufAlloc(CARD8 *,numDesc,n);
+    for (i=0;i<req->nKeyActs;i++) {
+	if (xkb->server->key_acts[i+req->firstKeyAct]==0)
+	     numDesc[i] = 0;
+	else numDesc[i] = XkbKeyNumActions(xkb,(i+req->firstKeyAct));
+    }
+    actDesc = (XkbAction *)&numDesc[XkbPaddedSize(req->nKeyActs)];
+    for (i=0;i<req->nKeyActs;i++) {
+	if (xkb->server->key_acts[i+req->firstKeyAct]!=0) {
+	    n = XkbKeyNumActions(xkb,(i+req->firstKeyAct));
+	    memcpy(actDesc,XkbKeyActionsPtr(xkb,(i+req->firstKeyAct)),
+                                                   n*SIZEOF(xkbActionWireDesc));
+	    actDesc+= n;
+	}
+    }
+    return;
+}
+
+static int
+_XkbSizeKeyBehaviors(XkbDescPtr	xkb,xkbSetMapReq *req)
+{
+register int i,first,last,nFound;
+
+    if (((req->present&XkbKeyBehaviorsMask)==0)||(req->nKeyBehaviors<1)) {
+	req->present&= ~XkbKeyBehaviorsMask;
+	req->firstKeyBehavior= req->nKeyBehaviors= 0;
+	req->totalKeyBehaviors= 0;
+	return 0;
+    }
+    first= req->firstKeyBehavior;
+    last= first+req->nKeyBehaviors-1;
+    for (i=first,nFound=0;i<=last;i++) {
+	if (xkb->server->behaviors[i].type!=XkbKB_Default)
+	    nFound++;
+    }
+    req->totalKeyBehaviors= nFound;
+    return (nFound*SIZEOF(xkbBehaviorWireDesc));
+}
+
+static void
+_XkbWriteKeyBehaviors(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int 		i,first,last;
+xkbBehaviorWireDesc *	wire;
+char *			buf;
+
+    if ((req->present&XkbKeyBehaviorsMask)==0)
+	return;
+    first= req->firstKeyBehavior;
+    last= first+req->nKeyBehaviors-1;
+
+    i= req->totalKeyBehaviors*SIZEOF(xkbBehaviorWireDesc);
+    BufAlloc(char *,buf,i);
+    wire= (xkbBehaviorWireDesc *)buf;
+    for (i=first;i<=last;i++) {
+	if (xkb->server->behaviors[i].type!=XkbKB_Default) {
+	    wire->key= i;
+	    wire->type= xkb->server->behaviors[i].type;
+	    wire->data= xkb->server->behaviors[i].data;
+	    buf+= SIZEOF(xkbBehaviorWireDesc);
+	    wire= (xkbBehaviorWireDesc *)buf;
+	}
+    }
+    return;
+}
+
+static unsigned
+_XkbSizeVirtualMods(xkbSetMapReq *req)
+{
+register int i,bit,nMods;
+
+   if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0)) {
+	req->present&= ~XkbVirtualModsMask;
+	req->virtualMods= 0;
+	return 0;
+   }
+   for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+	if (req->virtualMods&bit)
+	    nMods++;
+   }
+   return XkbPaddedSize(nMods);
+}
+
+static void
+_XkbWriteVirtualMods(	Display *	dpy,
+			XkbDescPtr 	xkb,
+			xkbSetMapReq *	req,
+			unsigned 	size)
+{
+    register int	 i,bit;
+    CARD8		*vmods;
+
+    /* This was req->present&XkbVirtualModsMask==0, and '==' beats '&' */
+    if (((req->present & XkbVirtualModsMask) == 0) || (size < 1))
+	return;
+    BufAlloc(CARD8 *,vmods,size);
+    for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+	if (req->virtualMods&bit)
+	    *vmods++= xkb->server->vmods[i];
+    }
+    return;
+}
+
+static int
+_XkbSizeKeyExplicit(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int i,first,last,nFound;
+
+    if (((req->present&XkbExplicitComponentsMask)==0)||(req->nKeyExplicit==0)) {
+	req->present&= ~XkbExplicitComponentsMask;
+	req->firstKeyExplicit= req->nKeyExplicit= 0;
+	req->totalKeyExplicit= 0;
+	return 0;
+    }
+    first= req->firstKeyExplicit;
+    last= first+req->nKeyExplicit-1;
+
+    for (i=first,nFound=0;i<=last;i++) {
+	if (xkb->server->explicit[i]!=0)
+	    nFound++;
+    }
+    req->totalKeyExplicit= nFound;
+    return XkbPaddedSize((nFound*2));
+}
+
+static void
+_XkbWriteKeyExplicit(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int	i,first,last;
+CARD8 *		wire;
+
+    if ((req->present&XkbExplicitComponentsMask)==0)
+	return;
+    first= req->firstKeyExplicit;
+    last= first+req->nKeyExplicit - 1;
+    i= XkbPaddedSize((req->totalKeyExplicit*2));
+    BufAlloc(CARD8 *,wire,i);
+    for (i=first;i<=last;i++) {
+	if (xkb->server->explicit[i]!=0) {
+	    wire[0]= i;
+	    wire[1]= xkb->server->explicit[i];
+	    wire+= 2;
+	}
+    }
+    return;
+}
+
+static int
+_XkbSizeModifierMap(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int i,first,last,nFound;
+
+    if (((req->present&XkbModifierMapMask)==0)||(req->nModMapKeys==0)) {
+	req->present&= ~XkbModifierMapMask;
+	req->firstModMapKey= req->nModMapKeys= 0;
+	req->totalModMapKeys= 0;
+	return 0;
+    }
+    first= req->firstModMapKey;
+    last= first+req->nModMapKeys-1;
+
+    for (i=first,nFound=0;i<=last;i++) {
+	if (xkb->map->modmap[i]!=0)
+	    nFound++;
+    }
+    req->totalModMapKeys= nFound;
+    return XkbPaddedSize((nFound*2));
+}
+
+static void
+_XkbWriteModifierMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int	i,first,last;
+CARD8 *		wire;
+
+    if ((req->present&XkbModifierMapMask)==0)
+	return;
+    first= req->firstModMapKey;
+    last= first+req->nModMapKeys-1;
+    if (req->totalModMapKeys>0) {
+	i= XkbPaddedSize((req->totalModMapKeys*2));
+	BufAlloc(CARD8 *,wire,i);
+	for (i=first;i<=last;i++) {
+	    if (xkb->map->modmap[i]!=0) {
+		wire[0]= i;
+		wire[1]= xkb->map->modmap[i];
+		wire+= 2;
+	    }
+	}
+    }
+    return;
+}
+
+static int
+_XkbSizeVirtualModMap(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int i,first,last,nFound;
+
+    if (((req->present&XkbVirtualModMapMask)==0)||(req->nVModMapKeys==0)) {
+	req->present&= ~XkbVirtualModMapMask;
+	req->firstVModMapKey= req->nVModMapKeys= 0;
+	req->totalVModMapKeys= 0;
+	return 0;
+    }
+    first= req->firstVModMapKey;
+    last= first+req->nVModMapKeys-1;
+
+    for (i=first,nFound=0;i<=last;i++) {
+	if (xkb->server->vmodmap[i]!=0)
+	    nFound++;
+    }
+    req->totalVModMapKeys= nFound;
+    return nFound*SIZEOF(xkbVModMapWireDesc);
+}
+
+static void
+_XkbWriteVirtualModMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int		i,first,last;
+xkbVModMapWireDesc *	wire;
+
+    if ((req->present&XkbVirtualModMapMask)==0)
+	return;
+    first= req->firstVModMapKey;
+    last= first+req->nVModMapKeys-1;
+    if (req->totalVModMapKeys>0) {
+	i= req->totalVModMapKeys*SIZEOF(xkbVModMapWireDesc);
+	BufAlloc(xkbVModMapWireDesc *,wire,i);
+	for (i=first;i<=last;i++) {
+	    if (xkb->server->vmodmap[i]!=0) {
+		wire->key= i;
+		wire->vmods= xkb->server->vmodmap[i];
+		wire++;
+	    }
+	}
+    }
+    return;
+}
+
+static void
+SendSetMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+xkbSetMapReq tmp;
+unsigned szMods;
+
+    req->length+= _XkbSizeKeyTypes(xkb,req)/4;
+    req->length+= _XkbSizeKeySyms(xkb,req)/4;
+    req->length+= _XkbSizeKeyActions(xkb,req)/4;
+    req->length+= _XkbSizeKeyBehaviors(xkb,req)/4;
+    szMods= _XkbSizeVirtualMods(req);
+    req->length+= szMods/4;
+    req->length+= _XkbSizeKeyExplicit(xkb,req)/4;
+    req->length+= _XkbSizeModifierMap(xkb,req)/4;
+    req->length+= _XkbSizeVirtualModMap(xkb,req)/4;
+
+    tmp= *req;
+    if ( tmp.nTypes>0 )
+	_XkbWriteKeyTypes(dpy,xkb,&tmp);
+    if ( tmp.nKeySyms>0 )
+	_XkbWriteKeySyms(dpy,xkb,&tmp);
+    if ( tmp.nKeyActs )
+	_XkbWriteKeyActions(dpy,xkb,&tmp);
+    if ( tmp.totalKeyBehaviors>0 )
+	_XkbWriteKeyBehaviors(dpy,xkb,&tmp);
+    if ( tmp.virtualMods )
+	_XkbWriteVirtualMods(dpy,xkb,&tmp,szMods);
+    if ( tmp.totalKeyExplicit>0)
+	_XkbWriteKeyExplicit(dpy,xkb,&tmp);
+    if ( tmp.totalModMapKeys>0)
+	_XkbWriteModifierMap(dpy,xkb,&tmp);
+    if ( tmp.totalVModMapKeys>0)
+	_XkbWriteVirtualModMap(dpy,xkb,&tmp);
+    return;
+}
+
+Bool
+XkbSetMap(Display *dpy,unsigned which,XkbDescPtr xkb)
+{
+register xkbSetMapReq *	req;
+XkbInfoPtr 		xkbi;
+XkbServerMapPtr		srv;
+XkbClientMapPtr		map;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
+	(!xkb))
+	return False;
+    map= xkb->map;
+    srv= xkb->server;
+
+    if (((which&XkbKeyTypesMask)&&((!map)||(!map->types)))||
+	((which&XkbKeySymsMask)&&((!map)||(!map->syms)||(!map->key_sym_map)))||
+	((which&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||
+	((which&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||
+	((which&XkbVirtualModsMask)&&(!srv))||
+	((which&XkbExplicitComponentsMask)&&((!srv)||(!srv->explicit)))||
+	((which&XkbModifierMapMask)&&((!map)||(!map->modmap)))||
+	((which&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))
+	return False;
+
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetMap, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSetMap;
+    req->deviceSpec = xkb->device_spec;
+    req->present = which;
+    req->flags = XkbSetMapAllFlags;
+    req->minKeyCode= xkb->min_key_code;
+    req->maxKeyCode= xkb->max_key_code;
+    req->firstType = 0;
+    if (which&XkbKeyTypesMask)	req->nTypes = map->num_types;
+    else			req->nTypes = 0;
+    if (which&XkbKeySymsMask) {
+	req->firstKeySym = xkb->min_key_code;
+	req->nKeySyms = XkbNumKeys(xkb);
+    }
+    if (which&XkbKeyActionsMask) {
+	req->firstKeyAct = xkb->min_key_code;
+	req->nKeyActs = XkbNumKeys(xkb);
+    }
+    if (which&XkbKeyBehaviorsMask) {
+	req->firstKeyBehavior = xkb->min_key_code;
+	req->nKeyBehaviors = XkbNumKeys(xkb);
+    }
+    if (which&XkbVirtualModsMask)
+	req->virtualMods= ~0;
+    if (which&XkbExplicitComponentsMask) {
+	req->firstKeyExplicit= xkb->min_key_code;
+	req->nKeyExplicit = XkbNumKeys(xkb);
+    }
+    if (which&XkbModifierMapMask) {
+	req->firstModMapKey= xkb->min_key_code;
+	req->nModMapKeys = XkbNumKeys(xkb);
+    }
+    if (which&XkbVirtualModMapMask) {
+	req->firstVModMapKey= xkb->min_key_code;
+	req->nVModMapKeys = XkbNumKeys(xkb);
+    }
+    SendSetMap(dpy,xkb,req);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbChangeMap(Display *dpy,XkbDescPtr xkb,XkbMapChangesPtr changes)
+{
+register xkbSetMapReq *	req;
+XkbInfoPtr 		xkbi;
+XkbServerMapPtr		srv;
+XkbClientMapPtr		map;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
+	(!xkb)||(!changes))
+	return False;
+    srv= xkb->server;
+    map= xkb->map;
+
+    if (((changes->changed&XkbKeyTypesMask)&&((!map)||(!map->types)))||
+	((changes->changed&XkbKeySymsMask)&&((!map)||(!map->syms)||
+				(!map->key_sym_map)))||
+	((changes->changed&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||
+	((changes->changed&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||
+	((changes->changed&XkbVirtualModsMask)&&(!srv))||
+	((changes->changed&XkbExplicitComponentsMask)&&
+				((!srv)||(!srv->explicit)))||
+	((changes->changed&XkbModifierMapMask)&&((!map)||(!map->modmap)))||
+	((changes->changed&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))
+	return False;
+
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetMap, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSetMap;
+    req->deviceSpec = xkb->device_spec;
+    req->present = changes->changed;
+    req->flags = XkbSetMapRecomputeActions;
+    req->minKeyCode= xkb->min_key_code;
+    req->maxKeyCode= xkb->max_key_code;
+    req->firstType = changes->first_type;
+    req->nTypes = changes->num_types;
+    req->firstKeySym = changes->first_key_sym;
+    req->nKeySyms = changes->num_key_syms;
+    req->firstKeyAct = changes->first_key_act;
+    req->nKeyActs = changes->num_key_acts;
+    req->firstKeyBehavior = changes->first_key_behavior;
+    req->nKeyBehaviors = changes->num_key_behaviors;
+    req->virtualMods = changes->vmods;
+    req->firstKeyExplicit = changes->first_key_explicit;
+    req->nKeyExplicit = changes->num_key_explicit;
+    req->firstModMapKey = changes->first_modmap_key;
+    req->nModMapKeys = changes->num_modmap_keys;
+    req->firstVModMapKey = changes->first_vmodmap_key;
+    req->nVModMapKeys = changes->num_vmodmap_keys;
+    SendSetMap(dpy,xkb,req);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+