libX11 libXinerama mesa git update 1 Feb 2011

1 files changed, 767 insertions, 767 deletions

diff --git a/libX11/src/xkb/XKB.c b/libX11/src/xkb/XKB.c
index 43b3ef95a..f926cb997 100644
--- a/libX11/src/xkb/XKB.c
+++ b/libX11/src/xkb/XKB.c
@@ -1,767 +1,767 @@
-/************************************************************

-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"

-

-XkbInternAtomFunc	_XkbInternAtomFunc= XInternAtom;

-XkbGetAtomNameFunc	_XkbGetAtomNameFunc= XGetAtomName;

-

-Bool

-XkbQueryExtension(	Display *dpy,

-			int *	opcodeReturn,

-			int *	eventBaseReturn,

-			int *	errorBaseReturn,

-			int *	majorReturn,

-			int *	minorReturn)

-{

-    if (!XkbUseExtension(dpy,majorReturn,minorReturn))

-	return False;

-    if (opcodeReturn)

-	*opcodeReturn = dpy->xkb_info->codes->major_opcode;

-    if (eventBaseReturn)

-	*eventBaseReturn = dpy->xkb_info->codes->first_event;

-    if (errorBaseReturn)

-	*errorBaseReturn = dpy->xkb_info->codes->first_error;

-    if (majorReturn)

-	*majorReturn = dpy->xkb_info->srv_major;

-    if (minorReturn)

-	*minorReturn = dpy->xkb_info->srv_minor;

-    return True;

-}

-

-Bool

-XkbLibraryVersion(int *libMajorRtrn,int *libMinorRtrn)

-{

-int supported;

-

-    if (*libMajorRtrn != XkbMajorVersion) {

-	/* version 0.65 is (almost) compatible with 1.00 */

-	if ((XkbMajorVersion==1)&&(((*libMajorRtrn)==0)&&((*libMinorRtrn)==65)))

-	     supported= True;

-	else supported= False;

-    }

-    else {

-	supported = True;

-    }

-

-    *libMajorRtrn = XkbMajorVersion;

-    *libMinorRtrn = XkbMinorVersion;

-    return supported;

-}

-

-Bool

-XkbSelectEvents(	Display *	dpy,

-			unsigned int 	deviceSpec,

-			unsigned int 	affect,

-			unsigned int 	selectAll)

