Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 771 insertions, 0 deletions

diff --git a/libX11/src/xkb/XKB.c b/libX11/src/xkb/XKB.c
new file mode 100644
index 000000000..ecc5ddf0a
--- /dev/null
+++ b/libX11/src/xkb/XKB.c
@@ -0,0 +1,771 @@
+/* $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.9 2003/04/17 02:06:31 dawes Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#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 
+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;
+}