From 3562e78743202e43aec8727005182a2558117eca Mon Sep 17 00:00:00 2001 From: marha Date: Sun, 28 Jun 2009 22:07:26 +0000 Subject: 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 --- libX11/src/xkb/XKBBind.c | 851 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 851 insertions(+) create mode 100644 libX11/src/xkb/XKBBind.c (limited to 'libX11/src/xkb/XKBBind.c') diff --git a/libX11/src/xkb/XKBBind.c b/libX11/src/xkb/XKBBind.c new file mode 100644 index 000000000..4dc92654e --- /dev/null +++ b/libX11/src/xkb/XKBBind.c @@ -0,0 +1,851 @@ +/* $Xorg: XKBBind.c,v 1.4 2001/02/09 02:03:37 xorgcvs Exp $ */ +/* + +Copyright 1985, 1987, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/* $XFree86: xc/lib/X11/XKBBind.c,v 3.19 2003/05/27 22:26:25 tsi Exp $ */ + + /* the new monsters ate the old ones */ + +#define NEED_EVENTS +#ifdef HAVE_CONFIG_H +#include +#endif +#include "XKBlib.h" +#include +#include +#include +#include +#include + +#include +#include "XKBlibint.h" + +#ifdef USE_OWN_COMPOSE +#define COMPOSE_NO_CONST_MEMBERS +#include "imComp.h" +#endif + +#define AllMods (ShiftMask|LockMask|ControlMask| \ + Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask) + +static int _XkbLoadDpy( + Display *dpy +); + +struct _XKeytrans { + struct _XKeytrans *next;/* next on list */ + char *string; /* string to return when the time comes */ + int len; /* length of string (since NULL is legit)*/ + KeySym key; /* keysym rebound */ + unsigned int state; /* modifier state */ + KeySym *modifiers; /* modifier keysyms you want */ + int mlen; /* length of modifier list */ +}; + +KeySym +XkbKeycodeToKeysym(Display *dpy, +#if NeedWidePrototypes + unsigned int kc, +#else + KeyCode kc, +#endif + int group, + int level) +{ + XkbDescRec *xkb; + + if (_XkbUnavailable(dpy)) + return NoSymbol; + + _XkbCheckPendingRefresh(dpy,dpy->xkb_info); + + xkb = dpy->xkb_info->desc; + if ((kcmin_key_code)||(kc>xkb->max_key_code)) + return NoSymbol; + + if ((group<0)||(level<0)||(group>=XkbKeyNumGroups(xkb,kc))) + return NoSymbol; + if (level>=XkbKeyGroupWidth(xkb,kc,group)) { + /* for compatibility with the core protocol, _always_ allow */ + /* two symbols in the first two groups. If either of the */ + /* two is of type ONE_LEVEL, just replicate the first symbol */ + if ((group>XkbGroup2Index)||(XkbKeyGroupWidth(xkb,kc,group)!=1)|| + (level!=1)) { + return NoSymbol; + } + level= 0; + } + return XkbKeySymEntry(xkb,kc,level,group); +} + +KeySym +XKeycodeToKeysym(Display *dpy, +#if NeedWidePrototypes + unsigned int kc, +#else + KeyCode kc, +#endif + int col) +{ + XkbDescRec *xkb; + + if (_XkbUnavailable(dpy)) + return _XKeycodeToKeysym(dpy, kc, col); + + _XkbCheckPendingRefresh(dpy,dpy->xkb_info); + + xkb = dpy->xkb_info->desc; + if ((kcmin_key_code)||(kc>xkb->max_key_code)) + return NoSymbol; + + if (col>3) { + int lastSym,tmp,nGrp; + + lastSym= 3; + nGrp= XkbKeyNumGroups(xkb,kc); + if ((nGrp>0)&&((tmp=XkbKeyGroupWidth(xkb,kc,XkbGroup1Index))>2)) { + if (col<=(lastSym+tmp-2)) + return XkbKeycodeToKeysym(dpy,kc,XkbGroup1Index,col-lastSym+2); + lastSym+= tmp-2; + } + if ((nGrp>1)&&((tmp=XkbKeyGroupWidth(xkb,kc,XkbGroup2Index))>2)) { + if (col<=(lastSym+tmp-2)) + return XkbKeycodeToKeysym(dpy,kc,XkbGroup2Index,col-lastSym+2); + lastSym+= tmp-2; + } + if (nGrp>2) { + tmp= XkbKeyGroupWidth(xkb,kc,XkbGroup3Index); + if (col<=lastSym+tmp) + return XkbKeycodeToKeysym(dpy,kc,XkbGroup3Index,col-lastSym); + lastSym+= tmp; + } + if (nGrp>3) { + tmp= XkbKeyGroupWidth(xkb,kc,XkbGroup4Index); + if (col<=lastSym+tmp) + return XkbKeycodeToKeysym(dpy,kc,XkbGroup4Index,col-lastSym); + } + return NoSymbol; + } + return XkbKeycodeToKeysym(dpy,kc,(col>>1),(col&1)); +} + +KeyCode +XKeysymToKeycode(Display *dpy, KeySym ks) +{ + register int i, j, gotOne; + + if (_XkbUnavailable(dpy)) + return _XKeysymToKeycode(dpy,ks); + _XkbCheckPendingRefresh(dpy,dpy->xkb_info); + + j= 0; + do { + register XkbDescRec *xkb = dpy->xkb_info->desc; + gotOne= 0; + for (i = dpy->min_keycode; i <= dpy->max_keycode; i++) { + if ( j<(int)XkbKeyNumSyms(xkb,i) ) { + gotOne = 1; + if ((XkbKeySym(xkb,i,j)==ks)) + return i; + } + } + j++; + } while (gotOne); + return 0; +} + +static int +_XkbComputeModmap(Display *dpy) +{ +register XkbDescPtr xkb; + + xkb= dpy->xkb_info->desc; + if (XkbGetUpdatedMap(dpy,XkbModifierMapMask,xkb)==Success) + return 1; + return 0; +} + +unsigned +XkbKeysymToModifiers(Display *dpy,KeySym ks) +{ + XkbDescRec *xkb; + register int i,j; + register KeySym *pSyms; + CARD8 mods; + + if (_XkbUnavailable(dpy)) + return _XKeysymToModifiers(dpy,ks); + _XkbCheckPendingRefresh(dpy,dpy->xkb_info); + + if (_XkbNeedModmap(dpy->xkb_info)&&(!_XkbComputeModmap(dpy))) + return _XKeysymToModifiers(dpy,ks); + + xkb= dpy->xkb_info->desc; + mods= 0; + for (i = xkb->min_key_code; i <= (int)xkb->max_key_code; i++) { + pSyms= XkbKeySymsPtr(xkb,i); + for (j=XkbKeyNumSyms(xkb,i)-1;j>=0;j--) { + if (pSyms[j]==ks) { + mods|= xkb->map->modmap[i]; + break; + } + } + } + return mods; +} + +KeySym +XLookupKeysym(register XKeyEvent *event, int col) +{ + Display *dpy = event->display; + if (_XkbUnavailable(dpy)) + return _XLookupKeysym(event, col); + _XkbCheckPendingRefresh(dpy,dpy->xkb_info); + return XKeycodeToKeysym(dpy, event->keycode, col); +} + + /* + * Not a public entry point -- XkbTranslateKey is an obsolete name + * that is preserved here so that functions linked against the old + * version will continue to work in a shared library environment. + */ +int +XkbTranslateKey( register Display * dpy, + KeyCode key, + register unsigned int mods, + unsigned int * mods_rtrn, + KeySym * keysym_rtrn); +int +XkbTranslateKey( register Display * dpy, + KeyCode key, + register unsigned int mods, + unsigned int * mods_rtrn, + KeySym * keysym_rtrn) +{ + return XkbLookupKeySym(dpy,key,mods,mods_rtrn,keysym_rtrn); +} + +Bool +XkbLookupKeySym( register Display * dpy, + KeyCode key, + register unsigned int mods, + unsigned int * mods_rtrn, + KeySym * keysym_rtrn) +{ + if (_XkbUnavailable(dpy)) + return _XTranslateKey(dpy, key, mods, mods_rtrn, keysym_rtrn); + _XkbCheckPendingRefresh(dpy,dpy->xkb_info); + return XkbTranslateKeyCode(dpy->xkb_info->desc,key,mods,mods_rtrn, + keysym_rtrn); +} + +Bool +XkbTranslateKeyCode( register XkbDescPtr xkb, + KeyCode key, + register unsigned int mods, + unsigned int * mods_rtrn, + KeySym * keysym_rtrn) +{ + XkbKeyTypeRec *type; + int col,nKeyGroups; + unsigned preserve,effectiveGroup; + KeySym *syms; + + if (mods_rtrn!=NULL) + *mods_rtrn = 0; + + nKeyGroups= XkbKeyNumGroups(xkb,key); + if ((!XkbKeycodeInRange(xkb,key))||(nKeyGroups==0)) { + if (keysym_rtrn!=NULL) + *keysym_rtrn = NoSymbol; + return False; + } + + syms = XkbKeySymsPtr(xkb,key); + + /* find the offset of the effective group */ + col = 0; + effectiveGroup= XkbGroupForCoreState(mods); + if ( effectiveGroup>=nKeyGroups ) { + unsigned groupInfo= XkbKeyGroupInfo(xkb,key); + switch (XkbOutOfRangeGroupAction(groupInfo)) { + default: + effectiveGroup %= nKeyGroups; + break; + case XkbClampIntoRange: + effectiveGroup = nKeyGroups-1; + break; + case XkbRedirectIntoRange: + effectiveGroup = XkbOutOfRangeGroupNumber(groupInfo); + if (effectiveGroup>=nKeyGroups) + effectiveGroup= 0; + break; + } + } + col= effectiveGroup*XkbKeyGroupsWidth(xkb,key); + type = XkbKeyKeyType(xkb,key,effectiveGroup); + + preserve= 0; + if (type->map) { /* find the column (shift level) within the group */ + register int i; + register XkbKTMapEntryPtr entry; + for (i=0,entry=type->map;imap_count;i++,entry++) { + if ((entry->active)&&((mods&type->mods.mask)==entry->mods.mask)) { + col+= entry->level; + if (type->preserve) + preserve= type->preserve[i].mask; + break; + } + } + } + + if (keysym_rtrn!=NULL) + *keysym_rtrn= syms[col]; + if (mods_rtrn) { + *mods_rtrn= type->mods.mask&(~preserve); + /* The Motif VTS doesn't get the help callback called if help + * is bound to Shift+, and it appears as though it + * is XkbTranslateKeyCode that is causing the problem. The + * core X version of XTranslateKey always OR's in ShiftMask + * and LockMask for mods_rtrn, so this "fix" keeps this behavior + * and solves the VTS problem. + */ + if ((xkb->dpy)&&(xkb->dpy->xkb_info)&& + (xkb->dpy->xkb_info->xlib_ctrls&XkbLC_AlwaysConsumeShiftAndLock)) { + *mods_rtrn|= (ShiftMask|LockMask); + } + } + return (syms[col]!=NoSymbol); +} + +Status +XkbRefreshKeyboardMapping(register XkbMapNotifyEvent *event) +{ + Display *dpy = event->display; + XkbInfoPtr xkbi; + + if (_XkbUnavailable(dpy)) { + _XRefreshKeyboardMapping((XMappingEvent *)event); + return Success; + } + xkbi= dpy->xkb_info; + + if (((event->type&0x7f)-xkbi->codes->first_event)!=XkbEventCode) + return BadMatch; + if (event->xkb_type==XkbNewKeyboardNotify) { + _XkbReloadDpy(dpy); + return Success; + } + if (event->xkb_type==XkbMapNotify) { + XkbMapChangesRec changes; + Status rtrn; + + if (xkbi->flags&XkbMapPending) + changes= xkbi->changes; + else bzero(&changes,sizeof(changes)); + XkbNoteMapChanges(&changes,event,XKB_XLIB_MAP_MASK); + if ((rtrn=XkbGetMapChanges(dpy,xkbi->desc,&changes))!=Success) { +#ifdef DEBUG + fprintf(stderr,"Internal Error! XkbGetMapChanges failed:\n"); +#endif + xkbi->changes= changes; + } + else if (xkbi->flags&XkbMapPending) { + xkbi->flags&= ~XkbMapPending; + bzero(&xkbi->changes,sizeof(XkbMapChangesRec)); + } + return rtrn; + } + return BadMatch; +} + +int +XRefreshKeyboardMapping(register XMappingEvent *event) +{ + XkbEvent *xkbevent = (XkbEvent *)event; + Display *dpy = event->display; + XkbMapChangesRec changes; + XkbInfoPtr xkbi; + + /* always do this for input methods, which still use the old keymap */ + (void) _XRefreshKeyboardMapping(event); + + if (_XkbUnavailable(dpy)) + return 1; + + xkbi = dpy->xkb_info; + + if (((event->type&0x7f)-xkbi->codes->first_event)==XkbEventCode) + return XkbRefreshKeyboardMapping(&xkbevent->map); + + if (xkbi->flags&XkbXlibNewKeyboard) { + _XkbReloadDpy(dpy); + return 1; + } + + if ((xkbi->flags&XkbMapPending)||(event->request==MappingKeyboard)) { + if (xkbi->flags&XkbMapPending) { + changes= xkbi->changes; + _XkbNoteCoreMapChanges(&changes,event,XKB_XLIB_MAP_MASK); + } + else { + bzero(&changes,sizeof(changes)); + changes.changed= XkbKeySymsMask; + if (xkbi->desc->min_key_codedesc->max_key_code) { + changes.first_key_sym= xkbi->desc->min_key_code; + changes.num_key_syms= xkbi->desc->max_key_code- + xkbi->desc->min_key_code+1; + } + else { + changes.first_key_sym= event->first_keycode; + changes.num_key_syms= event->count; + } + } + + if (XkbGetMapChanges(dpy,xkbi->desc, &changes)!=Success) { +#ifdef DEBUG + fprintf(stderr,"Internal Error! XkbGetMapChanges failed:\n"); + if (changes.changed&XkbKeyTypesMask) { + int first= changes.first_type; + int last= changes.first_type+changes.num_types-1; + fprintf(stderr," types: %d..%d\n",first,last); + } + if (changes.changed&XkbKeySymsMask) { + int first= changes.first_key_sym; + int last= changes.first_key_sym+changes.num_key_syms-1; + fprintf(stderr," symbols: %d..%d\n",first,last); + } + if (changes.changed&XkbKeyActionsMask) { + int last,first= changes.first_key_act; + last= changes.first_key_act+changes.num_key_acts-1; + fprintf(stderr," acts: %d..%d\n",first,last); + } + if (changes.changed&XkbKeyBehaviorsMask) { + int last,first= changes.first_key_behavior; + last= first+changes.num_key_behaviors-1; + fprintf(stderr," behaviors: %d..%d\n",first,last); + } + if (changes.changed&XkbVirtualModsMask) { + fprintf(stderr,"virtual mods: 0x%04x\n", + changes.vmods); + } + if (changes.changed&XkbExplicitComponentsMask) { + int last,first= changes.first_key_explicit; + last= first+changes.num_key_explicit-1; + fprintf(stderr," explicit: %d..%d\n",first,last); + } +#endif + } + LockDisplay(dpy); + if (xkbi->flags&XkbMapPending) { + xkbi->flags&= ~XkbMapPending; + bzero(&xkbi->changes,sizeof(XkbMapChangesRec)); + } + UnlockDisplay(dpy); + } + if (event->request==MappingModifier) { + LockDisplay(dpy); + if (xkbi->desc->map->modmap) { + _XkbFree(xkbi->desc->map->modmap); + xkbi->desc->map->modmap= NULL; + } + if (dpy->key_bindings) { + register struct _XKeytrans *p; + for (p = dpy->key_bindings; p; p = p->next) { + register int i; + p->state= 0; + if (p->mlen>0) { + for (i = 0; i < p->mlen; i++) { + p->state|= XkbKeysymToModifiers(dpy,p->modifiers[i]); + } + if (p->state) p->state &= AllMods; + else p->state = AnyModifier; + } + } + } + UnlockDisplay(dpy); + } + return 1; +} + +static int +_XkbLoadDpy(Display *dpy) +{ + XkbInfoPtr xkbi; + unsigned query,oldEvents; + XkbDescRec *desc; + + if (!XkbUseExtension(dpy,NULL,NULL)) + return 0; + + xkbi = dpy->xkb_info; + query = XkbAllClientInfoMask; + desc = XkbGetMap(dpy,query,XkbUseCoreKbd); + if (!desc) { +#ifdef DEBUG + fprintf(stderr,"Warning! XkbGetMap failed!\n"); +#endif + return 0; + } + LockDisplay(dpy); + xkbi->desc = desc; + + UnlockDisplay(dpy); + oldEvents= xkbi->selected_events; + if (!(xkbi->xlib_ctrls&XkbLC_IgnoreNewKeyboards)) { + XkbSelectEventDetails(dpy,xkbi->desc->device_spec,XkbNewKeyboardNotify, + XkbNKN_KeycodesMask|XkbNKN_DeviceIDMask, + XkbNKN_KeycodesMask|XkbNKN_DeviceIDMask); + } + XkbSelectEventDetails(dpy,xkbi->desc->device_spec,XkbMapNotify, + XkbAllClientInfoMask,XkbAllClientInfoMask); + LockDisplay(dpy); + xkbi->selected_events= oldEvents; + UnlockDisplay(dpy); + return 1; +} + +void +_XkbReloadDpy(Display *dpy) +{ + XkbInfoPtr xkbi; + XkbDescRec *desc; + unsigned oldDeviceID; + + if (_XkbUnavailable(dpy)) + return; + + xkbi = dpy->xkb_info; + LockDisplay(dpy); + if (xkbi->desc) { + oldDeviceID= xkbi->desc->device_spec; + XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True); + xkbi->desc= NULL; + xkbi->flags&= ~(XkbMapPending|XkbXlibNewKeyboard); + xkbi->changes.changed= 0; + } + else oldDeviceID= XkbUseCoreKbd; + UnlockDisplay(dpy); + desc = XkbGetMap(dpy,XkbAllClientInfoMask,XkbUseCoreKbd); + if (!desc) + return; + LockDisplay(dpy); + xkbi->desc = desc; + UnlockDisplay(dpy); + + if (desc->device_spec!=oldDeviceID) { + /* transfer(?) event masks here */ +#ifdef NOTYET + unsigned oldEvents; + oldEvents= xkbi->selected_events; + XkbSelectEventDetails(dpy,xkbi->desc->device_spec,XkbMapNotify, + XkbAllMapComponentsMask,XkbAllClientInfoMask); + LockDisplay(dpy); + xkbi->selected_events= oldEvents; + UnlockDisplay(dpy); +#endif + } + return; +} + +int +XkbTranslateKeySym( register Display * dpy, + register KeySym * sym_rtrn, + unsigned int mods, + char * buffer, + int nbytes, + int * extra_rtrn) +{ + register XkbInfoPtr xkb; + XkbKSToMBFunc cvtr; + XPointer priv; + char tmp[4]; + int n; + + xkb= dpy->xkb_info; + if (!xkb->cvt.KSToMB) { + _XkbGetConverters(_XkbGetCharset(),&xkb->cvt); + _XkbGetConverters("ISO8859-1",&xkb->latin1cvt); + } + + if (extra_rtrn) + *extra_rtrn= 0; + + if ((buffer==NULL)||(nbytes==0)) { + buffer= tmp; + nbytes= 4; + } + + /* see if symbol rebound, if so, return that string. */ + n = XkbLookupKeyBinding(dpy,*sym_rtrn,mods,buffer,nbytes,extra_rtrn); + if (n) + return n; + + if ( nbytes>0 ) + buffer[0]= '\0'; + + if ( xkb->cvt.KSToUpper && (mods&LockMask) ) { + *sym_rtrn = (*xkb->cvt.KSToUpper)(*sym_rtrn); + } + if (xkb->xlib_ctrls & XkbLC_ForceLatin1Lookup) { + cvtr = xkb->latin1cvt.KSToMB; + priv = xkb->latin1cvt.KSToMBPriv; + } else { + cvtr = xkb->cvt.KSToMB; + priv = xkb->cvt.KSToMBPriv; + } + + n = (*cvtr)(priv,*sym_rtrn,buffer,nbytes,extra_rtrn); + + if ((!xkb->cvt.KSToUpper)&&( mods&LockMask )) { + register int i; + int change; + char ch; + for (i=change=0;icvt.MBToKS)(xkb->cvt.MBToKSPriv,buffer,n,0); + else *sym_rtrn= NoSymbol; + } + } + + if ( mods&ControlMask ) { + if ( n==1 ) { + buffer[0]= XkbToControl(buffer[0]); + if ( nbytes>1 ) + buffer[1]= '\0'; + return 1; + } + if ( nbytes > 0 ) + buffer[0]= '\0'; + return 0; + } + return n; +} + +int +XLookupString ( register XKeyEvent * event, + char * buffer, + int nbytes, + KeySym * keysym, + XComposeStatus * status) +{ + KeySym dummy; + int rtrnLen; + unsigned int new_mods; + Display *dpy = event->display; + + if (keysym==NULL) + keysym= &dummy; + if (!XkbLookupKeySym(dpy,event->keycode,event->state, &new_mods,keysym)) + return 0; + new_mods= (event->state&(~new_mods)); + + /* find the group where a symbol can be converted to control one */ + if (new_mods&ControlMask && *keysym > 0x7F && + (dpy->xkb_info->xlib_ctrls & XkbLC_ControlFallback)) { + XKeyEvent tmp_ev = *event; + KeySym tmp_keysym; + unsigned int tmp_new_mods; + if (_XkbUnavailable(dpy)) { + tmp_ev.state= event->state ^ dpy->mode_switch; + if (XkbLookupKeySym(dpy, tmp_ev.keycode, tmp_ev.state, + &tmp_new_mods, &tmp_keysym) && + tmp_keysym != NoSymbol && tmp_keysym < 0x80 ) { + *keysym = tmp_keysym; + } + } else { + int n = XkbKeyNumGroups(dpy->xkb_info->desc, tmp_ev.keycode); + int i; + for (i = 0; i < n; i++) { + if (XkbGroupForCoreState(event->state) == i) + continue; + tmp_ev.state= XkbBuildCoreState(tmp_ev.state, i); + if (XkbLookupKeySym(dpy, tmp_ev.keycode, tmp_ev.state, + &tmp_new_mods, &tmp_keysym) && + tmp_keysym != NoSymbol && tmp_keysym < 0x80 ) { + *keysym = tmp_keysym; + new_mods= (event->state&(~tmp_new_mods)); + break; + } + } + } + } + +#ifdef USE_OWN_COMPOSE + if ( status ) { + static int been_here= 0; + if ( !been_here ) { + XimCompInitTables(); + been_here = 1; + } + if ( !XimCompLegalStatus(status) ) { + status->compose_ptr = NULL; + status->chars_matched = 0; + } + if ( ((status->chars_matched>0)&&(status->compose_ptr!=NULL)) || + XimCompIsComposeKey(*keysym,event->keycode,status) ) { + XimCompRtrn rtrn; + + switch (XimCompProcessSym(status,*keysym,&rtrn)) { + case XIM_COMP_IGNORE: + break; + case XIM_COMP_IN_PROGRESS: + if ( keysym!=NULL ) + *keysym = NoSymbol; +#ifndef NO_COMPOSE_LED + if ( dpy->xkb_info->xlib_ctrls&XkbLC_ComposeLED ) { + XkbSetNamedIndicator(dpy,dpy->xkb_info->composeLED, + True,True,False,NULL); + } +#endif + return 0; + case XIM_COMP_FAIL: + { + static Atom _ComposeFail= None; + int n = 0, len= 0; +#ifndef NO_COMPOSE_LED + if ( dpy->xkb_info->xlib_ctrls&XkbLC_ComposeLED ) { + XkbSetNamedIndicator(dpy,dpy->xkb_info->composeLED, + True,False,False,NULL); + } +#endif +#ifndef NO_BELL_ON_COMPOSE_FAIL + if (dpy->xkb_info->xlib_ctrls&XkbLC_BeepOnComposeFail) { + if (_ComposeFail==None) + _ComposeFail= XInternAtom(dpy,"ComposeFail",0); + XkbBell(dpy,event->window,0,_ComposeFail); + } +#endif + for (n=len=0;rtrn.sym[n]!=XK_VoidSymbol;n++) { + if ( nbytes-len > 0 ) { + len+= XkbTranslateKeySym(dpy,&rtrn.sym[n],new_mods, + buffer+len,nbytes-len, + NULL); + } + } + if ( keysym!=NULL ) { + if ( n==1 ) *keysym = rtrn.sym[0]; + else *keysym = NoSymbol; + } + return len; + } + case XIM_COMP_SUCCEED: + { + int len,n = 0; + +#ifndef NO_COMPOSE_LED + if ( dpy->xkb_info->xlib_ctrls&XkbLC_ComposeLED ) { + XkbSetNamedIndicator(dpy,dpy->xkb_info->composeLED, + True,False,False,NULL); + } +#endif + *keysym = rtrn.matchSym; + if ( rtrn.str[0]!='\0' ) { + strncpy(buffer,rtrn.str,nbytes-1); + buffer[nbytes-1]= '\0'; + len = (int)strlen(buffer); + } + else { + len = XkbTranslateKeySym(dpy,keysym,new_mods, + buffer,nbytes, + NULL); + } + for (n=0;rtrn.sym[n]!=XK_VoidSymbol;n++) { + if ( nbytes-len > 0 ) { + len+= XkbTranslateKeySym(dpy,&rtrn.sym[n], + event->state, + buffer+len,nbytes-len, + NULL); + } + } + return len; + } + } + } + } +#endif + + /* We *should* use the new_mods (which does not contain any modifiers */ + /* that were used to compute the symbol here, but pre-XKB XLookupString */ + /* did not and we have to remain compatible. Sigh. */ + if (_XkbUnavailable(dpy) || + (dpy->xkb_info->xlib_ctrls&XkbLC_ConsumeLookupMods)==0) + new_mods= event->state; + + rtrnLen= XkbLookupKeyBinding(dpy,*keysym,new_mods,buffer,nbytes,NULL); + if (rtrnLen>0) + return rtrnLen; + + return XkbTranslateKeySym(dpy,keysym,new_mods,buffer,nbytes,NULL); +} + + +int +XkbLookupKeyBinding( Display * dpy, + register KeySym sym, + unsigned int mods, + char * buffer, + int nbytes, + int * extra_rtrn) +{ + register struct _XKeytrans *p; + + if (extra_rtrn) + *extra_rtrn= 0; + for (p = dpy->key_bindings; p; p = p->next) { + if (((mods & AllMods) == p->state) && (sym == p->key)) { + int tmp = p->len; + if (tmp > nbytes) { + if (extra_rtrn) + *extra_rtrn= (tmp-nbytes); + tmp = nbytes; + } + memcpy (buffer, p->string, tmp); + if (tmp < nbytes) buffer[tmp]= '\0'; + return tmp; + } + } + return 0; +} + +char +XkbToControl( char ch ) +{ + register char c = ch; + + if ((c >= '@' && c < '\177') || c == ' ') c &= 0x1F; + else if (c == '2') c = '\000'; + else if (c >= '3' && c <= '7') c -= ('3' - '\033'); + else if (c == '8') c = '\177'; + else if (c == '/') c = '_' & 0x1F; + return c; +} -- cgit v1.2.3