-{

-    register xkbSelectEventsReq *req;

-    XkbInfoPtr xkbi;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    xkbi->selected_events&= ~affect;

-    xkbi->selected_events|= (affect&selectAll);

-    GetReq(kbSelectEvents, req);

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

-    req->xkbReqType = X_kbSelectEvents;

-    req->deviceSpec = deviceSpec;

-    req->affectWhich = (CARD16)affect;

-    req->clear = affect&(~selectAll);

-    req->selectAll = affect&selectAll;

-    if (affect&XkbMapNotifyMask) {

-	req->affectMap= XkbAllMapComponentsMask;

-	/* the implicit support needs the client info */

-	/* even if the client itself doesn't want it */

-	if (selectAll&XkbMapNotifyMask)

-	     req->map= XkbAllMapEventsMask;

-	else req->map= XkbAllClientInfoMask;

-	if (selectAll&XkbMapNotifyMask)

-	     xkbi->selected_map_details= XkbAllMapEventsMask;

-	else xkbi->selected_map_details= 0;

-    }

-    if (affect&XkbNewKeyboardNotifyMask) {

-	if (selectAll&XkbNewKeyboardNotifyMask)

-	     xkbi->selected_nkn_details= XkbAllNewKeyboardEventsMask;

-	else xkbi->selected_nkn_details= 0;

-	if (!(xkbi->xlib_ctrls&XkbLC_IgnoreNewKeyboards)) {

-	    /* we want it, even if the client doesn't.  Don't mess */

-	    /* around with details -- ask for all of them and throw */

-	    /* away the ones we don't need */

-	    req->selectAll|= XkbNewKeyboardNotifyMask;

-	}

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbSelectEventDetails(	Display *		dpy,

-			unsigned 		deviceSpec,

-			unsigned 		eventType,

-			unsigned long int 	affect,

-			unsigned long int 	details)

-{

-    register xkbSelectEventsReq *req;

-    XkbInfoPtr xkbi;

-    int	     size = 0;

-    char     *out;

-    union {

-	CARD8	*c8;

-	CARD16	*c16;

-	CARD32	*c32;

-    } u;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    if (affect&details)	xkbi->selected_events|= (1<<eventType);

-    else		xkbi->selected_events&= ~(1<<eventType);

-    GetReq(kbSelectEvents, req);

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

-    req->xkbReqType = X_kbSelectEvents;

-    req->deviceSpec = deviceSpec;

-    req->clear= req->selectAll= 0;

-    if (eventType==XkbMapNotify) {

-	/* we need all of the client info, even if the application */

-	/* doesn't.   Make sure that we always request the stuff */

-	/* that the implicit support needs, and just filter out anything */

-	/* the client doesn't want later */

-	req->affectWhich = 0;

-	req->selectAll = 0;

-	req->clear = 0;

-	req->affectMap = (CARD16)affect;

-	req->map = (CARD16)details|(XkbAllClientInfoMask&affect);

-	req->affectWhich = XkbMapNotifyMask;

-	xkbi->selected_map_details&= ~affect;

-	xkbi->selected_map_details|=  (details&affect);

-    }

-    else {

-	req->affectMap = req->map = 0;

-	req->affectWhich= (1<<eventType);

-	switch (eventType) {

-	    case XkbNewKeyboardNotify:

-		xkbi->selected_nkn_details&= ~affect;

-		xkbi->selected_nkn_details|= (details&affect);

-		if (!(xkbi->xlib_ctrls&XkbLC_IgnoreNewKeyboards))

-		    details= (affect&XkbAllNewKeyboardEventsMask);

-	    case XkbStateNotify:

-	    case XkbNamesNotify:

-	    case XkbAccessXNotify:

-	    case XkbExtensionDeviceNotify:

-		size= 2;

-		req->length+= 1;

-		break;

-	    case XkbControlsNotify:

-	    case XkbIndicatorStateNotify:

-	    case XkbIndicatorMapNotify:

-		size= 4;

-		req->length+= 2;

-		break;

-	    case XkbBellNotify:

-	    case XkbActionMessage:

-	    case XkbCompatMapNotify:

-		size= 1;

-		req->length+= 1;

-		break;

-	}

-	BufAlloc(char *,out,(((size*2)+(unsigned)3)/4)*4);

-	u.c8= (CARD8 *)out;

-	if (size==2) {

-	    u.c16[0]= (CARD16)affect;

-	    u.c16[1]= (CARD16)details;

-	}

-	else if (size==4) {

-	    u.c32[0]= (CARD32)affect;

-	    u.c32[1]= (CARD32)details;

-	}

-	else {

-	    u.c8[0]= (CARD8)affect;

-	    u.c8[1]= (CARD8)details;

-	}

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbLockModifiers(	Display *	dpy,

-			unsigned int 	deviceSpec,

-			unsigned int 	affect,

-			unsigned int 	values)

-{

-    register xkbLatchLockStateReq *req;

-    XkbInfoPtr xkbi;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbLatchLockState, req);

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

-    req->xkbReqType = X_kbLatchLockState;

-    req->deviceSpec = deviceSpec;

-    req->affectModLocks= affect;

-    req->modLocks = values;

-    req->lockGroup = False;

-    req->groupLock = 0;

-

-    req->affectModLatches = req->modLatches = 0;

-    req->latchGroup = False;

-    req->groupLatch = 0;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbLatchModifiers(	Display *	dpy,

-			unsigned int	deviceSpec,

-			unsigned int	affect,

-			unsigned int	values)

-{

-    register xkbLatchLockStateReq *req;

-    XkbInfoPtr xkbi;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbLatchLockState, req);

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

-    req->xkbReqType = X_kbLatchLockState;

-    req->deviceSpec = deviceSpec;

-

-    req->affectModLatches= affect;

-    req->modLatches = values;

-    req->latchGroup = False;

-    req->groupLatch = 0;

-

-    req->affectModLocks = req->modLocks = 0;

-    req->lockGroup = False;

-    req->groupLock = 0;

-

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbLockGroup(Display *dpy,unsigned int deviceSpec,unsigned int group)

-{

-    register xkbLatchLockStateReq *req;

-    XkbInfoPtr xkbi;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbLatchLockState, req);

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

-    req->xkbReqType = X_kbLatchLockState;

-    req->deviceSpec = deviceSpec;

-    req->affectModLocks= 0;

-    req->modLocks = 0;

-    req->lockGroup = True;

-    req->groupLock = group;

-

-    req->affectModLatches = req->modLatches = 0;

-    req->latchGroup = False;

-    req->groupLatch = 0;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbLatchGroup(Display *dpy,unsigned int deviceSpec,unsigned int group)

-{

-    register xkbLatchLockStateReq *req;

-    XkbInfoPtr xkbi;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbLatchLockState, req);

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

-    req->xkbReqType = X_kbLatchLockState;

-    req->deviceSpec = deviceSpec;

-

-    req->affectModLatches= 0;

-    req->modLatches = 0;

-    req->latchGroup = True;

-    req->groupLatch = group;

-

-    req->affectModLocks = req->modLocks = 0;

-    req->lockGroup = False;

-    req->groupLock = 0;

-

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-unsigned

-XkbSetXlibControls(Display *dpy,unsigned affect,unsigned values)

-{

-    if (!dpy->xkb_info)

-	XkbUseExtension(dpy,NULL,NULL);

-    if (!dpy->xkb_info)

-	return 0;

-    affect&= XkbLC_AllControls;

-    dpy->xkb_info->xlib_ctrls&= ~affect;

-    dpy->xkb_info->xlib_ctrls|= (affect&values);

-    return dpy->xkb_info->xlib_ctrls;

-}

-

-unsigned

-XkbGetXlibControls(Display *dpy)

-{

-    if (!dpy->xkb_info)

-	XkbUseExtension(dpy,NULL,NULL);

-    if (!dpy->xkb_info)

-	return 0;

-    return dpy->xkb_info->xlib_ctrls;

-}

-

-unsigned int

-XkbXlibControlsImplemented(void)

-{

-#ifdef __sgi

-    return XkbLC_AllControls;

-#else

-    return XkbLC_AllControls&~XkbLC_AllComposeControls;

-#endif

-}

-

-Bool

-XkbSetDebuggingFlags(	Display *	dpy,

-			unsigned int 	mask,

-			unsigned int 	flags,

-			char *		msg,

-			unsigned int	ctrls_mask,

-			unsigned int	ctrls,

-			unsigned int *	rtrn_flags,

-			unsigned int *	rtrn_ctrls)

-{

-    register xkbSetDebuggingFlagsReq *req;

-    xkbSetDebuggingFlagsReply rep;

-    XkbInfoPtr xkbi;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetDebuggingFlags, req);

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

-    req->xkbReqType=	X_kbSetDebuggingFlags;

-    req->affectFlags=	mask;

-    req->flags= 	flags;

-    req->affectCtrls=	ctrls_mask;

-    req->ctrls= 	ctrls;

-

-    if (msg) {

-	char *out;

-	req->msgLength= (unsigned short)strlen(msg)+1;

-	req->length+= (req->msgLength+(unsigned)3)>>2;

-	BufAlloc(char *,out,((req->msgLength+(unsigned)3)/4)*4);

-	memcpy(out,msg,req->msgLength);

-    }

-    else req->msgLength= 0;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return False;

-    }

-    if (rtrn_flags)

-	*rtrn_flags= rep.currentFlags;

-    if (rtrn_ctrls)

-	*rtrn_ctrls= rep.currentCtrls;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbComputeEffectiveMap(	XkbDescPtr 	xkb,

-			XkbKeyTypePtr 	type,

-			unsigned char *	map_rtrn)

-{

-register int 		i;

-unsigned     		tmp;

-XkbKTMapEntryPtr	entry = NULL;

-

-    if ((!xkb)||(!type)||(!xkb->server))

-	return False;

-

-    if (type->mods.vmods!=0) {

-	if (!XkbVirtualModsToReal(xkb,type->mods.vmods,&tmp))

-	    return False;

-

-	type->mods.mask= tmp|type->mods.real_mods;

-	entry= type->map;

-	for (i=0;i<type->map_count;i++,entry++) {

-	    tmp= 0;

-	    if (entry->mods.vmods!=0) {

-		if (!XkbVirtualModsToReal(xkb,entry->mods.vmods,&tmp))

-		    return False;

-		if (tmp==0) {

-		    entry->active= False;

-		    continue;

-		}

-	    }

-	    entry->active= True;

-	    entry->mods.mask= (entry->mods.real_mods|tmp)&type->mods.mask;

-	}

-    }

-    else {

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

-    }

-    if (map_rtrn!=NULL) {

-	bzero(map_rtrn,type->mods.mask+1);

-	for (i=0;i<type->map_count;i++) {

-	    if (entry->active) {

-		map_rtrn[type->map[i].mods.mask]= type->map[i].level;

-	    }

-	}

-    }

-    return True;

-}

-

-Status

-XkbGetState(Display *dpy,unsigned deviceSpec,XkbStatePtr rtrn)

-{

-    register xkbGetStateReq	*req;

-    xkbGetStateReply rep;

-    XkbInfoPtr xkbi;

-

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

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

-	return BadAccess;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbGetState, req);

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

-    req->xkbReqType = X_kbGetState;

-    req->deviceSpec = deviceSpec;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return BadImplementation;

-    }

-    rtrn->mods= 		rep.mods;

-    rtrn->base_mods= 		rep.baseMods;

-    rtrn->latched_mods= 	rep.latchedMods;

-    rtrn->locked_mods= 		rep.lockedMods;

-    rtrn->group= 		rep.group;

-    rtrn->base_group= 		rep.baseGroup;

-    rtrn->latched_group= 	rep.latchedGroup;

-    rtrn->locked_group= 	rep.lockedGroup;

-    rtrn->compat_state= 	rep.compatState;

-    rtrn->grab_mods=		rep.grabMods;

-    rtrn->compat_grab_mods=	rep.compatGrabMods;

-    rtrn->lookup_mods=		rep.lookupMods;

-    rtrn->compat_lookup_mods=	rep.compatLookupMods;

-    rtrn->ptr_buttons=		rep.ptrBtnState;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return Success;

-}

-

-Bool

-XkbSetDetectableAutoRepeat(Display *dpy,Bool detectable,Bool *supported)

-{

-register xkbPerClientFlagsReq *	req;

-xkbPerClientFlagsReply 		rep;

-XkbInfoPtr 			xkbi;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbPerClientFlags, req);

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

-    req->xkbReqType = X_kbPerClientFlags;

-    req->deviceSpec = XkbUseCoreKbd;

-    req->change = XkbPCF_DetectableAutoRepeatMask;

-    if (detectable)

-	 req->value = XkbPCF_DetectableAutoRepeatMask;

-    else req->value = 0;

-    req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return False;

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    if (supported!=NULL)

-	*supported= ((rep.supported&XkbPCF_DetectableAutoRepeatMask)!=0);

-    return ((rep.value&XkbPCF_DetectableAutoRepeatMask)!=0);

-}

