/* $Xorg: XKB.c,v 1.3 2000/08/17 19:44:59 cpqbld Exp $ */
/************************************************************
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.

********************************************************/
/* $XFree86: xc/lib/X11/XKB.c,v 1.5 2001/02/20 16:43:14 paulo Exp $ */

#include <stdio.h>
#define NEED_REPLIES
#define NEED_EVENTS
#include "Xlibint.h"
#include <X11/extensions/XKBproto.h>
#include "XKBlibint.h"

XkbInternAtomFunc	_XkbInternAtomFunc= XInternAtom;
XkbGetAtomNameFunc	_XkbGetAtomNameFunc= XGetAtomName;

Bool 
#if NeedFunctionPrototypes
XkbQueryExtension(	Display *dpy,
			int *	opcodeReturn,
			int *	eventBaseReturn,
			int *	errorBaseReturn,
			int *	majorReturn,
			int *	minorReturn)
#else
XkbQueryExtension(dpy,opcodeReturn,eventBaseReturn,errorBaseReturn,
						majorReturn,minorReturn)
    Display *dpy;
    int *opcodeReturn;
    int *eventBaseReturn;
    int *errorBaseReturn;
    int *majorReturn;
    int *minorReturn;
#endif
{
    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 
#if NeedFunctionPrototypes
XkbLibraryVersion(int *libMajorRtrn,int *libMinorRtrn)
#else
XkbLibraryVersion(libMajorRtrn,libMinorRtrn)
    int *libMajorRtrn;
    int *libMinorRtrn;
#endif
{
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
#if NeedFunctionPrototypes
XkbSelectEvents(	Display *	dpy,
			unsigned int 	deviceSpec,
			unsigned int 	affect,
			unsigned int 	selectAll)
#else
XkbSelectEvents(dpy,deviceSpec,affect,selectAll)
    Display *dpy;
    unsigned int deviceSpec;
    unsigned int affect;
    unsigned int selectAll;
#endif
{
    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
#if NeedFunctionPrototypes
XkbSelectEventDetails(	Display *		dpy,
			unsigned 		deviceSpec,
			unsigned 		eventType,
			unsigned long int 	affect,
			unsigned long int 	details)
#else
XkbSelectEventDetails(dpy,deviceSpec,eventType,affect,details)
    Display *dpy;
    unsigned deviceSpec;
    unsigned eventType;
    unsigned long int affect;
    unsigned long int details;
#endif
{
    register xkbSelectEventsReq *req;
    XkbInfoPtr xkbi;
    int	     size;
    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
#if NeedFunctionPrototypes
XkbLockModifiers(	Display *	dpy,
			unsigned int 	deviceSpec,
			unsigned int 	affect,
			unsigned int 	values)
#else
XkbLockModifiers(dpy,deviceSpec,affect,values)
    Display *dpy;
    unsigned int deviceSpec;
    unsigned int affect;
    unsigned int values;
#endif
{
    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
#if NeedFunctionPrototypes
XkbLatchModifiers(	Display *	dpy,
			unsigned int	deviceSpec,
			unsigned int	affect,
			unsigned int	values)
#else
XkbLatchModifiers(dpy,deviceSpec,affect,values)
    Display *dpy;
    unsigned int deviceSpec;
    unsigned int affect;
    unsigned int values;
#endif
{
    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
#if NeedFunctionPrototypes
XkbLockGroup(Display *dpy,unsigned int deviceSpec,unsigned int group)
#else
XkbLockGroup(dpy,deviceSpec,group)
    Display *dpy;
    unsigned int deviceSpec;
    unsigned int group;
#endif
{
    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
#if NeedFunctionPrototypes
XkbLatchGroup(Display *dpy,unsigned int deviceSpec,unsigned int group)
#else
XkbLatchGroup(dpy,deviceSpec,group)
    Display *dpy;
    unsigned int deviceSpec;
    unsigned int group;
#endif
{
    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
#if NeedFunctionPrototypes
XkbSetXlibControls(Display *dpy,unsigned affect,unsigned values)
#else
XkbSetXlibControls(dpy,affect,values)
    Display *	dpy;
    unsigned	affect;
    unsigned	values;
#endif
{
    if ((dpy->flags & XlibDisplayNoXkb) ||
	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
	return False;
    affect&= XkbLC_AllControls;
    dpy->xkb_info->xlib_ctrls&= ~affect;
    dpy->xkb_info->xlib_ctrls|= (affect&values);
    return dpy->xkb_info->xlib_ctrls;
}

unsigned
#if NeedFunctionPrototypes
XkbGetXlibControls(Display *dpy)
#else
XkbGetXlibControls(dpy)
    Display *	dpy;
#endif
{
    if ((dpy->flags & XlibDisplayNoXkb) ||
	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
	return 0;
    return dpy->xkb_info->xlib_ctrls;
}

unsigned int
#if NeedFunctionPrototypes
XkbXlibControlsImplemented(void)
#else
XkbXlibControlsImplemented()
#endif
{
#ifdef __sgi
    return XkbLC_AllControls;
#else
    return XkbLC_AllControls&~XkbLC_AllComposeControls;
#endif
}

Bool
#if NeedFunctionPrototypes
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)
#else
XkbSetDebuggingFlags(dpy,mask,flags,msg,ctrls_mask,ctrls,rtrn_flags,rtrn_ctrls)
    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;
#endif
{
    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
#if NeedFunctionPrototypes
XkbComputeEffectiveMap(	XkbDescPtr 	xkb,
			XkbKeyTypePtr 	type,
			unsigned char *	map_rtrn)
#else
XkbComputeEffectiveMap(xkb,type,map_rtrn)
    XkbDescPtr		xkb;
    XkbKeyTypePtr	type;
    unsigned char *	map_rtrn;
#endif
{
register int 		i;
unsigned     		tmp;
XkbKTMapEntryPtr	entry;

    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
#if NeedFunctionPrototypes
XkbGetState(Display *dpy,unsigned deviceSpec,XkbStatePtr rtrn)
#else
XkbGetState(dpy,deviceSpec,rtrn)
    Display *	dpy;
    unsigned 	deviceSpec;
    XkbStatePtr	rtrn;
#endif
{
    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
#if NeedFunctionPrototypes
XkbSetDetectableAutoRepeat(Display *dpy,Bool detectable,Bool *supported)
#else
XkbSetDetectableAutoRepeat(dpy,detectable,supported)
    Display *		dpy;
    Bool		detectable;
    Bool *		supported;
#endif
{
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
#if NeedFunctionPrototypes
XkbGetDetectableAutoRepeat(Display *dpy,Bool *supported)
#else
XkbGetDetectableAutoRepeat(dpy,supported)
    Display *		dpy;
    Bool *		supported;
#endif
{
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
#if NeedFunctionPrototypes
XkbSetAutoResetControls(	Display *	dpy,
				unsigned 	changes,
				unsigned *	auto_ctrls,
				unsigned *	auto_values)
#else
XkbSetAutoResetControls(dpy,changes,auto_ctrls,auto_values)
    Display *		dpy;
    unsigned 		changes;
    unsigned *		auto_ctrls;
    unsigned *		auto_values;
#endif
{
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
#if NeedFunctionPrototypes
XkbGetAutoResetControls(	Display *	dpy,
				unsigned *	auto_ctrls,
				unsigned *	auto_ctrl_values)
#else
XkbGetAutoResetControls(dpy,auto_ctrls,auto_ctrl_values)
    Display *		dpy;
    unsigned *		auto_ctrls;
    unsigned *		auto_ctrl_values;
#endif
{
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
#if NeedFunctionPrototypes
XkbSetPerClientControls(	Display *	dpy,
				unsigned 	change,
				unsigned *	values)
#else
XkbSetPerClientControls(dpy,change,values)
    Display *		dpy;
    unsigned 		change;
    unsigned *		values;
#endif
{
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
#if NeedFunctionPrototypes
XkbGetPerClientControls(	Display *	dpy,
				unsigned *	ctrls)
#else
XkbGetPerClientControls(dpy,ctrls)
    Display *		dpy;
    unsigned *		ctrls;
#endif
{
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 *
#if NeedFunctionPrototypes
XkbOpenDisplay(	char *	name,
		int *	ev_rtrn,
		int *	err_rtrn,
		int *	major_rtrn,
		int *	minor_rtrn,
		int *	reason)
#else
XkbOpenDisplay(name,ev_rtrn,err_rtrn,major_rtrn,minor_rtrn,reason)
    char *	name;
    int *	ev_rtrn;
    int *	err_rtrn;
    int *	major_rtrn;
    int *	minor_rtrn;
    int *	reason;
#endif
{
    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
#if NeedFunctionPrototypes
XkbSetAtomFuncs(XkbInternAtomFunc getAtom,XkbGetAtomNameFunc getName)
#else
XkbSetAtomFuncs(getAtom,getName)
    XkbInternAtomFunc	getAtom;
    XkbGetAtomNameFunc	getName;
#endif
{
    _XkbInternAtomFunc= (getAtom?getAtom:XInternAtom);
    _XkbGetAtomNameFunc= (getName?getName:XGetAtomName);
    return;
}