-

-Bool

-XkbGetDetectableAutoRepeat(Display *dpy,Bool *supported)

-{

-register xkbPerClientFlagsReq *	req;

-xkbPerClientFlagsReply 		rep;

-XkbInfoPtr 			xkbi;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbPerClientFlags, req);

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

-    req->xkbReqType = X_kbPerClientFlags;

-    req->deviceSpec = XkbUseCoreKbd;

-    req->change = 0;

-    req->value = 0;

-    req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return False;

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    if (supported!=NULL)

-	*supported= ((rep.supported&XkbPCF_DetectableAutoRepeatMask)!=0);

-    return ((rep.value&XkbPCF_DetectableAutoRepeatMask)!=0);

-}

-

-Bool

-XkbSetAutoResetControls(	Display *	dpy,

-				unsigned 	changes,

-				unsigned *	auto_ctrls,

-				unsigned *	auto_values)

-{

-register xkbPerClientFlagsReq *	req;

-xkbPerClientFlagsReply 		rep;

-XkbInfoPtr 			xkbi;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbPerClientFlags, req);

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

-    req->xkbReqType = X_kbPerClientFlags;

-    req->change = XkbPCF_AutoResetControlsMask;

-    req->deviceSpec = XkbUseCoreKbd;

-    req->value = XkbPCF_AutoResetControlsMask;

-    req->ctrlsToChange= changes;

-    req->autoCtrls= *auto_ctrls;

-    req->autoCtrlValues= *auto_values;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return False;

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    *auto_ctrls= rep.autoCtrls;

-    *auto_values= rep.autoCtrlValues;

-    return ((rep.value&XkbPCF_AutoResetControlsMask)!=0);

-}

-

-Bool

-XkbGetAutoResetControls(	Display *	dpy,

-				unsigned *	auto_ctrls,

-				unsigned *	auto_ctrl_values)

-{

-register xkbPerClientFlagsReq *	req;

-xkbPerClientFlagsReply 		rep;

-XkbInfoPtr 			xkbi;

-

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

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

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbPerClientFlags, req);

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

-    req->xkbReqType = X_kbPerClientFlags;

-    req->deviceSpec = XkbUseCoreKbd;

-    req->change = 0;

-    req->value = 0;

-    req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return False;

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    if (auto_ctrls)

-	*auto_ctrls= rep.autoCtrls;

-    if (auto_ctrl_values)

-	*auto_ctrl_values= rep.autoCtrlValues;

-    return ((rep.value&XkbPCF_AutoResetControlsMask)!=0);

-}

-

-Bool

-XkbSetPerClientControls(	Display *	dpy,

-				unsigned 	change,

-				unsigned *	values)

-{

-register xkbPerClientFlagsReq *	req;

-xkbPerClientFlagsReply 		rep;

-XkbInfoPtr 			xkbi;

-unsigned			value_hold = *values;

-

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

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

-	(change & ~(XkbPCF_GrabsUseXKBStateMask|XkbPCF_LookupStateWhenGrabbed|XkbPCF_SendEventUsesXKBState)))

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbPerClientFlags, req);

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

-    req->xkbReqType = X_kbPerClientFlags;

-    req->change = change;

-    req->deviceSpec = XkbUseCoreKbd;

-    req->value = *values;

-    req->ctrlsToChange = req->autoCtrls = req->autoCtrlValues= 0;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return False;

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    *values = rep.value;

-    return ((rep.value&value_hold)!=0);

-}

-

-Bool

-XkbGetPerClientControls(	Display *	dpy,

-				unsigned *	ctrls)

-{

-register xkbPerClientFlagsReq *	req;

-xkbPerClientFlagsReply 		rep;

-XkbInfoPtr 			xkbi;

-

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

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

-	(*ctrls & ~(XkbPCF_GrabsUseXKBStateMask|XkbPCF_LookupStateWhenGrabbed|XkbPCF_SendEventUsesXKBState)))

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbPerClientFlags, req);

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

-    req->xkbReqType = X_kbPerClientFlags;

-    req->deviceSpec = XkbUseCoreKbd;

-    req->change = 0;

-    req->value = 0;

-    req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return False;

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    if (ctrls)

-	*ctrls= (rep.value & (XkbPCF_GrabsUseXKBStateMask |

-		 XkbPCF_LookupStateWhenGrabbed |

-		 XkbPCF_SendEventUsesXKBState));

-    return (True);

-}

-

-Display *

-XkbOpenDisplay(	char *	name,

-		int *	ev_rtrn,

-		int *	err_rtrn,

-		int *	major_rtrn,

-		int *	minor_rtrn,

-		int *	reason)

-{

-    Display* dpy;

-    int	 major_num,minor_num;

-

-    if ((major_rtrn!=NULL) && (minor_rtrn!=NULL)) {

-	if (!XkbLibraryVersion(major_rtrn,minor_rtrn)) {

-	    if (reason!=NULL)

-		*reason= XkbOD_BadLibraryVersion;

-	    return NULL;

-	}

-    }

-    else {

-	major_num= XkbMajorVersion;

-	minor_num= XkbMinorVersion;

-	major_rtrn= &major_num;

-	minor_rtrn= &minor_num;

-    }

-    dpy= XOpenDisplay(name);

-    if (dpy==NULL) {

-	if (reason!=NULL)

-	    *reason= XkbOD_ConnectionRefused;

-	return NULL;

-    }

-    if (!XkbQueryExtension(dpy,NULL,ev_rtrn,err_rtrn,major_rtrn,minor_rtrn)) {

-	if (reason!=NULL) {

-	    if ((*major_rtrn!=0)||(*minor_rtrn!=0))

-		 *reason= XkbOD_BadServerVersion;

-	    else *reason= XkbOD_NonXkbServer;

-	}

-	XCloseDisplay(dpy);

-	return NULL;

-    }

-    if (reason!=NULL)

-	*reason= XkbOD_Success;

-    return dpy;

-}

-

-void

-XkbSetAtomFuncs(XkbInternAtomFunc getAtom,XkbGetAtomNameFunc getName)

-{

-    _XkbInternAtomFunc= (getAtom?getAtom:XInternAtom);

-    _XkbGetAtomNameFunc= (getName?getName:XGetAtomName);

-    return;

-}

+/************************************************************
+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"
+
+XkbInternAtomFunc	_XkbInternAtomFunc= XInternAtom;
+XkbGetAtomNameFunc	_XkbGetAtomNameFunc= XGetAtomName;
+
+Bool
+XkbQueryExtension(	Display *dpy,
+			int *	opcodeReturn,
+			int *	eventBaseReturn,
+			int *	errorBaseReturn,
+			int *	majorReturn,
+			int *	minorReturn)
+{
+    if (!XkbUseExtension(dpy,majorReturn,minorReturn))
+	return False;
+    if (opcodeReturn)
+	*opcodeReturn = dpy->xkb_info->codes->major_opcode;
+    if (eventBaseReturn)
+	*eventBaseReturn = dpy->xkb_info->codes->first_event;
+    if (errorBaseReturn)
+	*errorBaseReturn = dpy->xkb_info->codes->first_error;
+    if (majorReturn)
+	*majorReturn = dpy->xkb_info->srv_major;
+    if (minorReturn)
+	*minorReturn = dpy->xkb_info->srv_minor;
+    return True;
+}
+
+Bool
+XkbLibraryVersion(int *libMajorRtrn,int *libMinorRtrn)
+{
+int supported;
+
+    if (*libMajorRtrn != XkbMajorVersion) {
+	/* version 0.65 is (almost) compatible with 1.00 */
+	if ((XkbMajorVersion==1)&&(((*libMajorRtrn)==0)&&((*libMinorRtrn)==65)))
+	     supported= True;
+	else supported= False;
+    }
+    else {
+	supported = True;
+    }
+
+    *libMajorRtrn = XkbMajorVersion;
+    *libMinorRtrn = XkbMinorVersion;
+    return supported;
+}
+
+Bool
+XkbSelectEvents(	Display *	dpy,
+			unsigned int 	deviceSpec,
+			unsigned int 	affect,
+			unsigned int 	selectAll)
+{
+    register xkbSelectEventsReq *req;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    xkbi->selected_events&= ~affect;
+    xkbi->selected_events|= (affect&selectAll);
+    GetReq(kbSelectEvents, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSelectEvents;
+    req->deviceSpec = deviceSpec;
+    req->affectWhich = (CARD16)affect;
+    req->clear = affect&(~selectAll);
+    req->selectAll = affect&selectAll;
+    if (affect&XkbMapNotifyMask) {
+	req->affectMap= XkbAllMapComponentsMask;
+	/* the implicit support needs the client info */
+	/* even if the client itself doesn't want it */
+	if (selectAll&XkbMapNotifyMask)
+	     req->map= XkbAllMapEventsMask;
+	else req->map= XkbAllClientInfoMask;
+	if (selectAll&XkbMapNotifyMask)
+	     xkbi->selected_map_details= XkbAllMapEventsMask;
+	else xkbi->selected_map_details= 0;
+    }
+    if (affect&XkbNewKeyboardNotifyMask) {
+	if (selectAll&XkbNewKeyboardNotifyMask)
+	     xkbi->selected_nkn_details= XkbAllNewKeyboardEventsMask;
+	else xkbi->selected_nkn_details= 0;
+	if (!(xkbi->xlib_ctrls&XkbLC_IgnoreNewKeyboards)) {
+	    /* we want it, even if the client doesn't.  Don't mess */
+	    /* around with details -- ask for all of them and throw */
+	    /* away the ones we don't need */
+	    req->selectAll|= XkbNewKeyboardNotifyMask;
+	}
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbSelectEventDetails(	Display *		dpy,
+			unsigned 		deviceSpec,
+			unsigned 		eventType,
+			unsigned long int 	affect,
+			unsigned long int 	details)
+{
+    register xkbSelectEventsReq *req;
+    XkbInfoPtr xkbi;
+    int	     size = 0;
+    char     *out;
+    union {
+	CARD8	*c8;
+	CARD16	*c16;
+	CARD32	*c32;
+    } u;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    if (affect&details)	xkbi->selected_events|= (1<<eventType);
+    else		xkbi->selected_events&= ~(1<<eventType);
+    GetReq(kbSelectEvents, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSelectEvents;
+    req->deviceSpec = deviceSpec;
+    req->clear= req->selectAll= 0;
+    if (eventType==XkbMapNotify) {
+	/* we need all of the client info, even if the application */
+	/* doesn't.   Make sure that we always request the stuff */
+	/* that the implicit support needs, and just filter out anything */
+	/* the client doesn't want later */
+	req->affectWhich = 0;
+	req->selectAll = 0;
+	req->clear = 0;
+	req->affectMap = (CARD16)affect;
+	req->map = (CARD16)details|(XkbAllClientInfoMask&affect);
+	req->affectWhich = XkbMapNotifyMask;
+	xkbi->selected_map_details&= ~affect;
+	xkbi->selected_map_details|=  (details&affect);
+    }
+    else {
+	req->affectMap = req->map = 0;
+	req->affectWhich= (1<<eventType);
+	switch (eventType) {
+	    case XkbNewKeyboardNotify:
+		xkbi->selected_nkn_details&= ~affect;
+		xkbi->selected_nkn_details|= (details&affect);
+		if (!(xkbi->xlib_ctrls&XkbLC_IgnoreNewKeyboards))
+		    details= (affect&XkbAllNewKeyboardEventsMask);
+	    case XkbStateNotify:
+	    case XkbNamesNotify:
+	    case XkbAccessXNotify:
+	    case XkbExtensionDeviceNotify:
+		size= 2;
+		req->length+= 1;
+		break;
+	    case XkbControlsNotify:
+	    case XkbIndicatorStateNotify:
+	    case XkbIndicatorMapNotify:
+		size= 4;
+		req->length+= 2;
+		break;
+	    case XkbBellNotify:
+	    case XkbActionMessage:
+	    case XkbCompatMapNotify:
+		size= 1;
+		req->length+= 1;
+		break;
+	}
+	BufAlloc(char *,out,(((size*2)+(unsigned)3)/4)*4);
+	u.c8= (CARD8 *)out;
+	if (size==2) {
+	    u.c16[0]= (CARD16)affect;
+	    u.c16[1]= (CARD16)details;
+	}
+	else if (size==4) {
+	    u.c32[0]= (CARD32)affect;
+	    u.c32[1]= (CARD32)details;
+	}
+	else {
+	    u.c8[0]= (CARD8)affect;
+	    u.c8[1]= (CARD8)details;
+	}
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbLockModifiers(	Display *	dpy,
+			unsigned int 	deviceSpec,
+			unsigned int 	affect,
+			unsigned int 	values)
+{
+    register xkbLatchLockStateReq *req;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbLatchLockState, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbLatchLockState;
+    req->deviceSpec = deviceSpec;
+    req->affectModLocks= affect;
+    req->modLocks = values;
+    req->lockGroup = False;
+    req->groupLock = 0;
+
+    req->affectModLatches = req->modLatches = 0;
+    req->latchGroup = False;
+    req->groupLatch = 0;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbLatchModifiers(	Display *	dpy,
+			unsigned int	deviceSpec,
+			unsigned int	affect,
+			unsigned int	values)
+{
+    register xkbLatchLockStateReq *req;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbLatchLockState, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbLatchLockState;
+    req->deviceSpec = deviceSpec;
+
+    req->affectModLatches= affect;
+    req->modLatches = values;
+    req->latchGroup = False;
+    req->groupLatch = 0;
+
+    req->affectModLocks = req->modLocks = 0;
+    req->lockGroup = False;
+    req->groupLock = 0;
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbLockGroup(Display *dpy,unsigned int deviceSpec,unsigned int group)
+{
+    register xkbLatchLockStateReq *req;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbLatchLockState, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbLatchLockState;
+    req->deviceSpec = deviceSpec;
+    req->affectModLocks= 0;
+    req->modLocks = 0;
+    req->lockGroup = True;
+    req->groupLock = group;
+
+    req->affectModLatches = req->modLatches = 0;
+    req->latchGroup = False;
+    req->groupLatch = 0;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbLatchGroup(Display *dpy,unsigned int deviceSpec,unsigned int group)
+{
+    register xkbLatchLockStateReq *req;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbLatchLockState, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbLatchLockState;
+    req->deviceSpec = deviceSpec;
+
+    req->affectModLatches= 0;
+    req->modLatches = 0;
+    req->latchGroup = True;
+    req->groupLatch = group;
+
+    req->affectModLocks = req->modLocks = 0;
+    req->lockGroup = False;
+    req->groupLock = 0;
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+unsigned
+XkbSetXlibControls(Display *dpy,unsigned affect,unsigned values)
+{
+    if (!dpy->xkb_info)
+	XkbUseExtension(dpy,NULL,NULL);
+    if (!dpy->xkb_info)
+	return 0;
+    affect&= XkbLC_AllControls;
+    dpy->xkb_info->xlib_ctrls&= ~affect;
+    dpy->xkb_info->xlib_ctrls|= (affect&values);
+    return dpy->xkb_info->xlib_ctrls;
+}
+
+unsigned
+XkbGetXlibControls(Display *dpy)
+{
+    if (!dpy->xkb_info)
+	XkbUseExtension(dpy,NULL,NULL);
+    if (!dpy->xkb_info)
+	return 0;
+    return dpy->xkb_info->xlib_ctrls;
+}
+
+unsigned int
+XkbXlibControlsImplemented(void)
+{
+#ifdef __sgi
+    return XkbLC_AllControls;
+#else
+    return XkbLC_AllControls&~XkbLC_AllComposeControls;
+#endif
+}
+
+Bool
+XkbSetDebuggingFlags(	Display *	dpy,
+			unsigned int 	mask,
+			unsigned int 	flags,
+			char *		msg,
+			unsigned int	ctrls_mask,
+			unsigned int	ctrls,
+			unsigned int *	rtrn_flags,
+			unsigned int *	rtrn_ctrls)
+{
+    register xkbSetDebuggingFlagsReq *req;
+    xkbSetDebuggingFlagsReply rep;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetDebuggingFlags, req);
+    req->reqType= 	xkbi->codes->major_opcode;
+    req->xkbReqType=	X_kbSetDebuggingFlags;
+    req->affectFlags=	mask;
+    req->flags= 	flags;
+    req->affectCtrls=	ctrls_mask;
+    req->ctrls= 	ctrls;
+
+    if (msg) {
+	char *out;
+	req->msgLength= (unsigned short)strlen(msg)+1;
+	req->length+= (req->msgLength+(unsigned)3)>>2;
+	BufAlloc(char *,out,((req->msgLength+(unsigned)3)/4)*4);
+	memcpy(out,msg,req->msgLength);
+    }
+    else req->msgLength= 0;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    if (rtrn_flags)
+	*rtrn_flags= rep.currentFlags;
+    if (rtrn_ctrls)
+	*rtrn_ctrls= rep.currentCtrls;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbComputeEffectiveMap(	XkbDescPtr 	xkb,
+			XkbKeyTypePtr 	type,
+			unsigned char *	map_rtrn)
+{
+register int 		i;
+unsigned     		tmp;
+XkbKTMapEntryPtr	entry = NULL;
+
+    if ((!xkb)||(!type)||(!xkb->server))
+	return False;
+
+    if (type->mods.vmods!=0) {
+	if (!XkbVirtualModsToReal(xkb,type->mods.vmods,&tmp))
+	    return False;
+
+	type->mods.mask= tmp|type->mods.real_mods;
+	entry= type->map;
+	for (i=0;i<type->map_count;i++,entry++) {
+	    tmp= 0;
+	    if (entry->mods.vmods!=0) {
+		if (!XkbVirtualModsToReal(xkb,entry->mods.vmods,&tmp))
+		    return False;
+		if (tmp==0) {
+		    entry->active= False;
+		    continue;
+		}
+	    }
+	    entry->active= True;
+	    entry->mods.mask= (entry->mods.real_mods|tmp)&type->mods.mask;
+	}
+    }
+    else {
+	type->mods.mask= type->mods.real_mods;
+    }
+    if (map_rtrn!=NULL) {
+	bzero(map_rtrn,type->mods.mask+1);
+	for (i=0;i<type->map_count;i++) {
+	    if (entry && entry->active) {
+		map_rtrn[type->map[i].mods.mask]= type->map[i].level;
+	    }
+	}
+    }
+    return True;
+}
+
+Status
+XkbGetState(Display *dpy,unsigned deviceSpec,XkbStatePtr rtrn)
+{
+    register xkbGetStateReq	*req;
+    xkbGetStateReply rep;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbGetState, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbGetState;
+    req->deviceSpec = deviceSpec;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return BadImplementation;
+    }
+    rtrn->mods= 		rep.mods;
+    rtrn->base_mods= 		rep.baseMods;
+    rtrn->latched_mods= 	rep.latchedMods;
+    rtrn->locked_mods= 		rep.lockedMods;
+    rtrn->group= 		rep.group;
+    rtrn->base_group= 		rep.baseGroup;
+    rtrn->latched_group= 	rep.latchedGroup;
+    rtrn->locked_group= 	rep.lockedGroup;
+    rtrn->compat_state= 	rep.compatState;
+    rtrn->grab_mods=		rep.grabMods;
+    rtrn->compat_grab_mods=	rep.compatGrabMods;
+    rtrn->lookup_mods=		rep.lookupMods;
+    rtrn->compat_lookup_mods=	rep.compatLookupMods;
+    rtrn->ptr_buttons=		rep.ptrBtnState;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return Success;
+}
+
+Bool
+XkbSetDetectableAutoRepeat(Display *dpy,Bool detectable,Bool *supported)
+{
+register xkbPerClientFlagsReq *	req;
+xkbPerClientFlagsReply 		rep;
+XkbInfoPtr 			xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbPerClientFlags, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbPerClientFlags;
+    req->deviceSpec = XkbUseCoreKbd;
+    req->change = XkbPCF_DetectableAutoRepeatMask;
+    if (detectable)
+	 req->value = XkbPCF_DetectableAutoRepeatMask;
+    else req->value = 0;
+    req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (supported!=NULL)
+	*supported= ((rep.supported&XkbPCF_DetectableAutoRepeatMask)!=0);
+    return ((rep.value&XkbPCF_DetectableAutoRepeatMask)!=0);
+}
+
+Bool
+XkbGetDetectableAutoRepeat(Display *dpy,Bool *supported)
+{
+register xkbPerClientFlagsReq *	req;
+xkbPerClientFlagsReply 		rep;
+XkbInfoPtr 			xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbPerClientFlags, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbPerClientFlags;
+    req->deviceSpec = XkbUseCoreKbd;
+    req->change = 0;
+    req->value = 0;
+    req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (supported!=NULL)
+	*supported= ((rep.supported&XkbPCF_DetectableAutoRepeatMask)!=0);
+    return ((rep.value&XkbPCF_DetectableAutoRepeatMask)!=0);
+}
+
+Bool
+XkbSetAutoResetControls(	Display *	dpy,
+				unsigned 	changes,
+				unsigned *	auto_ctrls,
+				unsigned *	auto_values)
+{
+register xkbPerClientFlagsReq *	req;
+xkbPerClientFlagsReply 		rep;
+XkbInfoPtr 			xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbPerClientFlags, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbPerClientFlags;
+    req->change = XkbPCF_AutoResetControlsMask;
+    req->deviceSpec = XkbUseCoreKbd;
+    req->value = XkbPCF_AutoResetControlsMask;
+    req->ctrlsToChange= changes;
+    req->autoCtrls= *auto_ctrls;
+    req->autoCtrlValues= *auto_values;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    *auto_ctrls= rep.autoCtrls;
+    *auto_values= rep.autoCtrlValues;
+    return ((rep.value&XkbPCF_AutoResetControlsMask)!=0);
+}
+
+Bool
+XkbGetAutoResetControls(	Display *	dpy,
+				unsigned *	auto_ctrls,
+				unsigned *	auto_ctrl_values)
+{
+register xkbPerClientFlagsReq *	req;
+xkbPerClientFlagsReply 		rep;
+XkbInfoPtr 			xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbPerClientFlags, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbPerClientFlags;
+    req->deviceSpec = XkbUseCoreKbd;
+    req->change = 0;
+    req->value = 0;
+    req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (auto_ctrls)
+	*auto_ctrls= rep.autoCtrls;
+    if (auto_ctrl_values)
+	*auto_ctrl_values= rep.autoCtrlValues;
+    return ((rep.value&XkbPCF_AutoResetControlsMask)!=0);
+}
+
+Bool
+XkbSetPerClientControls(	Display *	dpy,
+				unsigned 	change,
+				unsigned *	values)
+{
+register xkbPerClientFlagsReq *	req;
+xkbPerClientFlagsReply 		rep;
+XkbInfoPtr 			xkbi;
+unsigned			value_hold = *values;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)) ||
+	(change & ~(XkbPCF_GrabsUseXKBStateMask|XkbPCF_LookupStateWhenGrabbed|XkbPCF_SendEventUsesXKBState)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbPerClientFlags, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbPerClientFlags;
+    req->change = change;
+    req->deviceSpec = XkbUseCoreKbd;
+    req->value = *values;
+    req->ctrlsToChange = req->autoCtrls = req->autoCtrlValues= 0;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    *values = rep.value;
+    return ((rep.value&value_hold)!=0);
+}
+
+Bool
+XkbGetPerClientControls(	Display *	dpy,
+				unsigned *	ctrls)
+{
+register xkbPerClientFlagsReq *	req;
+xkbPerClientFlagsReply 		rep;
+XkbInfoPtr 			xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)) ||
+	(*ctrls & ~(XkbPCF_GrabsUseXKBStateMask|XkbPCF_LookupStateWhenGrabbed|XkbPCF_SendEventUsesXKBState)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbPerClientFlags, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbPerClientFlags;
+    req->deviceSpec = XkbUseCoreKbd;
+    req->change = 0;
+    req->value = 0;
+    req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (ctrls)
+	*ctrls= (rep.value & (XkbPCF_GrabsUseXKBStateMask |
+		 XkbPCF_LookupStateWhenGrabbed |
+		 XkbPCF_SendEventUsesXKBState));
+    return (True);
+}
+
+Display *
+XkbOpenDisplay(	char *	name,
+		int *	ev_rtrn,
+		int *	err_rtrn,
+		int *	major_rtrn,
+		int *	minor_rtrn,
+		int *	reason)
+{
+    Display* dpy;
+    int	 major_num,minor_num;
+
+    if ((major_rtrn!=NULL) && (minor_rtrn!=NULL)) {
+	if (!XkbLibraryVersion(major_rtrn,minor_rtrn)) {
+	    if (reason!=NULL)
+		*reason= XkbOD_BadLibraryVersion;
+	    return NULL;
+	}
+    }
+    else {
+	major_num= XkbMajorVersion;
+	minor_num= XkbMinorVersion;
+	major_rtrn= &major_num;
+	minor_rtrn= &minor_num;
+    }
+    dpy= XOpenDisplay(name);
+    if (dpy==NULL) {
+	if (reason!=NULL)
+	    *reason= XkbOD_ConnectionRefused;
+	return NULL;
+    }
+    if (!XkbQueryExtension(dpy,NULL,ev_rtrn,err_rtrn,major_rtrn,minor_rtrn)) {
+	if (reason!=NULL) {
+	    if ((*major_rtrn!=0)||(*minor_rtrn!=0))
+		 *reason= XkbOD_BadServerVersion;
+	    else *reason= XkbOD_NonXkbServer;
+	}
+	XCloseDisplay(dpy);
+	return NULL;
+    }
+    if (reason!=NULL)
+	*reason= XkbOD_Success;
+    return dpy;
+}
+
+void
+XkbSetAtomFuncs(XkbInternAtomFunc getAtom,XkbGetAtomNameFunc getName)
+{
+    _XkbInternAtomFunc= (getAtom?getAtom:XInternAtom);
+    _XkbGetAtomNameFunc= (getName?getName:XGetAtomName);
+    return;
+}