From 52a8406aaba4ed1f9fa5e78bfa5da7af659bce01 Mon Sep 17 00:00:00 2001 From: Kaleb Keithley Date: Fri, 14 Nov 2003 15:54:40 +0000 Subject: R6.6 is the Xorg base-line --- include/X11/extensions/XKBbells.h | 146 ++++ include/X11/extensions/XKBconfig.h | 299 +++++++ include/X11/extensions/XKBfile.h | 601 +++++++++++++ include/X11/extensions/XKBrules.h | 264 ++++++ include/X11/extensions/XKM.h | 70 ++ include/X11/extensions/XKMformat.h | 299 +++++++ src/XKBfileInt.h | 82 ++ src/cout.c | 1242 ++++++++++++++++++++++++++ src/magic | 11 + src/maprules.c | 1382 +++++++++++++++++++++++++++++ src/srvmisc.c | 233 +++++ src/xkbatom.c | 284 ++++++ src/xkbbells.c | 116 +++ src/xkbconfig.c | 1394 +++++++++++++++++++++++++++++ src/xkbdraw.c | 151 ++++ src/xkberrs.c | 70 ++ src/xkbmisc.c | 716 +++++++++++++++ src/xkbout.c | 1216 ++++++++++++++++++++++++++ src/xkbtext.c | 1700 ++++++++++++++++++++++++++++++++++++ src/xkmout.c | 1628 ++++++++++++++++++++++++++++++++++ src/xkmread.c | 1481 +++++++++++++++++++++++++++++++ 21 files changed, 13385 insertions(+) create mode 100644 include/X11/extensions/XKBbells.h create mode 100644 include/X11/extensions/XKBconfig.h create mode 100644 include/X11/extensions/XKBfile.h create mode 100644 include/X11/extensions/XKBrules.h create mode 100644 include/X11/extensions/XKM.h create mode 100644 include/X11/extensions/XKMformat.h create mode 100644 src/XKBfileInt.h create mode 100644 src/cout.c create mode 100644 src/magic create mode 100644 src/maprules.c create mode 100644 src/srvmisc.c create mode 100644 src/xkbatom.c create mode 100644 src/xkbbells.c create mode 100644 src/xkbconfig.c create mode 100644 src/xkbdraw.c create mode 100644 src/xkberrs.c create mode 100644 src/xkbmisc.c create mode 100644 src/xkbout.c create mode 100644 src/xkbtext.c create mode 100644 src/xkmout.c create mode 100644 src/xkmread.c diff --git a/include/X11/extensions/XKBbells.h b/include/X11/extensions/XKBbells.h new file mode 100644 index 0000000..2b6865f --- /dev/null +++ b/include/X11/extensions/XKBbells.h @@ -0,0 +1,146 @@ +#ifndef _XKBBELLS_H_ +#define _XKBBELLS_H_ 1 + +/* $Xorg: XKBbells.h,v 1.3 2000/08/17 19:46:42 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1995 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. + + ********************************************************/ + +#define XkbBN_Info "Info" +#define XkbBN_Warning "Warning" +#define XkbBN_MinorError "MinorError" +#define XkbBN_MajorError "MajorError" +#define XkbBN_BadValue "BadValue" +#define XkbBN_InvalidLocation "InvalidLocation" +#define XkbBN_Question "Question" +#define XkbBN_Start "Start" +#define XkbBN_End "End" +#define XkbBN_Success "Success" +#define XkbBN_Failure "Failure" +#define XkbBN_Wait "Wait" +#define XkbBN_Proceed "Proceed" +#define XkbBN_Ignore "Ignore" +#define XkbBN_Iconify "Iconify" +#define XkbBN_Deiconify "Deconify" +#define XkbBN_Open "Open" +#define XkbBN_Close "Close" +#define XkbBN_TerminalBell "TerminalBell" +#define XkbBN_MarginBell "MarginBell" +#define XkbBN_CursorStuck "CursorStuck" +#define XkbBN_NewMail "NewMail" +#define XkbBN_LaunchApp "LaunchApp" +#define XkbBN_AppDeath "AppDeath" +#define XkbBN_ImAlive "ImAlive" +#define XkbBN_ClockChimeHour "ClockChimeHour" +#define XkbBN_ClockChimeHalf "ClockChimeHalf" +#define XkbBN_ClockChimeQuarter "ClockChimeQuarter" +#define XkbBN_RepeatingLastBell "RepeatingLastBell" +#define XkbBN_ComposeFail "ComposeFail" +#define XkbBN_AX_FeatureOn "AX_FeatureOn" +#define XkbBN_AX_FeatureOff "AX_FeatureOff" +#define XkbBN_AX_FeatureChange "AX_FeatureChange" +#define XkbBN_AX_IndicatorOn "AX_IndicatorOn" +#define XkbBN_AX_IndicatorOff "AX_IndicatorOff" +#define XkbBN_AX_IndicatorChange "AX_IndicatorChange" +#define XkbBN_AX_SlowKeysWarning "AX_SlowKeysWarning" +#define XkbBN_AX_SlowKeyPress "AX_SlowKeyPress" +#define XkbBN_AX_SlowKeyAccept "AX_SlowKeyAccept" +#define XkbBN_AX_SlowKeyReject "AX_SlowKeyReject" +#define XkbBN_AX_SlowKeyRelease "AX_SlowKeyRelease" +#define XkbBN_AX_BounceKeyReject "AX_BounceKeyReject" +#define XkbBN_AX_StickyLatch "AX_StickyLatch" +#define XkbBN_AX_StickyLock "AX_StickyLock" +#define XkbBN_AX_StickyUnlock "AX_StickyUnlock" + +#define XkbBI_Info 0 +#define XkbBI_Warning 1 +#define XkbBI_MinorError 2 +#define XkbBI_MajorError 3 +#define XkbBI_BadValue 4 +#define XkbBI_InvalidLocation 5 +#define XkbBI_Question 6 +#define XkbBI_Start 7 +#define XkbBI_End 8 +#define XkbBI_Success 9 +#define XkbBI_Failure 10 +#define XkbBI_Wait 11 +#define XkbBI_Proceed 12 +#define XkbBI_Ignore 13 +#define XkbBI_Iconify 14 +#define XkbBI_Deiconify 15 +#define XkbBI_Open 16 +#define XkbBI_Close 17 +#define XkbBI_TerminalBell 18 +#define XkbBI_MarginBell 19 +#define XkbBI_CursorStuck 20 +#define XkbBI_NewMail 21 +#define XkbBI_LaunchApp 22 +#define XkbBI_AppDeath 23 +#define XkbBI_ImAlive 24 +#define XkbBI_ClockChimeHour 25 +#define XkbBI_ClockChimeHalf 26 +#define XkbBI_ClockChimeQuarter 27 +#define XkbBI_RepeatingLastBell 28 +#define XkbBI_ComposeFail 29 +#define XkbBI_AX_FeatureOn 30 +#define XkbBI_AX_FeatureOff 31 +#define XkbBI_AX_FeatureChange 32 +#define XkbBI_AX_IndicatorOn 33 +#define XkbBI_AX_IndicatorOff 34 +#define XkbBI_AX_IndicatorChange 35 +#define XkbBI_AX_SlowKeysWarning 36 +#define XkbBI_AX_SlowKeyPress 37 +#define XkbBI_AX_SlowKeyAccept 38 +#define XkbBI_AX_SlowKeyReject 39 +#define XkbBI_AX_SlowKeyRelease 40 +#define XkbBI_AX_BounceKeyReject 41 +#define XkbBI_AX_StickyLatch 42 +#define XkbBI_AX_StickyLock 43 +#define XkbBI_AX_StickyUnlock 44 +#define XkbBI_NumBells 45 + +_XFUNCPROTOBEGIN + +extern Bool XkbStdBell( +#if NeedFunctionPrototypes + Display * /* dpy */, + Window /* win */, + int /* percent */, + int /* bellDef */ +#endif +); + +extern Bool XkbStdBellEvent( +#if NeedFunctionPrototypes + Display * /* dpy */, + Window /* win */, + int /* percent */, + int /* bellDef */ +#endif +); + +_XFUNCPROTOEND + +#endif /* _XKBBELLS_H_ */ diff --git a/include/X11/extensions/XKBconfig.h b/include/X11/extensions/XKBconfig.h new file mode 100644 index 0000000..5c38b6f --- /dev/null +++ b/include/X11/extensions/XKBconfig.h @@ -0,0 +1,299 @@ +#ifndef _XKBCONFIG_H_ +#define _XKBCONFIG_H_ 1 + +/* $Xorg: XKBconfig.h,v 1.3 2000/08/17 19:46:42 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1995 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. + + ********************************************************/ + + +typedef struct _XkbConfigRtrn *XkbConfigRtrnPtr; +typedef struct _XkbConfigField *XkbConfigFieldPtr; +typedef struct _XkbConfigFields *XkbConfigFieldsPtr; + +typedef Bool (*XkbConfigParseFunc)( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbConfigFieldsPtr /* fields */, + XkbConfigFieldPtr /* field */, + XkbDescPtr /* xkb */, + XkbConfigRtrnPtr /* rtrn */ +#endif +); + +#define XkbCF_Check 0 +#define XkbCF_Apply 1 +#define XkbCF_CleanUp 2 +#define XkbCF_Destroy 3 + +typedef Bool (*XkbConfigFinishFunc)( +#if NeedFunctionPrototypes + XkbConfigFieldsPtr /* fields */, + XkbDescPtr /* xkb */, + XkbConfigRtrnPtr /* rtrn */, + int /* what */ +#endif +); + +typedef struct _XkbConfigRtrnPriv { + int cfg_id; + XPointer priv; + struct _XkbConfigRtrnPriv * next; +} XkbConfigRtrnPrivRec,*XkbConfigRtrnPrivPtr; + +typedef struct _XkbConfigModInfo { + Bool replace; + unsigned char mods; + unsigned char mods_clear; + unsigned short vmods; + unsigned short vmods_clear; +} XkbConfigModInfoRec,*XkbConfigModInfoPtr; + +typedef struct _XkbConfigUnboundMod { + unsigned char what; + unsigned char mods; + unsigned short vmods; + short merge; + char * name; +} XkbConfigUnboundModRec,*XkbConfigUnboundModPtr; + +#define XkbCF_MergeSet 0 +#define XkbCF_MergeAdd 1 +#define XkbCF_MergeRemove 2 + +#define XkbCF_InitialMods (1L<<0) +#define XkbCF_InternalMods (1L<<1) +#define XkbCF_IgnoreLockMods (1L<<2) +#define XkbCF_InitialCtrls (1L<<3) +#define XkbCF_AccessXTimeout (1L<<4) +#define XkbCF_AccessXTimeoutCtrlsOn (1L<<5) +#define XkbCF_AccessXTimeoutCtrlsOff (1L<<6) +#define XkbCF_AccessXTimeoutOptsOn (1L<<7) +#define XkbCF_AccessXTimeoutOptsOff (1L<<8) +#define XkbCF_GroupsWrap (1L<<9) + +typedef struct _XkbConfigRtrn { + unsigned defined; + int error; + int line; + + int click_volume; + int bell_volume; + int bell_pitch; + int bell_duration; + int repeat_delay; + int repeat_interval; + + char * rules_file; + char * model; + char * layout; + char * variant; + char * options; + + char * keymap; + char * keycodes; + char * geometry; + char * phys_symbols; + char * symbols; + char * types; + char * compat; + Bool replace_initial_ctrls; + unsigned long initial_ctrls; + unsigned long initial_ctrls_clear; + + XkbConfigModInfoRec initial_mods; + XkbConfigModInfoRec internal_mods; + XkbConfigModInfoRec ignore_lock_mods; + + short num_unbound_mods; + short sz_unbound_mods; + XkbConfigUnboundModPtr unbound_mods; + + int groups_wrap; + int slow_keys_delay; + int debounce_delay; + int mk_delay; + int mk_interval; + int mk_time_to_max; + int mk_max_speed; + int mk_curve; + int ax_timeout; + + Bool replace_axt_ctrls_on; + Bool replace_axt_ctrls_off; + unsigned long axt_ctrls_on; + unsigned long axt_ctrls_off; + unsigned long axt_ctrls_ignore; + + Bool replace_axt_opts_off; + Bool replace_axt_opts_on; + unsigned short axt_opts_off; + unsigned short axt_opts_on; + unsigned short axt_opts_ignore; + XkbConfigRtrnPrivPtr priv; +} XkbConfigRtrnRec; + +typedef struct _XkbConfigField { + char * field; + unsigned char field_id; +} XkbConfigFieldRec; + +typedef struct _XkbConfigFields { + unsigned short cfg_id; + unsigned short num_fields; + XkbConfigFieldPtr fields; + XkbConfigParseFunc parser; + XkbConfigFinishFunc finish; + XPointer priv; + struct _XkbConfigFields *next; +} XkbConfigFieldsRec; + +#define XkbCF_EOF -1 +#define XkbCF_Unknown 0 +#define XkbCF_EOL 1 +#define XkbCF_Semi 2 +#define XkbCF_Equals 3 +#define XkbCF_PlusEquals 4 +#define XkbCF_MinusEquals 5 +#define XkbCF_Plus 6 +#define XkbCF_Minus 7 +#define XkbCF_String 10 +#define XkbCF_Ident 11 +#define XkbCF_Integer 12 + +#define XkbCF_UnterminatedString 100 +#define XkbCF_BadAlloc 101 +#define XkbCF_MissingIdent 102 +#define XkbCF_MissingEquals 103 +#define XkbCF_ExpectedEOS 104 +#define XkbCF_ExpectedBoolean 105 +#define XkbCF_ExpectedInteger 106 +#define XkbCF_ExpectedString 107 +#define XkbCF_ExpectedModifier 108 +#define XkbCF_ExpectedControl 109 +#define XkbCF_ExpectedAXOption 110 +#define XkbCF_ExpectedOperator 111 +#define XkbCF_ExpectedOORGroupBehavior 112 + +typedef union { + int ival; + char * str; +} XkbCFScanResultRec,*XkbCFScanResultPtr; + +extern XkbConfigFieldsPtr XkbCFDflts; + +_XFUNCPROTOBEGIN + +extern int XkbCFScan( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbCFScanResultPtr /* val_rtrn */, + XkbConfigRtrnPtr /* rtrn */ +#endif +); + +extern XkbConfigFieldsPtr XkbCFDup( +#if NeedFunctionPrototypes + XkbConfigFieldsPtr /* fields */ +#endif +); + +extern XkbConfigFieldsPtr XkbCFFree( +#if NeedFunctionPrototypes + XkbConfigFieldsPtr /* fields */, + Bool /* all */ +#endif +); + +extern XkbConfigUnboundModPtr XkbCFAddModByName( +#if NeedFunctionPrototypes + XkbConfigRtrnPtr /* rtrn */, + int /* what */, + char * /* name */, + Bool /* merge */, + XkbConfigUnboundModPtr /* last */ +#endif +); + +extern Bool XkbCFBindMods( +#if NeedFunctionPrototypes + XkbConfigRtrnPtr /* rtrn */, + XkbDescPtr /* xkb */ +#endif +); + +extern Bool XkbCFApplyMods( +#if NeedFunctionPrototypes + XkbConfigRtrnPtr /* rtrn */, + int /* what */, + XkbConfigModInfoPtr /* info */ +#endif +); + +extern Bool XkbCFApplyRtrnValues( +#if NeedFunctionPrototypes + XkbConfigRtrnPtr /* rtrn */, + XkbConfigFieldsPtr /* fields */, + XkbDescPtr /* xkb */ +#endif +); + +extern XkbConfigRtrnPrivPtr XkbCFAddPrivate( +#if NeedFunctionPrototypes + XkbConfigRtrnPtr /* rtrn */, + XkbConfigFieldsPtr /* fields */, + XPointer /* ptr */ +#endif +); + +extern void XkbCFFreeRtrn( +#if NeedFunctionPrototypes + XkbConfigRtrnPtr /* rtrn */, + XkbConfigFieldsPtr /* fields */, + XkbDescPtr /* xkb */ +#endif +); + +extern Bool XkbCFParse( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbConfigFieldsPtr /* fields */, + XkbDescPtr /* xkb */, + XkbConfigRtrnPtr /* rtrn */ +#endif +); + +extern void XkbCFReportError( +#if NeedFunctionPrototypes + FILE * /* file */, + char * /* name */, + int /* error */, + int /* line */ +#endif +); + +_XFUNCPROTOEND + +#endif /* _XKBCONFIG_H_ */ diff --git a/include/X11/extensions/XKBfile.h b/include/X11/extensions/XKBfile.h new file mode 100644 index 0000000..2c7de2d --- /dev/null +++ b/include/X11/extensions/XKBfile.h @@ -0,0 +1,601 @@ +#ifndef _XKBFILE_H_ +#define _XKBFILE_H_ 1 + +/* $Xorg: XKBfile.h,v 1.3 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ + +/***====================================================================***/ + +#define XkbXKMFile 0 +#define XkbCFile 1 +#define XkbXKBFile 2 +#define XkbMessage 3 + +#define XkbMapDefined (1<<0) +#define XkbStateDefined (1<<1) + +typedef struct _XkbFileInfo { + unsigned type; + unsigned defined; + XkbDescPtr xkb; +} XkbFileInfo,*XkbFileInfoPtr; + +typedef void (*XkbFileAddOnFunc)( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* topLevel */, + Bool /* showImplicit */, + int /* fileSection */, + void * /* priv */ +#endif +); + +/***====================================================================***/ + +#define _XkbSuccess 0 +#define _XkbErrMissingNames 1 +#define _XkbErrMissingTypes 2 +#define _XkbErrMissingReqTypes 3 +#define _XkbErrMissingSymbols 4 +#define _XkbErrMissingVMods 5 +#define _XkbErrMissingIndicators 6 +#define _XkbErrMissingCompatMap 7 +#define _XkbErrMissingSymInterps 8 +#define _XkbErrMissingGeometry 9 +#define _XkbErrIllegalDoodad 10 +#define _XkbErrIllegalTOCType 11 +#define _XkbErrIllegalContents 12 +#define _XkbErrEmptyFile 13 +#define _XkbErrFileNotFound 14 +#define _XkbErrFileCannotOpen 15 +#define _XkbErrBadValue 16 +#define _XkbErrBadMatch 17 +#define _XkbErrBadTypeName 18 +#define _XkbErrBadTypeWidth 19 +#define _XkbErrBadFileType 20 +#define _XkbErrBadFileVersion 21 +#define _XkbErrBadFileFormat 22 +#define _XkbErrBadAlloc 23 +#define _XkbErrBadLength 24 +#define _XkbErrXReqFailure 25 +#define _XkbErrBadImplementation 26 + +extern char * _XkbErrMessages[]; +extern unsigned _XkbErrCode; +extern char * _XkbErrLocation; +extern unsigned _XkbErrData; + +/***====================================================================***/ + +_XFUNCPROTOBEGIN + +extern char * XkbIndentText( +#if NeedFunctionPrototypes + unsigned /* size */ +#endif +); + +extern char * XkbAtomText( +#if NeedFunctionPrototypes + Display * /* dpy */, + Atom /* atm */, + unsigned /* format */ +#endif +); + +extern char * XkbKeysymText( +#if NeedFunctionPrototypes + KeySym /* sym */, + unsigned /* format */ +#endif +); + +extern char * XkbStringText( +#if NeedFunctionPrototypes + char * /* str */, + unsigned /* format */ +#endif +); + +extern char * XkbKeyNameText( +#if NeedFunctionPrototypes + char * /* name */, + unsigned /* format */ +#endif +); + +extern char * +XkbModIndexText( +#if NeedFunctionPrototypes + unsigned /* ndx */, + unsigned /* format */ +#endif +); + +extern char * +XkbModMaskText( +#if NeedFunctionPrototypes + unsigned /* mask */, + unsigned /* format */ +#endif +); + +extern char * XkbVModIndexText( +#if NeedFunctionPrototypes + Display * /* dpy */, + XkbDescPtr /* xkb */, + unsigned /* ndx */, + unsigned /* format */ +#endif +); + +extern char * XkbVModMaskText( +#if NeedFunctionPrototypes + Display * /* dpy */, + XkbDescPtr /* xkb */, + unsigned /* modMask */, + unsigned /* mask */, + unsigned /* format */ +#endif +); + +extern char * XkbConfigText( +#if NeedFunctionPrototypes + unsigned /* config */, + unsigned /* format */ +#endif +); + +extern char * XkbSIMatchText( +#if NeedFunctionPrototypes + unsigned /* type */, + unsigned /* format */ +#endif +); + +extern char * XkbIMWhichStateMaskText( +#if NeedFunctionPrototypes + unsigned /* use_which */, + unsigned /* format */ +#endif +); + +extern char * XkbAccessXDetailText( +#if NeedFunctionPrototypes + unsigned /* state */, + unsigned /* format */ +#endif +); + +extern char * XkbNKNDetailMaskText( +#if NeedFunctionPrototypes + unsigned /* detail */, + unsigned /* format */ +#endif +); + +extern char * XkbControlsMaskText( +#if NeedFunctionPrototypes + unsigned /* ctrls */, + unsigned /* format */ +#endif +); + +extern char * XkbGeomFPText( +#if NeedFunctionPrototypes + int /* val */, + unsigned /* format */ +#endif +); + +extern char * XkbDoodadTypeText( +#if NeedFunctionPrototypes + unsigned /* type */, + unsigned /* format */ +#endif +); + +extern char * XkbActionTypeText( +#if NeedFunctionPrototypes + unsigned /* type */, + unsigned /* format */ +#endif +); + +extern char * XkbActionText( +#if NeedFunctionPrototypes + Display * /* dpy */, + XkbDescPtr /* xkb */, + XkbAction * /* action */, + unsigned /* format */ +#endif +); + +extern char * XkbBehaviorText( +#if NeedFunctionPrototypes + XkbDescPtr /* xkb */, + XkbBehavior * /* behavior */, + unsigned /* format */ +#endif +); + +/***====================================================================***/ + +#define _XkbKSLower (1<<0) +#define _XkbKSUpper (1<<1) + +#define XkbKSIsLower(k) (_XkbKSCheckCase(k)&_XkbKSLower) +#define XkbKSIsUpper(k) (_XkbKSCheckCase(k)&_XkbKSUpper) +#define XkbKSIsKeypad(k) (((k)>=XK_KP_Space)&&((k)<=XK_KP_Equal)) +#define XkbKSIsDeadKey(k) \ + (((k)>=XK_dead_grave)&&((k)<=XK_dead_semivoiced_sound)) + +extern unsigned _XkbKSCheckCase( +#if NeedFunctionPrototypes + KeySym /* sym */ +#endif +); + +extern int XkbFindKeycodeByName( +#if NeedFunctionPrototypes + XkbDescPtr /* xkb */, + char * /* name */, + Bool /* use_aliases */ +#endif +); + +extern Bool XkbLookupGroupAndLevel( +#if NeedFunctionPrototypes + XkbDescPtr /* xkb */, + int /* key */, + int * /* mods_inout */, + int * /* grp_inout */, + int * /* lvl_rtrn */ +#endif +); + +/***====================================================================***/ + +#ifndef XKB_IN_SERVER + +extern Bool XkbLookupCanonicalRGBColor( +#if NeedFunctionPrototypes + char * /* def */, + XColor * /* color */ +#endif +); + +#endif + +/***====================================================================***/ + +extern char * XkbAtomGetString( +#if NeedFunctionPrototypes + Display * /* dpy */, + Atom /* atm */ +#endif +); + +extern Atom XkbInternAtom( +#if NeedFunctionPrototypes + Display * /* dpy */, + char * /* name */, + Bool /* onlyIfExists */ +#endif +); + +extern Status XkbChangeKbdDisplay( +#if NeedFunctionPrototypes + Display * /* newDpy */, + XkbFileInfo * /* result */ +#endif +); + +extern Atom XkbChangeAtomDisplay( +#if NeedFunctionPrototypes + Display * /* oldDpy */, + Display * /* newDpy */, + Atom /* atm */ +#endif +); + +extern void XkbInitAtoms( +#if NeedFunctionPrototypes + Display * /* dpy */ +#endif +); + +/***====================================================================***/ + +#ifdef _XKBGEOM_H_ + +#define XkbDW_Unknown 0 +#define XkbDW_Doodad 1 +#define XkbDW_Section 2 +typedef struct _XkbDrawable { + int type; + int priority; + union { + XkbDoodadPtr doodad; + XkbSectionPtr section; + } u; + struct _XkbDrawable * next; +} XkbDrawableRec,*XkbDrawablePtr; + +extern XkbDrawablePtr +XkbGetOrderedDrawables( +#if NeedFunctionPrototypes + XkbGeometryPtr /* geom */, + XkbSectionPtr /* section */ +#endif +); + +extern void +XkbFreeOrderedDrawables( +#if NeedFunctionPrototypes + XkbDrawablePtr /* draw */ +#endif +); + +#endif + +/***====================================================================***/ + +extern unsigned XkbConvertGetByNameComponents( +#if NeedFunctionPrototypes + Bool /* toXkm */, + unsigned /* orig */ +#endif +); + +extern unsigned XkbConvertXkbComponents( +#if NeedFunctionPrototypes + Bool /* toXkm */, + unsigned /* orig */ +#endif +); + +extern Bool XkbDetermineFileType( +#if NeedFunctionPrototypes + XkbFileInfo * /* xkb */, + int /* format */, + int * /* opts_missing */ +#endif +); + +extern Bool XkbNameMatchesPattern( +#if NeedFunctionPrototypes + char * /* name */, + char * /* pattern */ +#endif +); + +/***====================================================================***/ + +extern Bool XkbWriteXKBKeycodes( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* topLevel */, + Bool /* showImplicit */, + XkbFileAddOnFunc /* addOn */, + void * /* priv */ +#endif +); + +extern Bool XkbWriteXKBKeyTypes( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* topLevel */, + Bool /* showImplicit */, + XkbFileAddOnFunc /* addOn */, + void * /* priv */ +#endif +); + +extern Bool XkbWriteXKBCompatMap( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* topLevel */, + Bool /* showImplicit */, + XkbFileAddOnFunc /* addOn */, + void * /* priv */ +#endif +); + +extern Bool XkbWriteXKBSymbols( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* topLevel */, + Bool /* showImplicit */, + XkbFileAddOnFunc /* addOn */, + void * /* priv */ +#endif +); + +extern Bool XkbWriteXKBGeometry( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* topLevel */, + Bool /* showImplicit */, + XkbFileAddOnFunc /* addOn */, + void * /* priv */ +#endif +); + +extern Bool XkbWriteXKBSemantics( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* topLevel */, + Bool /* showImplicit */, + XkbFileAddOnFunc /* addOn */, + void * /* priv */ +#endif +); + +extern Bool XkbWriteXKBLayout( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* topLevel */, + Bool /* showImplicit */, + XkbFileAddOnFunc /* addOn */, + void * /* priv */ +#endif +); + +extern Bool XkbWriteXKBKeymap( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* topLevel */, + Bool /* showImplicit */, + XkbFileAddOnFunc /* addOn */, + void * /* priv */ +#endif +); + +extern Bool XkbWriteXKBFile( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* showImplicit */, + XkbFileAddOnFunc /* addOn */, + void * /* priv */ +#endif +); + +extern Bool XkbWriteCFile( +#if NeedFunctionPrototypes + FILE * /* file */, + char * /* name */, + XkbFileInfo * /* info */ +#endif +); + +extern Bool XkbWriteXKMFile( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */ +#endif +); + +extern Bool XkbWriteToServer( +#if NeedFunctionPrototypes + XkbFileInfo * /* result */ +#endif +); + +extern void XkbEnsureSafeMapName( +#if NeedFunctionPrototypes + char * /* name */ +#endif +); + +extern Bool XkbWriteXKBKeymapForNames( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbComponentNamesPtr /* names */, + Display * /* dpy */, + XkbDescPtr /* xkb */, + unsigned /* want */, + unsigned /* need */ +#endif +); + +/***====================================================================***/ + +extern Bool XkmProbe( +#if NeedFunctionPrototypes + FILE * /* file */ +#endif +); + +extern unsigned XkbReadFromServer( +#if NeedFunctionPrototypes + Display * /* dpy */, + unsigned /* need */, + unsigned /* want */, + XkbFileInfo * /* result */ +#endif +); + +extern unsigned XkmReadFile( +#if NeedFunctionPrototypes + FILE * /* file */, + unsigned /* need */, + unsigned /* want */, + XkbFileInfo * /* result */ +#endif +); + +#ifdef _XKMFORMAT_H_ + +extern Bool XkmReadTOC( +#if NeedFunctionPrototypes + FILE * /* file */, + xkmFileInfo * /* file_info */, + int /* max_toc */, + xkmSectionInfo * /* toc */ +#endif +); + +extern xkmSectionInfo *XkmFindTOCEntry( +#if NeedFunctionPrototypes + xkmFileInfo * /* finfo */, + xkmSectionInfo * /* toc */, + unsigned /* type */ +#endif +); + +extern Bool XkmReadFileSection( +#if NeedFunctionPrototypes + FILE * /* file */, + xkmSectionInfo * /* toc */, + XkbFileInfo * /* result */, + unsigned * /* loaded_rtrn */ +#endif +); + +extern char * XkmReadFileSectionName( +#if NeedFunctionPrototypes + FILE * /* file */, + xkmSectionInfo * /* toc */ +#endif +); + +#endif /* _XKMFORMAT_H */ + +_XFUNCPROTOEND + +#endif /* _XKBFILE_H_ */ diff --git a/include/X11/extensions/XKBrules.h b/include/X11/extensions/XKBrules.h new file mode 100644 index 0000000..ffc5138 --- /dev/null +++ b/include/X11/extensions/XKBrules.h @@ -0,0 +1,264 @@ +#ifndef _XKBRULES_H_ +#define _XKBRULES_H_ 1 + +/* $Xorg: XKBrules.h,v 1.3 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1996 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. + + ********************************************************/ + +/***====================================================================***/ + +typedef struct _XkbRF_VarDefs { + char * model; + char * layout; + char * variant; + char * options; + unsigned short sz_extra; + unsigned short num_extra; + char * extra_names; + char ** extra_values; +} XkbRF_VarDefsRec,*XkbRF_VarDefsPtr; + +typedef struct _XkbRF_VarDesc { + char * name; + char * desc; +} XkbRF_VarDescRec, *XkbRF_VarDescPtr; + +typedef struct _XkbRF_DescribeVars { + int sz_desc; + int num_desc; + XkbRF_VarDescPtr desc; +} XkbRF_DescribeVarsRec,*XkbRF_DescribeVarsPtr; + +typedef struct _XkbRF_Rule { + char * model; + char * layout; + char * variant; + char * option; + /* yields */ + char * keycodes; + char * symbols; + char * types; + char * compat; + char * geometry; + char * keymap; + unsigned flags; +} XkbRF_RuleRec,*XkbRF_RulePtr; + +#define XkbRF_PendingMatch (1L<<1) +#define XkbRF_Delayed (1L<<2) +#define XkbRF_Append (1L<<3) +#define XkbRF_Invalid (1L<<4) + +typedef struct _XkbRF_Rules { + XkbRF_DescribeVarsRec models; + XkbRF_DescribeVarsRec layouts; + XkbRF_DescribeVarsRec variants; + XkbRF_DescribeVarsRec options; + unsigned short sz_extra; + unsigned short num_extra; + char ** extra_names; + XkbRF_DescribeVarsPtr extra; + + unsigned short sz_rules; + unsigned short num_rules; + XkbRF_RulePtr rules; +} XkbRF_RulesRec, *XkbRF_RulesPtr; + +/***====================================================================***/ + +_XFUNCPROTOBEGIN + +extern Bool XkbRF_ApplyRule( +#if NeedFunctionPrototypes + XkbRF_RulePtr /* rule */, + XkbComponentNamesPtr /* names */ +#endif +); + +extern Bool XkbRF_CheckApplyRule( +#if NeedFunctionPrototypes + XkbRF_RulePtr /* rule */, + XkbRF_VarDefsPtr /* defs */, + XkbComponentNamesPtr /* names */ +#endif +); + +extern void XkbRF_ClearPartialMatches( +#if NeedFunctionPrototypes + XkbRF_RulesPtr /* rules */ +#endif +); + +extern Bool XkbRF_ApplyPartialMatches( +#if NeedFunctionPrototypes + XkbRF_RulesPtr /* rules */, + XkbComponentNamesPtr /* names */ +#endif +); + +extern void XkbRF_CheckApplyDelayedRules( +#if NeedFunctionPrototypes + XkbRF_RulesPtr /* rules */, + XkbRF_VarDefsPtr /* defs */, + XkbComponentNamesPtr /* names */ +#endif +); + +extern Bool XkbRF_CheckApplyRules( +#if NeedFunctionPrototypes + XkbRF_RulesPtr /* rules */, + XkbRF_VarDefsPtr /* defs */, + XkbComponentNamesPtr /* names */ +#endif +); + +extern char * XkbRF_SubstituteVars( +#if NeedFunctionPrototypes + char * /* p_name */, + XkbRF_VarDefsPtr /* defs */ +#endif +); + +extern Bool XkbRF_GetComponents( +#if NeedFunctionPrototypes + XkbRF_RulesPtr /* rules */, + XkbRF_VarDefsPtr /* var_defs */, + XkbComponentNamesPtr /* names */ +#endif +); + +extern XkbRF_RulePtr XkbRF_AddRule( +#if NeedFunctionPrototypes + XkbRF_RulesPtr /* rules */ +#endif +); + +extern Bool XkbRF_LoadRules( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbRF_RulesPtr /* rules */ +#endif +); + +extern Bool XkbRF_LoadRulesByName( +#if NeedFunctionPrototypes + char * /* base */, + char * /* locale */, + XkbRF_RulesPtr /* rules */ +#endif +); + +/***====================================================================***/ + +extern XkbRF_VarDescPtr XkbRF_AddVarDesc( +#if NeedFunctionPrototypes + XkbRF_DescribeVarsPtr /* vars */ +#endif +); + +extern XkbRF_VarDescPtr XkbRF_AddVarDescCopy( +#if NeedFunctionPrototypes + XkbRF_DescribeVarsPtr /* vars */, + XkbRF_VarDescPtr /* copy_from */ +#endif +); + +extern XkbRF_DescribeVarsPtr XkbRF_AddVarToDescribe( +#if NeedFunctionPrototypes + XkbRF_RulesPtr /* rules */, + char * /* name */ +#endif +); + +extern Bool XkbRF_LoadDescriptions( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbRF_RulesPtr /* rules */ +#endif +); + +extern Bool XkbRF_LoadDescriptionsByName( +#if NeedFunctionPrototypes + char * /* base */, + char * /* locale */, + XkbRF_RulesPtr /* rules */ +#endif +); + +extern XkbRF_RulesPtr XkbRF_Load( +#if NeedFunctionPrototypes + char * /* base */, + char * /* locale */, + Bool /* wantDesc */, + Bool /* wantRules */ +#endif +); + +extern XkbRF_RulesPtr XkbRF_Create( +#if NeedFunctionPrototypes + int /* sz_rules */, + int /* sz_extra */ +#endif +); + +/***====================================================================***/ + +extern void XkbRF_Free( +#if NeedFunctionPrototypes + XkbRF_RulesPtr /* rules */, + Bool /* freeRules */ +#endif +); + + +/***====================================================================***/ + +#define _XKB_RF_NAMES_PROP_ATOM "_XKB_RULES_NAMES" +#define _XKB_RF_NAMES_PROP_MAXLEN 1024 + +#ifndef XKB_IN_SERVER + +extern Bool XkbRF_GetNamesProp( +#if NeedFunctionPrototypes + Display * /* dpy */, + char ** /* rules_file_rtrn */, + XkbRF_VarDefsPtr /* var_defs_rtrn */ +#endif +); + +extern Bool XkbRF_SetNamesProp( +#if NeedFunctionPrototypes + Display * /* dpy */, + char * /* rules_file */, + XkbRF_VarDefsPtr /* var_defs */ +#endif +); + +#endif + +_XFUNCPROTOEND + +#endif /* _XKBRULES_H_ */ diff --git a/include/X11/extensions/XKM.h b/include/X11/extensions/XKM.h new file mode 100644 index 0000000..c6c9f51 --- /dev/null +++ b/include/X11/extensions/XKM.h @@ -0,0 +1,70 @@ +/* $Xorg: XKM.h,v 1.3 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ +#ifndef XKM_H +#define XKM_H 1 + +#define XkmFileVersion 15 + +#define XkmIllegalFile -1 +#define XkmSemanticsFile 20 +#define XkmLayoutFile 21 +#define XkmKeymapFile 22 +#define XkmGeometryFile 23 + +#define XkmTypesIndex 0 +#define XkmCompatMapIndex 1 +#define XkmSymbolsIndex 2 +#define XkmIndicatorsIndex 3 +#define XkmKeyNamesIndex 4 +#define XkmGeometryIndex 5 +#define XkmVirtualModsIndex 6 +#define XkmLastIndex XkmVirtualModsIndex + +#define XkmTypesMask (1<<0) +#define XkmCompatMapMask (1<<1) +#define XkmSymbolsMask (1<<2) +#define XkmIndicatorsMask (1<<3) +#define XkmKeyNamesMask (1<<4) +#define XkmGeometryMask (1<<5) +#define XkmVirtualModsMask (1<<6) +#define XkmLegalIndexMask (0x7f) +#define XkmAllIndicesMask (0x7f) + +#define XkmSemanticsRequired (XkmCompatMapMask) +#define XkmSemanticsOptional (XkmTypesMask|XkmVirtualModsMask|XkmIndicatorsMask) +#define XkmSemanticsLegal (XkmSemanticsRequired|XkmSemanticsOptional) +#define XkmLayoutRequired (XkmKeyNamesMask|XkmSymbolsMask|XkmTypesMask) +#define XkmLayoutOptional (XkmVirtualModsMask|XkmGeometryMask) +#define XkmLayoutLegal (XkmLayoutRequired|XkmLayoutOptional) +#define XkmKeymapRequired (XkmSemanticsRequired|XkmLayoutRequired) +#define XkmKeymapOptional ((XkmSemanticsOptional|XkmLayoutOptional)&(~XkmKeymapRequired)) +#define XkmKeymapLegal (XkmKeymapRequired|XkmKeymapOptional) + +#define XkmLegalSection(m) (((m)&(~XkmKeymapLegal))==0) +#define XkmSingleSection(m) (XkmLegalSection(m)&&(((m)&(~(m)+1))==(m))) + +#endif /* XKM_H */ diff --git a/include/X11/extensions/XKMformat.h b/include/X11/extensions/XKMformat.h new file mode 100644 index 0000000..9e70845 --- /dev/null +++ b/include/X11/extensions/XKMformat.h @@ -0,0 +1,299 @@ +/* $Xorg: XKMformat.h,v 1.3 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ +#ifndef _XKMFORMAT_H_ +#define _XKMFORMAT_H_ 1 + +#include +#include +#include "XKM.h" + +typedef struct _xkmFileInfo { + CARD8 type; + CARD8 min_kc; + CARD8 max_kc; + CARD8 num_toc; + CARD16 present B16; + CARD16 pad B16; +} xkmFileInfo; +#define sz_xkmFileInfo 8 + +typedef struct _xkmSectionInfo { + CARD16 type B16; + CARD16 format B16; + CARD16 size B16; + CARD16 offset B16; +} xkmSectionInfo; +#define sz_xkmSectionInfo 8 + +typedef struct _xkmKeyTypeDesc { + CARD8 realMods; + CARD8 numLevels; + CARD16 virtualMods B16; + CARD8 nMapEntries; + CARD8 nLevelNames; + CARD8 preserve; + CARD8 pad; +} xkmKeyTypeDesc; +#define sz_xkmKeyTypeDesc 8 + +typedef struct _xkmKTMapEntryDesc { + CARD8 level; + CARD8 realMods; + CARD16 virtualMods B16; +} xkmKTMapEntryDesc; +#define sz_xkmKTMapEntryDesc 4 + +typedef struct _xkmModsDesc { + CARD8 realMods; + CARD8 pad; + CARD16 virtualMods B16; +} xkmModsDesc; +#define sz_xkmModsDesc 4 + +typedef struct _xkmVModMapDesc { + CARD8 key; + CARD8 pad; + CARD16 vmods B16; +} xkmVModMapDesc; +#define sz_xkmVModMapDesc 4 + +typedef struct _xkmSymInterpretDesc { + CARD32 sym B32; + CARD8 mods; + CARD8 match; + CARD8 virtualMod; + CARD8 flags; + CARD8 actionType; + CARD8 actionData[7]; +} xkmSymInterpretDesc; +#define sz_xkmSymInterpretDesc 16 + +typedef struct _xkmBehaviorDesc { + CARD8 type; + CARD8 data; + CARD16 pad B16; +} xkmBehaviorDesc; +#define sz_xkmBehaviorDesc 4 + +typedef struct _xkmActionDesc { + CARD8 type; + CARD8 data[7]; +} xkmActionDesc; +#define sz_xkmActionDesc 8 + +#define XkmKeyHasTypes (0x0f) +#define XkmKeyHasGroup1Type (1<<0) +#define XkmKeyHasGroup2Type (1<<1) +#define XkmKeyHasGroup3Type (1<<2) +#define XkmKeyHasGroup4Type (1<<3) +#define XkmKeyHasActions (1<<4) +#define XkmKeyHasBehavior (1<<5) +#define XkmRepeatingKey (1<<6) +#define XkmNonRepeatingKey (1<<7) + +typedef struct _xkmKeySymMapDesc { + CARD8 width; + CARD8 num_groups; + CARD8 modifier_map; + CARD8 flags; +} xkmKeySymMapDesc; +#define sz_xkmKeySymMapDesc 4 + +typedef struct _xkmIndicatorMapDesc { + CARD8 indicator; + CARD8 flags; + CARD8 which_mods; + CARD8 real_mods; + CARD16 vmods B16; + CARD8 which_groups; + CARD8 groups; + CARD32 ctrls B32; +} xkmIndicatorMapDesc; +#define sz_xkmIndicatorMapDesc 12 + +typedef struct _xkmGeometryDesc { + CARD16 width_mm B16; + CARD16 height_mm B16; + CARD8 base_color_ndx; + CARD8 label_color_ndx; + CARD16 num_properties B16; + CARD16 num_colors B16; + CARD16 num_shapes B16; + CARD16 num_sections B16; + CARD16 num_doodads B16; + CARD16 num_key_aliases B16; + CARD16 pad1 B16; +} xkmGeometryDesc; +#define sz_xkmGeometryDesc 20 + +typedef struct _xkmPointDesc { + INT16 x B16; + INT16 y B16; +} xkmPointDesc; +#define sz_xkmPointDesc 4 + +typedef struct _xkmOutlineDesc { + CARD8 num_points; + CARD8 corner_radius; + CARD16 pad B16; +} xkmOutlineDesc; +#define sz_xkmOutlineDesc 4 + +typedef struct _xkmShapeDesc { + CARD8 num_outlines; + CARD8 primary_ndx; + CARD8 approx_ndx; + CARD8 pad; +} xkmShapeDesc; +#define sz_xkmShapeDesc 4 + +typedef struct _xkmSectionDesc { + INT16 top B16; + INT16 left B16; + CARD16 width B16; + CARD16 height B16; + INT16 angle B16; + CARD8 priority; + CARD8 num_rows; + CARD8 num_doodads; + CARD8 num_overlays; + CARD16 pad2 B16; +} xkmSectionDesc; +#define sz_xkmSectionDesc 16 + +typedef struct _xkmRowDesc { + INT16 top B16; + INT16 left B16; + CARD8 num_keys; + BOOL vertical; + CARD16 pad B16; +} xkmRowDesc; +#define sz_xkmRowDesc 8 + +typedef struct _xkmKeyDesc { + CARD8 name[XkbKeyNameLength]; + INT16 gap B16; + CARD8 shape_ndx; + CARD8 color_ndx; +} xkmKeyDesc; +#define sz_xkmKeyDesc 8 + +typedef struct _xkmOverlayDesc { + CARD8 num_rows; + CARD8 pad1; + CARD16 pad2 B16; +} xkmOverlayDesc; +#define sz_xkmOverlayDesc 4 + +typedef struct _xkmOverlayRowDesc { + CARD8 row_under; + CARD8 num_keys; + CARD16 pad B16; +} xkmOverlayRowDesc; +#define sz_xkmOverlayRowDesc 4 + +typedef struct _xkmOverlayKeyDesc { + char over[XkbKeyNameLength]; + char under[XkbKeyNameLength]; +} xkmOverlayKeyDesc; +#define sz_xkmOverlayKeyDesc 8 + +typedef struct _xkmShapeDoodadDesc { + CARD8 type; + CARD8 priority; + INT16 top B16; + INT16 left B16; + INT16 angle B16; + CARD8 color_ndx; + CARD8 shape_ndx; + CARD16 pad B16; + CARD32 pad1 B32; +} xkmShapeDoodadDesc; +#define sz_xkmShapeDoodadDesc 16 + +typedef struct _xkmTextDoodadDesc { + CARD8 type; + CARD8 priority; + INT16 top B16; + INT16 left B16; + INT16 angle B16; + CARD16 width B16; + CARD16 height B16; + CARD8 color_ndx; + CARD8 pad1; + CARD16 pad2 B16; +} xkmTextDoodadDesc; +#define sz_xkmTextDoodadDesc 16 + +typedef struct _xkmIndicatorDoodadDesc { + CARD8 type; + CARD8 priority; + INT16 top B16; + INT16 left B16; + CARD8 shape_ndx; + CARD8 on_color_ndx; + CARD8 off_color_ndx; + CARD8 pad1; + CARD16 pad2 B16; + CARD32 pad3 B32; +} xkmIndicatorDoodadDesc; +#define sz_xkmIndicatorDoodadDesc 16 + +typedef struct _xkmLogoDoodadDesc { + CARD8 type; + CARD8 priority; + INT16 top B16; + INT16 left B16; + INT16 angle B16; + CARD8 color_ndx; + CARD8 shape_ndx; + CARD16 pad B16; + CARD32 pad1 B32; +} xkmLogoDoodadDesc; +#define sz_xkmLogoDoodadDesc 16 + +typedef struct _xkmAnyDoodadDesc { + CARD8 type; + CARD8 priority; + INT16 top B16; + INT16 left B16; + CARD16 pad1 B16; + CARD32 pad2 B32; + CARD32 pad3 B32; +} xkmAnyDoodadDesc; +#define sz_xkmAnyDoodadDesc 16 + +typedef union _xkmDoodadDesc { + xkmAnyDoodadDesc any; + xkmShapeDoodadDesc shape; + xkmTextDoodadDesc text; + xkmIndicatorDoodadDesc indicator; + xkmLogoDoodadDesc logo; +} xkmDoodadDesc; +#define sz_xkmDoodadDesc 16 + +#endif /* _XKMFORMAT_H_ */ diff --git a/src/XKBfileInt.h b/src/XKBfileInt.h new file mode 100644 index 0000000..67ef319 --- /dev/null +++ b/src/XKBfileInt.h @@ -0,0 +1,82 @@ +#ifndef _XKBFILEINT_H_ +#define _XKBFILEINT_H_ 1 + +/* $Xorg: XKBfileInt.h,v 1.3 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ + +#include "XKBfile.h" + +#ifdef DEBUG +#define _XkbLibError(c,l,d) \ + { fprintf(stderr,"xkbfile: %s in %s\n",_XkbErrMessages[c],(l)); \ + _XkbErrCode= (c); _XkbErrLocation= (l); _XkbErrData= (d); } +#else +#define _XkbLibError(c,l,d) \ + { _XkbErrCode= (c); _XkbErrLocation= (l); _XkbErrData= (d); } +#endif + +#ifndef XKB_IN_SERVER + +#define _XkbAlloc(s) malloc((s)) +#define _XkbCalloc(n,s) calloc((n),(s)) +#define _XkbRealloc(o,s) realloc((o),(s)) +#define _XkbTypedAlloc(t) ((t *)malloc(sizeof(t))) +#define _XkbTypedCalloc(n,t) ((t *)calloc((n),sizeof(t))) +#define _XkbTypedRealloc(o,n,t) \ + ((o)?(t *)realloc((o),(n)*sizeof(t)):_XkbTypedCalloc(n,t)) +#define _XkbClearElems(a,f,l,t) bzero(&(a)[f],((l)-(f)+1)*sizeof(t)) +#define _XkbFree(p) free(p) + +#ifndef PATH_MAX +#ifdef MAXPATHLEN +#define PATH_MAX MAXPATHLEN +#else +#define PATH_MAX 1024 +#endif +#endif + +#endif + +_XFUNCPROTOBEGIN + +extern char * _XkbDupString( +#if NeedFunctionPrototypes + char * /* old_str */ +#endif +); + +extern int _XkbStrCaseCmp( +#if NeedFunctionPrototypes + char * /* str1 */, + char * /* str2 */ +#endif +); +#define _XkbStrCaseEqual(s1,s2) (_XkbStrCaseCmp(s1,s2)==0) + +_XFUNCPROTOEND + +#endif /* _XKBFILEINT_H_ */ diff --git a/src/cout.c b/src/cout.c new file mode 100644 index 0000000..4d7c147 --- /dev/null +++ b/src/cout.c @@ -0,0 +1,1242 @@ +/* $Xorg: cout.c,v 1.3 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif +#include +#include +#include +#include + +#include "XKMformat.h" +#include "XKBfileInt.h" + +#define lowbit(x) ((x) & (-(x))) + +static Bool +#if NeedFunctionPrototypes +WriteCHdrVMods(FILE *file,Display *dpy,XkbDescPtr xkb) +#else +WriteCHdrVMods(file,dpy,xkb) + FILE * file; + Display * dpy; + XkbDescPtr xkb; +#endif +{ +register int i,nOut; + + if ((!xkb)||(!xkb->names)||(!xkb->names->vmods)) + return False; + for (i=nOut=0;inames->vmods[i]!=None) { + fprintf(file,"%s#define vmod_%s %d\n",(nOut<1?"\n":""), + XkbAtomText(dpy,xkb->names->vmods[i],XkbCFile), + i); + nOut++; + } + } + for (i=nOut=0;inames->vmods[i]!=None) { + fprintf(file,"%s#define vmod_%sMask (1<<%d)\n", + (nOut<1?"\n":""), + XkbAtomText(dpy,xkb->names->vmods[i],XkbCFile) + ,i); + nOut++; + } + } + if (nOut>0) + fprintf(file,"\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrKeycodes(FILE *file,XkbDescPtr xkb) +#else +WriteCHdrKeycodes(file,xkb) + FILE * file; + XkbDescPtr xkb; +#endif +{ +Atom kcName; +register unsigned i; +char buf[8]; + + if ((!xkb)||(!xkb->names)||(!xkb->names->keys)) { + _XkbLibError(_XkbErrMissingNames,"WriteCHdrKeycodes",0); + return False; + } + kcName= xkb->names->keycodes; + buf[4]= '\0'; + if (xkb->names->keycodes!=None) + fprintf(file,"/* keycodes name is \"%s\" */\n", + XkbAtomText(xkb->dpy,kcName,XkbMessage)); + fprintf(file,"static XkbKeyNameRec keyNames[NUM_KEYS]= {\n"); + for (i=0;i<=xkb->max_key_code;i++) { + sprintf(buf,"\"%s\"",XkbKeyNameText(xkb->names->keys[i].name,XkbCFile)); + if (i!=xkb->max_key_code) { + fprintf(file," { %6s },",buf); + if ((i&3)==3) + fprintf(file,"\n"); + } + else { + fprintf(file," { %6s }\n",buf); + } + } + fprintf(file,"};\n"); + return True; +} + +static void +#if NeedFunctionPrototypes +WriteTypePreserve( FILE * file, + Display * dpy, + char * prefix, + XkbDescPtr xkb, + XkbKeyTypePtr type) +#else +WriteTypePreserve(file,dpy,prefix,xkb,type) + FILE * file; + Display * dpy; + char * prefix; + XkbDescPtr xkb; + XkbKeyTypePtr type; +#endif +{ +register unsigned i; +XkbModsPtr pre; + + fprintf(file,"static XkbModsRec preserve_%s[%d]= {\n",prefix, + type->map_count); + for (i=0,pre=type->preserve;imap_count;i++,pre++) { + if (i!=0) + fprintf(file,",\n"); + fprintf(file," { %15s, ",XkbModMaskText(pre->mask,XkbCFile)); + fprintf(file,"%15s, ",XkbModMaskText(pre->real_mods,XkbCFile)); + fprintf(file,"%15s }",XkbVModMaskText(dpy,xkb,0,pre->vmods,XkbCFile)); + } + fprintf(file,"\n};\n"); + return; +} + +static void +#if NeedFunctionPrototypes +WriteTypeInitFunc(FILE *file,Display *dpy,XkbDescPtr xkb) +#else +WriteTypeInitFunc(file,dpy,xkb) + FILE * file; + Display * dpy; + XkbDescPtr xkb; +#endif +{ +register unsigned i,n; +XkbKeyTypePtr type; +Atom * names; +char prefix[32]; + + fprintf(file,"\n\nstatic void\n#if NeedFunctionPrototypes\n"); + fprintf(file,"initTypeNames(DPYTYPE dpy)\n#else\n"); + fprintf(file,"initTypeNames(dpy)\nDPYTYPE dpy;\n#endif\n{\n"); + for (i=0,type=xkb->map->types;imap->num_types;i++,type++) { + strcpy(prefix,XkbAtomText(dpy,type->name,XkbCFile)); + if (type->name!=None) + fprintf(file," dflt_types[%d].name= GET_ATOM(dpy,\"%s\");\n",i, + XkbAtomText(dpy,type->name,XkbCFile)); + names= type->level_names; + if (names!=NULL) { + char *tmp; + for (n=0;nnum_levels;n++) { + if (names[n]==None) + continue; + tmp= XkbAtomText(dpy,names[n],XkbCFile); + if (tmp==NULL) + continue; + fprintf(file," lnames_%s[%d]= ",prefix,n); + fprintf(file,"GET_ATOM(dpy,\"%s\");\n",tmp); + } + } + } + fprintf(file,"}\n"); + return; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrKeyTypes(FILE *file,Display *dpy,XkbDescPtr xkb) +#else +WriteCHdrKeyTypes(file,dpy,xkb) + FILE * file; + Display * dpy; + XkbDescPtr xkb; +#endif +{ +register unsigned i,n; +XkbClientMapPtr map; +XkbKeyTypePtr type; +char prefix[32]; + + if ((!xkb)||(!xkb->map)||(!xkb->map->types)) { + _XkbLibError(_XkbErrMissingTypes,"WriteCHdrKeyTypes",0); + return False; + } + if (xkb->map->num_typesmap; + if ((xkb->names!=NULL)&&(xkb->names->types!=None)) { + fprintf(file,"/* types name is \"%s\" */\n", + XkbAtomText(dpy,xkb->names->types,XkbCFile)); + } + for (i=0,type=map->types;inum_types;i++,type++) { + strcpy(prefix,XkbAtomText(dpy,type->name,XkbCFile)); + + if (type->map_count>0) { + XkbKTMapEntryPtr entry; + entry= type->map; + fprintf(file,"static XkbKTMapEntryRec map_%s[%d]= {\n",prefix, + type->map_count); + for (n=0;n<(unsigned)type->map_count;n++,entry++) { + if (n!=0) + fprintf(file,",\n"); + fprintf(file," { %d, %6d, { %15s, %15s, %15s } }", + entry->active, + entry->level, + XkbModMaskText(entry->mods.mask,XkbCFile), + XkbModMaskText(entry->mods.real_mods,XkbCFile), + XkbVModMaskText(dpy,xkb,0,entry->mods.vmods,XkbCFile)); + } + fprintf(file,"\n};\n"); + + if (type->preserve) + WriteTypePreserve(file,dpy,prefix,xkb,type); + } + if (type->level_names!=NULL) { + fprintf(file,"static Atom lnames_%s[%d];\n",prefix, + type->num_levels); + } + fprintf(file,"\n"); + } + fprintf(file,"static XkbKeyTypeRec dflt_types[]= {\n"); + for (i=0,type=map->types;i<(unsigned)map->num_types;i++,type++) { + strcpy(prefix,XkbAtomText(dpy,type->name,XkbCFile)); + if (i!=0) fprintf(file,",\n"); + fprintf(file," {\n { %15s, %15s, %15s },\n", + XkbModMaskText(type->mods.mask,XkbCFile), + XkbModMaskText(type->mods.real_mods,XkbCFile), + XkbVModMaskText(dpy,xkb,0,type->mods.vmods,XkbCFile)); + fprintf(file," %d,\n",type->num_levels); + fprintf(file," %d,",type->map_count); + if (type->map_count>0) + fprintf(file," map_%s,",prefix); + else fprintf(file," NULL,"); + if (type->preserve) + fprintf(file," preserve_%s,\n",prefix); + else fprintf(file," NULL,\n"); + if (type->level_names!=NULL) + fprintf(file," None, lnames_%s\n }",prefix); + else fprintf(file," None, NULL\n }"); + } + fprintf(file,"\n};\n"); + fprintf(file,"#define num_dflt_types (sizeof(dflt_types)/sizeof(XkbKeyTypeRec))\n"); + WriteTypeInitFunc(file,dpy,xkb); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrCompatMap(FILE *file,Display *dpy,XkbDescPtr xkb) +#else +WriteCHdrCompatMap(file,dpy,xkb) + FILE * file; + Display * dpy; + XkbDescPtr xkb; +#endif +{ +register unsigned i; +XkbCompatMapPtr compat; +XkbSymInterpretPtr interp; + + if ((!xkb)||(!xkb->compat)||(!xkb->compat->sym_interpret)) { + _XkbLibError(_XkbErrMissingSymInterps,"WriteCHdrInterp",0); + return False; + } + compat= xkb->compat; + if ((xkb->names!=NULL)&&(xkb->names->compat!=None)) { + fprintf(file,"/* compat name is \"%s\" */\n", + XkbAtomText(dpy,xkb->names->compat,XkbCFile)); + } + fprintf(file,"static XkbSymInterpretRec dfltSI[%d]= {\n", + compat->num_si); + interp= compat->sym_interpret; + for (i=0;inum_si;i++,interp++) { + XkbAction *act; + act= (XkbAction *)&interp->act; + if (i!=0) fprintf(file,",\n"); + fprintf(file," { %s, ",XkbKeysymText(interp->sym,XkbCFile)); + fprintf(file,"0x%04x,\n",interp->flags); + fprintf(file," %s, ",XkbSIMatchText(interp->match,XkbCFile)); + fprintf(file,"%s,\n",XkbModMaskText(interp->mods,XkbCFile)); + fprintf(file," %d,\n",interp->virtual_mod); + fprintf(file," %s }",XkbActionText(dpy,xkb,act,XkbCFile)); + } + fprintf(file,"\n};\n"); + fprintf(file, + "#define num_dfltSI (sizeof(dfltSI)/sizeof(XkbSymInterpretRec))\n"); + fprintf(file,"\nstatic XkbCompatMapRec compatMap= {\n"); + fprintf(file," dfltSI,\n"); + fprintf(file," { /* group compatibility */\n "); + for (i=0;icompat->groups[i]; + fprintf(file,"%s{ %12s, %12s, %12s }", + ((i==0)?"":",\n "), + XkbModMaskText(gc->mask,XkbCFile), + XkbModMaskText(gc->real_mods,XkbCFile), + XkbVModMaskText(xkb->dpy,xkb,0,gc->vmods,XkbCFile)); + } + fprintf(file,"\n },\n"); + fprintf(file," num_dfltSI, num_dfltSI\n"); + fprintf(file,"};\n\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrSymbols(FILE *file,XkbDescPtr xkb) +#else +WriteCHdrSymbols(file,xkb) + FILE * file; + XkbDescPtr xkb; +#endif +{ +register unsigned i; + + if ((!xkb)||(!xkb->map)||(!xkb->map->syms)||(!xkb->map->key_sym_map)) { + _XkbLibError(_XkbErrMissingSymbols,"WriteCHdrSymbols",0); + return False; + } + fprintf(file,"#define NUM_SYMBOLS %d\n",xkb->map->num_syms); + if (xkb->map->num_syms>0) { + register KeySym *sym; + sym= xkb->map->syms; + fprintf(file,"static KeySym symCache[NUM_SYMBOLS]= {\n"); + for (i=0;imap->num_syms;i++,sym++) { + if (i==0) fprintf(file," "); + else if (i%4==0) fprintf(file,",\n "); + else fprintf(file,", "); + fprintf(file,"%15s",XkbKeysymText(*sym,XkbCFile)); + } + fprintf(file,"\n};\n"); + } + if (xkb->max_key_code>0) { + register XkbSymMapPtr map; + map= xkb->map->key_sym_map; + fprintf(file,"static XkbSymMapRec symMap[NUM_KEYS]= {\n"); + for (i=0;i<=xkb->max_key_code;i++,map++) { + if (i==0) fprintf(file," "); + else if ((i&3)==0) fprintf(file,",\n "); + else fprintf(file,", "); + fprintf(file,"{ %2d, 0x%x, %3d }",map->kt_index,map->group_info, + map->offset); + } + fprintf(file,"\n};\n"); + } + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrClientMap(FILE *file,Display *dpy,XkbDescPtr xkb) +#else +WriteCHdrClientMap(file,dpy,xkb) + FILE * file; + Display * dpy; + XkbDescPtr xkb; +#endif +{ + if ((!xkb)||(!xkb->map)||(!xkb->map->syms)||(!xkb->map->key_sym_map)) { + _XkbLibError(_XkbErrMissingSymbols,"WriteCHdrClientMap",0); + return False; + } + if (!WriteCHdrKeyTypes(file,dpy,xkb)) + return False; + if (!WriteCHdrSymbols(file,xkb)) + return False; + fprintf(file,"static XkbClientMapRec clientMap= {\n"); + fprintf(file," NUM_TYPES, NUM_TYPES, types, \n"); + fprintf(file," NUM_SYMBOLS, NUM_SYMBOLS, symCache, symMap\n"); + fprintf(file,"};\n\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrServerMap(FILE *file,Display *dpy,XkbDescPtr xkb) +#else +WriteCHdrServerMap(file,dpy,xkb) + FILE * file; + Display * dpy; + XkbDescPtr xkb; +#endif +{ +register unsigned i; + + if ((!xkb)||(!xkb->map)||(!xkb->map->syms)||(!xkb->map->key_sym_map)) { + _XkbLibError(_XkbErrMissingSymbols,"WriteCHdrServerMap",0); + return False; + } + if (xkb->server->num_acts>0) { + register XkbAnyAction *act; + act= (XkbAnyAction *)xkb->server->acts; + fprintf(file,"#define NUM_ACTIONS %d\n",xkb->server->num_acts); + fprintf(file,"static XkbAnyAction actionCache[NUM_ACTIONS]= {\n"); + for (i=0;iserver->num_acts;i++,act++) { + if (i==0) fprintf(file," "); + else fprintf(file,",\n "); + fprintf(file,"%s",XkbActionText(dpy,xkb,(XkbAction *)act,XkbCFile)); + } + fprintf(file,"\n};\n"); + } + fprintf(file,"static unsigned short keyActions[NUM_KEYS]= {\n"); + for (i=0;i<=xkb->max_key_code;i++) { + if (i==0) fprintf(file," "); + else if ((i&0xf)==0) fprintf(file,",\n "); + else fprintf(file,", "); + fprintf(file,"%2d",xkb->server->key_acts[i]); + } + fprintf(file,"\n};\n"); + fprintf(file,"static XkbBehavior behaviors[NUM_KEYS]= {\n"); + for (i=0;i<=xkb->max_key_code;i++) { + if (i==0) fprintf(file," "); + else if ((i&0x3)==0) fprintf(file,",\n "); + else fprintf(file,", "); + if (xkb->server->behaviors) { + fprintf(file,"%s", + XkbBehaviorText(xkb,&xkb->server->behaviors[i],XkbCFile)); + } + else fprintf(file,"{ 0, 0 }"); + } + fprintf(file,"\n};\n"); + fprintf(file,"static unsigned char explicit_parts[NUM_KEYS]= {\n"); + for (i=0;i<=xkb->max_key_code;i++) { + if (i==0) fprintf(file," "); + else if ((i&0x7)==0) fprintf(file,",\n "); + else fprintf(file,", "); + if ((xkb->server->explicit==NULL)||(xkb->server->explicit[i]==0)) + fprintf(file," 0"); + else fprintf(file,"0x%02x",xkb->server->explicit[i]); + } + fprintf(file,"\n};\n"); + fprintf(file,"static unsigned short vmodmap[NUM_KEYS]= {\n"); + for (i=0;imax_key_code;i++) { + if (i==0) fprintf(file," "); + else if ((i&0x7)==0) fprintf(file,",\n "); + else fprintf(file,", "); + if ((xkb->server->vmodmap==NULL)||(xkb->server->vmodmap[i]==0)) + fprintf(file," 0"); + else fprintf(file,"0x%04x",xkb->server->vmodmap[i]); + } + fprintf(file,"};\n"); + fprintf(file,"static XkbServerMapRec serverMap= {\n"); + fprintf(file," %d, %d, (XkbAction *)actionCache,\n", + xkb->server->num_acts,xkb->server->num_acts); + fprintf(file," behaviors, keyActions, explicit_parts,\n"); + for (i=0;iserver->vmods[i]); + } + fprintf(file," },\n"); + fprintf(file," vmodmap\n"); + fprintf(file,"};\n\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrIndicators(FILE *file,Display *dpy,XkbDescPtr xkb) +#else +WriteCHdrIndicators(file,dpy,xkb) + FILE * file; + Display * dpy; + XkbDescPtr xkb; +#endif +{ +register int i,nNames; +XkbIndicatorMapPtr imap; + + if (xkb->indicators==NULL) + return True; + fprintf(file,"static XkbIndicatorRec indicators= {\n"); + fprintf(file," 0x%x,\n {\n",xkb->indicators->phys_indicators); + for (imap=xkb->indicators->maps,i=nNames=0;iflags, + XkbIMWhichStateMaskText(imap->which_groups,XkbCFile), + imap->groups, + XkbIMWhichStateMaskText(imap->which_mods,XkbCFile), + XkbModMaskText(imap->mods.mask,XkbCFile)); + fprintf(file," %s, %s, %s }", + XkbModMaskText(imap->mods.real_mods,XkbCFile), + XkbVModMaskText(dpy,xkb,0,imap->mods.vmods,XkbCFile), + XkbControlsMaskText(imap->ctrls,XkbCFile)); + if (xkb->names && (xkb->names->indicators[i]!=None)) + nNames++; + } + fprintf(file,"\n }\n};\n"); + if (nNames>0) { + fprintf(file,"static void\n#if NeedFunctionPrototypes\n"); + fprintf(file,"initIndicatorNames(DPYTYPE dpy,XkbDescPtr xkb)\n"); + fprintf(file,"#else\ninitIndicatorNames(dpy,xkb)\n"); + fprintf(file," DPYTYPE dpy;\n"); + fprintf(file," XkbDescPtr xkb;\n#endif\n{\n"); + for (i=0;inames->indicators[i]==None) + continue; + name= xkb->names->indicators[i]; + fprintf(file," xkb->names->indicators[%2d]= ",i); + fprintf(file,"GET_ATOM(dpy,\"%s\");\n", + XkbAtomText(dpy,name,XkbCFile)); + } + fprintf(file,"}\n"); + } + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrGeomProps(FILE *file,XkbDescPtr xkb,XkbGeometryPtr geom) +#else +WriteCHdrGeomProps(file,xkb,geom) + FILE * file; + XkbDescPtr xkb; + XkbGeometryPtr geom; +#endif +{ + if (geom->num_properties>0) { + register int i; + fprintf(file,"\nstatic XkbPropertyRec g_props[%d]= {\n", + geom->num_properties); + for (i=0;inum_properties;i++) { + fprintf(file,"%s { \"%s\", \"%s\" }",(i==0?"":",\n"), + XkbStringText(geom->properties[i].name,XkbCFile), + XkbStringText(geom->properties[i].value,XkbCFile)); + } + fprintf(file,"\n};\n"); + } + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrGeomColors(FILE *file,XkbDescPtr xkb,XkbGeometryPtr geom) +#else +WriteCHdrGeomColors(file,xkb,geom) + FILE * file; + XkbDescPtr xkb; + XkbGeometryPtr geom; +#endif +{ + if (geom->num_colors>0) { + register int i; + fprintf(file,"\nstatic XkbColorRec g_colors[%d]= {\n",geom->num_colors); + for (i=0;inum_colors;i++) { + fprintf(file,"%s { %3d, \"%s\" }",(i==0?"":",\n"), + geom->colors[i].pixel, + XkbStringText(geom->colors[i].spec,XkbCFile)); + } + fprintf(file,"\n};\n"); + } + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrGeomOutlines(FILE *file,int nOL,XkbOutlinePtr ol,int shapeNdx) +#else +WriteCHdrGeomOutlines(file,nOL,ol,shapeNdx) + FILE * file; + int nOL; + XkbOutlinePtr ol; + int shapeNdx; +#endif +{ +register int o,p; + + + for (o=0;oshapes;snum_shapes;s++,shape++) { + WriteCHdrGeomOutlines(file,shape->num_outlines,shape->outlines,s); + } + fprintf(file,"\n\nstatic XkbShapeRec g_shapes[%d]= {\n",geom->num_shapes); + for (s=0,shape=geom->shapes;snum_shapes;s++,shape++) { + fprintf(file,"%s { None, %3d, %3d, ol_sh%02d, ", + (s==0?"":",\n"),shape->num_outlines, + shape->num_outlines,s); + if (shape->approx) { + fprintf(file,"&ol_sh%02d[%2d], ",s, + XkbOutlineIndex(shape,shape->approx)); + } + else fprintf(file," NULL, "); + if (shape->primary) { + fprintf(file,"&ol_sh%02d[%2d],\n",s, + XkbOutlineIndex(shape,shape->primary)); + } + else fprintf(file," NULL,\n"); + fprintf(file," { %4d, %4d, %4d, %4d } }", + shape->bounds.x1,shape->bounds.y1, + shape->bounds.x2,shape->bounds.y2); + } + fprintf(file,"\n};\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrGeomDoodads( FILE * file, + XkbDescPtr xkb, + XkbGeometryPtr geom, + XkbSectionPtr section, + int section_num) +#else +WriteCHdrGeomDoodads(file,xkb,geom,section,section_num) + FILE * file; + XkbDescPtr xkb; + XkbGeometryPtr geom; + XkbSectionPtr section; + int section_num; +#endif +{ +int nd,d; +XkbDoodadPtr doodad; +Display * dpy; + + dpy= xkb->dpy; + if (section==NULL) { + if (geom->num_doodads>0) { + fprintf(file,"static XkbDoodadRec g_doodads[%d];\n", + geom->num_doodads); + } + fprintf(file,"static void\n"); + fprintf(file,"#if NeedFunctionPrototypes\n"); + fprintf(file,"_InitGeomDoodads(DPYTYPE dpy,XkbGeometryPtr geom)\n"); + fprintf(file,"#else\n"); + fprintf(file,"_InitGeomDoodads(dpy,geom)\n"); + fprintf(file," DPYTYPE dpy;\n"); + fprintf(file," XkbGeometryPtr geom;\n"); + fprintf(file,"#endif\n"); + fprintf(file,"{\n"); + fprintf(file,"register XkbDoodadPtr doodads;\n\n"); + fprintf(file," doodads= geom->doodads;\n"); + nd= geom->num_doodads; + doodad= geom->doodads; + } + else { + if (section->num_doodads>0) { + fprintf(file,"static XkbDoodadRec doodads_s%02d[%d];\n", + section_num,section->num_doodads); + } + fprintf(file,"static void\n"); + fprintf(file,"#if NeedFunctionPrototypes\n"); + fprintf(file,"_InitS%02dDoodads(",section_num); + fprintf(file," DPYTYPE dpy,\n"); + fprintf(file," XkbGeometryPtr geom,\n"); + fprintf(file," XkbSectionPtr section)\n"); + fprintf(file,"#else\n"); + fprintf(file,"_InitS%02dDoodads(dpy,geom,section)\n",section_num); + fprintf(file," DPYTYPE dpy;\n"); + fprintf(file," XkbGeometryPtr geom;\n"); + fprintf(file," XkbSectionPtr section;\n"); + fprintf(file,"#endif\n"); + fprintf(file,"{\n"); + fprintf(file,"register XkbDoodadPtr doodads;\n\n"); + fprintf(file," doodads= section->doodads;\n"); + nd= geom->num_doodads; + doodad= geom->doodads; + } + for (d=0;dany.name,XkbCFile)); + fprintf(file," doodads[%d].any.type= %s;\n",d, + XkbDoodadTypeText(doodad->any.type,XkbCFile)); + fprintf(file," doodads[%d].any.priority= %d;\n",d, + doodad->any.priority); + fprintf(file," doodads[%d].any.top= %d;\n",d,doodad->any.top); + fprintf(file," doodads[%d].any.left= %d;\n",d,doodad->any.left); + fprintf(file," doodads[%d].any.angle= %d;\n",d,doodad->any.angle); + switch (doodad->any.type) { + case XkbOutlineDoodad: + case XkbSolidDoodad: + fprintf(file," doodads[%d].shape.color_ndx= %d;\n",d, + doodad->shape.color_ndx); + fprintf(file," doodads[%d].shape.shape_ndx= %d;\n",d, + doodad->shape.shape_ndx); + break; + case XkbTextDoodad: + fprintf(file," doodads[%d].text.width= %d;\n",d, + doodad->text.width); + fprintf(file," doodads[%d].text.height= %d;\n",d, + doodad->text.height); + fprintf(file," doodads[%d].text.color_ndx= %d;\n",d, + doodad->text.color_ndx); + fprintf(file," doodads[%d].text.text= \"%s\";\n",d, + XkbStringText(doodad->text.text,XkbCFile)); + fprintf(file," doodads[%d].text.font= \"%s\";\n",d, + XkbStringText(doodad->text.font,XkbCFile)); + break; + case XkbIndicatorDoodad: + fprintf(file," doodads[%d].indicator.shape_ndx= %d;\n",d, + doodad->indicator.shape_ndx); + fprintf(file," doodads[%d].indicator.on_color_ndx= %d;\n",d, + doodad->indicator.on_color_ndx); + fprintf(file," doodads[%d].indicator.off_color_ndx= %d;\n",d, + doodad->indicator.off_color_ndx); + break; + case XkbLogoDoodad: + fprintf(file," doodads[%d].logo.color_ndx= %d;\n",d, + doodad->logo.color_ndx); + fprintf(file," doodads[%d].logo.shape_ndx= %d;\n",d, + doodad->logo.shape_ndx); + fprintf(file," doodads[%d].logo.logo_name= \"%s\";\n",d, + XkbStringText(doodad->logo.logo_name,XkbCFile)); + break; + } + } + fprintf(file,"}\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrGeomOverlays( FILE * file, + XkbDescPtr xkb, + XkbSectionPtr section, + int section_num) +#else +WriteCHdrGeomOverlays(file,xkb,section,section_num) + FILE * file; + XkbDescPtr xkb; + XkbSectionPtr section; + int section_num; +#endif +{ +register int o,r,k; +XkbOverlayPtr ol; +XkbOverlayRowPtr row; +XkbOverlayKeyPtr key; + + if (section->num_overlays<1) + return True; + for (o=0,ol=section->overlays;onum_overlays;o++,ol++) { + for (r=0,row=ol->rows;rnum_rows;r++,row++) { + fprintf(file,"static XkbOverlayKeyRec olkeys_s%02dr%02d[%d]= {\n", + section_num,r,row->num_keys); + for (k=0,key=row->keys;knum_keys;k++,key++) { + fprintf(file,"%s { {\"%s\"}, {\"%s\"} }", + (k==0?"":",\n"), + XkbKeyNameText(key->over.name,XkbCFile), + XkbKeyNameText(key->under.name,XkbCFile)); + } + fprintf(file,"\n};\n"); + } + fprintf(file,"static XkbOverlayRowRec olrows_s%02d[%d]= {\n", + section_num,section->num_rows); + for (r=0,row=ol->rows;rnum_rows;r++,row++) { + fprintf(file,"%s { %4d, %4d, %4d, olkeys_s%02dr%02d }", + (r==0?"":",\n"), + row->row_under,row->num_keys,row->num_keys, + section_num,r); + } + fprintf(file,"\n};\n"); + } + fprintf(file,"static XkbOverlayRec overlays_s%02d[%d]= {\n",section_num, + section->num_overlays); + for (o=0,ol=section->overlays;onum_overlays;o++,ol++) { + fprintf(file,"%s {\n",(o==0?"":",\n")); + fprintf(file," None, /* name */\n"); + fprintf(file," NULL, /* section_under */\n"); + fprintf(file," %4d, /* num_rows */\n",ol->num_rows); + fprintf(file," %4d, /* sz_rows */\n",ol->num_rows); + fprintf(file," olrows_s%02d,\n",section_num); + fprintf(file," NULL /* bounds */\n"); + fprintf(file," }"); + } + fprintf(file,"\n};\n"); + fprintf(file,"static void\n"); + fprintf(file,"#if NeedFunctionPrototypes\n"); + fprintf(file,"_InitS%02dOverlay(",section_num); + fprintf(file," DPYTYPE dpy,\n"); + fprintf(file," XkbGeometryPtr geom,\n"); + fprintf(file," XkbSectionPtr section)\n"); + fprintf(file,"#else\n"); + fprintf(file,"_InitS%02dOverlay(dpy,geom,section)\n",section_num); + fprintf(file," DPYTYPE dpy;\n"); + fprintf(file," XkbGeometryPtr geom;\n"); + fprintf(file," XkbSectionPtr section;\n"); + fprintf(file,"#endif\n"); + fprintf(file,"{\n"); + fprintf(file,"XkbOverlayPtr ol;\n\n"); + fprintf(file," ol= section->overlays;\n"); + for (o=0,ol=section->overlays;onum_overlays;o++,ol++) { + fprintf(file," ol[%2d].name= GET_ATOM(dpy,\"%s\");\n",o, + XkbAtomText(xkb->dpy,ol->name,XkbCFile)); + fprintf(file," ol[%2d].section_under= section;\n",o); + } + fprintf(file,"}\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrGeomRows( FILE * file, + XkbDescPtr xkb, + XkbSectionPtr section, + int section_num) +#else +WriteCHdrGeomRows(file,xkb,section,section_num) + FILE * file; + XkbDescPtr xkb; + XkbSectionPtr section; + int section_num; +#endif +{ +register int k,r; +register XkbRowPtr row; +register XkbKeyPtr key; + + for (r=0,row=section->rows;rnum_rows;r++,row++) { + fprintf(file,"static XkbKeyRec keys_s%02dr%02d[]= {\n",section_num,r); + for (k=0,key=row->keys;knum_keys;k++,key++) { + fprintf(file,"%s { { \"%s\" }, %4d, %4d, %4d }", + (k==0?"":",\n"), + XkbKeyNameText(key->name.name,XkbCFile), + key->gap,key->shape_ndx,key->color_ndx); + } + fprintf(file,"\n};\n"); + } + fprintf(file,"static XkbRowRec rows_s%02d[]= {\n",section_num); + for (r=0,row=section->rows;rnum_rows;r++,row++) { + fprintf(file,"%s { %4d, %4d, %2d, %2d, %1d, keys_s%02dr%02d, ", + (r==0?"":",\n"), + row->top,row->left,row->num_keys,row->num_keys, + (row->vertical!=0), + section_num,r); + fprintf(file," { %4d, %4d, %4d, %4d } }", + row->bounds.x1,row->bounds.y1, + row->bounds.x2,row->bounds.y2); + } + fprintf(file,"\n};\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrGeomSections(FILE *file,XkbDescPtr xkb,XkbGeometryPtr geom) +#else +WriteCHdrGeomSections(file,xkb,geom) + FILE * file; + XkbDescPtr xkb; + XkbGeometryPtr geom; +#endif +{ +register int s; +register XkbSectionPtr section; + + for (s=0,section=geom->sections;snum_sections;s++,section++) { + WriteCHdrGeomRows(file,xkb,section,s); +#ifdef NOTYET + if (section->num_doodads>0) + WriteCHdrGeomDoodads(file,xkb,geom,section,s); +#endif + if (section->num_overlays>0) + WriteCHdrGeomOverlays(file,xkb,section,s); + } + fprintf(file,"\nstatic XkbSectionRec g_sections[%d]= {\n", + geom->num_sections); + for (s=0,section=geom->sections;snum_sections;s++,section++) { + if (s!=0) fprintf(file,",\n"); + fprintf(file," {\n None, /* name */\n"); + fprintf(file," %4d, /* priority */\n",section->priority); + fprintf(file," %4d, /* top */\n",section->top); + fprintf(file," %4d, /* left */\n",section->left); + fprintf(file," %4d, /* width */\n",section->width); + fprintf(file," %4d, /* height */\n",section->height); + fprintf(file," %4d, /* angle */\n",section->angle); + fprintf(file," %4d, /* num_rows */\n",section->num_rows); + fprintf(file," %4d, /* num_doodads */\n",section->num_doodads); + fprintf(file," %4d, /* num_overlays */\n",section->num_overlays); + fprintf(file," %4d, /* sz_rows */\n",section->num_rows); + fprintf(file," %4d, /* sz_doodads */\n",section->num_doodads); + fprintf(file," %4d, /* sz_overlays */\n",section->num_overlays); + if (section->num_rows>0) + fprintf(file," rows_s%02d,\n",s); + else fprintf(file," NULL, /* rows */\n"); + if (section->num_doodads>0) + fprintf(file," doodads_s%02d,\n",s); + else fprintf(file," NULL, /* doodads */\n"); + fprintf(file," { %4d, %4d, %4d, %4d }, /* bounds */\n", + section->bounds.x1,section->bounds.y1, + section->bounds.x2,section->bounds.y2); + if (section->num_overlays>0) + fprintf(file," overlays_s%02d\n",s); + else fprintf(file," NULL /* overlays */\n"); + fprintf(file," }"); + } + fprintf(file,"\n};\n"); + fprintf(file,"\nstatic Bool\n"); + fprintf(file,"#if NeedFunctionPrototypes\n"); + fprintf(file,"_InitSections(DPYTYPE dpy,XkbGeometryPtr geom)\n"); + fprintf(file,"#else\n"); + fprintf(file,"_InitSections(dpy,geom)\n"); + fprintf(file," DPYTYPE dpy;\n XkbGeometryPtr geom;\n"); + fprintf(file,"#endif\n"); + fprintf(file,"{\nXkbSectionPtr sections;\n\n"); + fprintf(file," sections= geom->sections;\n"); + for (s=0,section=geom->sections;snum_sections;s++,section++) { + if (section->num_doodads>0) { + fprintf(file," _InitS%02dDoodads(dpy,geom,§ions[%d]);\n", + s,s); + } + if (section->num_overlays>0) { + fprintf(file," _InitS%02dOverlays(dpy,geom,§ions[%d]);\n", + s,s); + } + } + fprintf(file,"}\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrGeomAliases(FILE *file,XkbDescPtr xkb,XkbGeometryPtr geom) +#else +WriteCHdrGeomAliases(file,xkb,geom) + FILE * file; + XkbDescPtr xkb; + XkbGeometryPtr geom; +#endif +{ + if (geom->num_key_aliases>0) { + register int i; + fprintf(file,"\nstatic XkbKeyAliasRec g_aliases[%d]= {\n", + geom->num_key_aliases); + for (i=0;inum_key_aliases;i++) { + fprintf(file,"%s { \"%s\", \"%s\" }",(i==0?"":",\n"), + XkbKeyNameText(geom->key_aliases[i].real,XkbCFile), + XkbKeyNameText(geom->key_aliases[i].alias,XkbCFile)); + } + fprintf(file,"\n};\n"); + } + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrGeometry(FILE *file,XkbDescPtr xkb) +#else +WriteCHdrGeometry(file,xkb) + FILE * file; + XkbDescPtr xkb; +#endif +{ +XkbGeometryPtr geom; +register int i; + + if ((!xkb)||(!xkb->geom)) { + _XkbLibError(_XkbErrMissingGeometry,"WriteCHdrGeometry",0); + return False; + } + geom= xkb->geom; + WriteCHdrGeomProps(file,xkb,geom); + WriteCHdrGeomColors(file,xkb,geom); + WriteCHdrGeomShapes(file,xkb,geom); + WriteCHdrGeomSections(file,xkb,geom); + WriteCHdrGeomDoodads(file,xkb,geom,NULL,0); + WriteCHdrGeomAliases(file,xkb,geom); + fprintf(file,"\nstatic XkbGeometryRec geom= {\n"); + fprintf(file," None, /* name */\n"); + fprintf(file," %d, %d, /* width, height */\n",geom->width_mm, + geom->height_mm); + if (geom->label_font) { + fprintf(file," \"%s\",/* label font */\n", + XkbStringText(geom->label_font,XkbCFile)); + } + else fprintf(file," NULL, /* label font */\n"); + if (geom->label_color) { + fprintf(file," &g_colors[%d], /* label color */\n", + XkbGeomColorIndex(geom,geom->label_color)); + } + else fprintf(file," NULL, /* label color */\n"); + if (geom->base_color) { + fprintf(file," &g_colors[%d], /* base color */\n", + XkbGeomColorIndex(geom,geom->base_color)); + } + else fprintf(file," NULL, /* base color */\n"); + fprintf(file," %d, %d, %d, /* sz: props, colors, shapes */\n", + geom->num_properties,geom->num_colors, + geom->num_shapes); + fprintf(file," %d, %d, %d, /* sz: sections, doodads, aliases */\n", + geom->num_sections,geom->num_doodads, + geom->num_key_aliases); + fprintf(file," %d, %d, %d, /* num: props, colors, shapes */\n", + geom->num_properties,geom->num_colors, + geom->num_shapes); + fprintf(file," %d, %d, %d, /* num: sections, doodads, aliases */\n", + geom->num_sections,geom->num_doodads, + geom->num_key_aliases); + fprintf(file," %s, %s, %s,\n", + (geom->num_properties>0?"g_props":"NULL"), + (geom->num_colors>0?"g_colors":"NULL"), + (geom->num_shapes>0?"g_shapes":"NULL")); + fprintf(file," %s, %s, %s\n", + (geom->num_sections>0?"g_sections":"NULL"), + (geom->num_doodads>0?"g_doodads":"NULL"), + (geom->num_key_aliases>0?"g_aliases":"NULL")); + fprintf(file,"};\n\n"); + fprintf(file,"static Bool\n"); + fprintf(file,"#if NeedFunctionPrototypes\n"); + fprintf(file,"_InitHdrGeom(DPYTYPE dpy,XkbGeometryPtr geom)\n"); + fprintf(file,"#else\n"); + fprintf(file,"_InitHdrGeom(dpy,geom)\n"); + fprintf(file," DPYTYPE dpy;\n XkbGeometryPtr geom;\n"); + fprintf(file,"#endif\n"); + fprintf(file,"{\n"); + if (geom->name!=None) { + fprintf(file," geom->name= GET_ATOM(dpy,\"%s\");\n", + XkbAtomText(xkb->dpy,geom->name,XkbCFile)); + } + for (i=0;inum_shapes;i++) { + fprintf(file," geom->shapes[%2d].name= GET_ATOM(dpy,\"%s\");\n",i, + XkbAtomText(xkb->dpy,geom->shapes[i].name,XkbCFile)); + } + if (geom->num_doodads>0) + fprintf(file," _InitGeomDoodads(dpy,geom);\n"); + fprintf(file," _InitSections(dpy,geom);\n"); + fprintf(file,"}\n\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrGeomFile(FILE *file,XkbFileInfo *result) +#else +WriteCHdrGeomFile(file,result) + FILE * file; + XkbFileInfo * result; +#endif +{ +Bool ok; + + ok= WriteCHdrGeometry(file,result->xkb); + return ok; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrLayout(FILE *file,XkbFileInfo *result) +#else +WriteCHdrLayout(file,result) + FILE * file; + XkbFileInfo * result; +#endif +{ +Bool ok; +XkbDescPtr xkb; + + xkb= result->xkb; + ok= WriteCHdrVMods(file,xkb->dpy,xkb); + ok= WriteCHdrKeycodes(file,xkb)&&ok; + ok= WriteCHdrSymbols(file,xkb)&&ok; + ok= WriteCHdrGeometry(file,xkb)&&ok; + return ok; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrSemantics(FILE *file,XkbFileInfo *result) +#else +WriteCHdrSemantics(file,result) + FILE * file; + XkbFileInfo * result; +#endif +{ +Bool ok; +XkbDescPtr xkb; + + xkb= result->xkb; + ok= WriteCHdrVMods(file,xkb->dpy,xkb); + ok= WriteCHdrKeyTypes(file,xkb->dpy,xkb)&&ok; + ok= WriteCHdrCompatMap(file,xkb->dpy,xkb)&&ok; + ok= WriteCHdrIndicators(file,xkb->dpy,xkb)&&ok; + return ok; +} + +static Bool +#if NeedFunctionPrototypes +WriteCHdrKeymap(FILE *file,XkbFileInfo *result) +#else +WriteCHdrKeymap(file,result) + FILE * file; + XkbFileInfo * result; +#endif +{ +Bool ok; +XkbDescPtr xkb; + + xkb= result->xkb; + ok= WriteCHdrVMods(file,xkb->dpy,xkb); + ok= ok&&WriteCHdrKeycodes(file,xkb); + ok= ok&&WriteCHdrClientMap(file,xkb->dpy,xkb); + ok= ok&&WriteCHdrServerMap(file,xkb->dpy,xkb); + ok= ok&&WriteCHdrCompatMap(file,xkb->dpy,xkb); + ok= WriteCHdrIndicators(file,xkb->dpy,xkb)&&ok; + ok= ok&&WriteCHdrGeometry(file,xkb); + return ok; +} + +Bool +#if NeedFunctionPrototypes +XkbWriteCFile(FILE *out,char *name,XkbFileInfo *result) +#else +XkbWriteCFile(out,name,result) + FILE * out; + char * name; + XkbFileInfo * result; +#endif +{ +Bool ok; +XkbDescPtr xkb; +Bool (*func)( +#if NeedFunctionPrototypes + FILE * /* file*/, + XkbFileInfo * /* result */ +#endif +); + + switch (result->type) { + case XkmSemanticsFile: + func= WriteCHdrSemantics; + break; + case XkmLayoutFile: + func= WriteCHdrLayout; + break; + case XkmKeymapFile: + func= WriteCHdrKeymap; + break; + case XkmGeometryIndex: + case XkmGeometryFile: + func= WriteCHdrGeomFile; + break; + default: + _XkbLibError(_XkbErrIllegalContents,"XkbWriteCFile",result->type); + return False; + } + xkb= result->xkb; + if (out==NULL) { + _XkbLibError(_XkbErrFileCannotOpen,"XkbWriteCFile",0); + ok= False; + } + else { + char *tmp,*hdrdef; + tmp= (char *)strrchr(name,'/'); + if (tmp==NULL) + tmp= name; + else tmp++; + hdrdef= (char *)_XkbCalloc(strlen(tmp+1),sizeof(char)); + if (hdrdef) { + strcpy(hdrdef,tmp); + tmp= hdrdef; + while (*tmp) { + if (islower(*tmp)) *tmp= toupper(*tmp); + else if (!isalnum(*tmp)) *tmp= '_'; + tmp++; + } + fprintf(out,"/* This file generated automatically by xkbcomp */\n"); + fprintf(out,"/* DO NOT EDIT */\n"); + fprintf(out,"#ifndef %s\n",hdrdef); + fprintf(out,"#define %s 1\n\n",hdrdef); + } + fprintf(out,"#ifndef XKB_IN_SERVER\n"); + fprintf(out,"#define GET_ATOM(d,s) XInternAtom(d,s,0)\n"); + fprintf(out,"#define DPYTYPE Display *\n"); + fprintf(out,"#else\n"); + fprintf(out,"#define GET_ATOM(d,s) MakeAtom(s,strlen(s),1)\n"); + fprintf(out,"#define DPYTYPE char *\n"); + fprintf(out,"#endif\n"); + fprintf(out,"#define NUM_KEYS %d\n",xkb->max_key_code+1); + ok= (*func)(out,result); + if (hdrdef) + fprintf(out,"#endif /* %s */\n",hdrdef); + } + + if (!ok) { + return False; + } + return True; +} diff --git a/src/magic b/src/magic new file mode 100644 index 0000000..9c433ad --- /dev/null +++ b/src/magic @@ -0,0 +1,11 @@ +# $Xorg: magic,v 1.3 2000/08/17 19:46:43 cpqbld Exp $ +# Here are some lines you can add to /etc/magic +# to identify XKM (compiled X keymap) files +# and determine their version and the byte ordering +# with which they were compiled +1 string mkx Compiled XKB Keymap: lsb, +>0 byte >0 version %d +>0 byte =0 obsolete +0 string xkm Compiled XKB Keymap: msb, +>3 byte >0 version %d +>0 byte =0 obsolete diff --git a/src/maprules.c b/src/maprules.c new file mode 100644 index 0000000..559dc9c --- /dev/null +++ b/src/maprules.c @@ -0,0 +1,1382 @@ +/* $Xorg: maprules.c,v 1.4 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1996 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif + + +#define X_INCLUDE_STRING_H +#define XOS_USE_NO_LOCKING +#include + +#ifndef XKB_IN_SERVER + +#include +#include +#include +#include +#include +#include +#include +#include +#include "XKMformat.h" +#include "XKBfileInt.h" +#include "XKBrules.h" + +#else + +#define NEED_EVENTS +#include +#include +#include +#include +#include +#include +#include "misc.h" +#include "inputstr.h" +#include "dix.h" +#include "XKBstr.h" +#define XKBSRV_NEED_FILE_FUNCS +#include "XKBsrv.h" + +#endif + +#ifdef DEBUG +#define PR_DEBUG(s) fprintf(stderr,s) +#define PR_DEBUG1(s,a) fprintf(stderr,s,a) +#else +#define PR_DEBUG(s) +#define PR_DEBUG1(s,a) +#endif + +/***====================================================================***/ + +#define DFLT_LINE_SIZE 128 + +typedef struct { + int line_num; + int sz_line; + int num_line; + char buf[DFLT_LINE_SIZE]; + char * line; +} InputLine; + +static void +#if NeedFunctionPrototypes +InitInputLine(InputLine *line) +#else +InitInputLine(line) + InputLine * line; +#endif +{ + line->line_num= 1; + line->num_line= 0; + line->sz_line= DFLT_LINE_SIZE; + line->line= line->buf; + return; +} + +static void +#if NeedFunctionPrototypes +FreeInputLine(InputLine *line) +#else +FreeInputLine(line) + InputLine *line; +#endif +{ + if (line->line!=line->buf) + _XkbFree(line->line); + line->line_num= 1; + line->num_line= 0; + line->sz_line= DFLT_LINE_SIZE; + line->line= line->buf; + return; +} + +static int +#if NeedFunctionPrototypes +InputLineAddChar(InputLine *line,int ch) +#else +InputLineAddChar(line,ch) + InputLine * line; + int ch; +#endif +{ + if (line->num_line>=line->sz_line) { + if (line->line==line->buf) { + line->line= (char *)_XkbAlloc(line->sz_line*2); + memcpy(line->line,line->buf,line->sz_line); + } + else { + line->line=(char *)_XkbRealloc((char *)line->line,line->sz_line*2); + } + line->sz_line*= 2; + } + line->line[line->num_line++]= ch; + return ch; +} + +#define ADD_CHAR(l,c) ((l)->num_line<(l)->sz_line?\ + (int)((l)->line[(l)->num_line++]= (c)):\ + InputLineAddChar(l,c)) + +static Bool +#if NeedFunctionPrototypes +GetInputLine(FILE *file,InputLine *line,Bool checkbang) +#else +GetInputLine(file,line,checkbang) + FILE * file; + InputLine * line; + Bool checkbang; +#endif +{ +int ch; +Bool endOfFile,spacePending,slashPending,inComment; + + endOfFile= False; + while ((!endOfFile)&&(line->num_line==0)) { + spacePending= slashPending= inComment= False; + while (((ch=getc(file))!='\n')&&(ch!=EOF)) { + if (ch=='\\') { + if ((ch=getc(file))==EOF) + break; + if (ch=='\n') { + inComment= False; + ch= ' '; + line->line_num++; + } + } + if (inComment) + continue; + if (ch=='/') { + if (slashPending) { + inComment= True; + slashPending= False; + } + else { + slashPending= True; + } + continue; + } + else if (slashPending) { + if (spacePending) { + ADD_CHAR(line,' '); + spacePending= False; + } + ADD_CHAR(line,'/'); + slashPending= False; + } + if (isspace(ch)) { + while (isspace(ch)&&(ch!='\n')&&(ch!=EOF)) { + ch= getc(file); + } + if (ch==EOF) + break; + if ((ch!='\n')&&(line->num_line>0)) + spacePending= True; + ungetc(ch,file); + } + else { + if (spacePending) { + ADD_CHAR(line,' '); + spacePending= False; + } + if (checkbang && ch=='!') { + if (line->num_line!=0) { + PR_DEBUG("The '!' legal only at start of line\n"); + PR_DEBUG("Line containing '!' ignored\n"); + line->num_line= 0; + inComment= 0; + break; + } + + } + ADD_CHAR(line,ch); + } + } + if (ch==EOF) + endOfFile= True; +/* else line->num_line++;*/ + } + if ((line->num_line==0)&&(endOfFile)) + return False; + ADD_CHAR(line,'\0'); + return True; +} + +/***====================================================================***/ + +#define MODEL 0 +#define LAYOUT 1 +#define VARIANT 2 +#define OPTION 3 +#define KEYCODES 4 +#define SYMBOLS 5 +#define TYPES 6 +#define COMPAT 7 +#define GEOMETRY 8 +#define KEYMAP 9 +#define MAX_WORDS 10 + +#define PART_MASK 0x000F +#define COMPONENT_MASK 0x03F0 + +static char * cname[MAX_WORDS] = { + "model", "layout", "variant", "option", + "keycodes", "symbols", "types", "compat", "geometry", "keymap" +}; + +typedef struct _RemapSpec { + int num_remap; + int remap[MAX_WORDS]; +} RemapSpec; + +typedef struct _FileSpec { + char * name[MAX_WORDS]; + struct _FileSpec * pending; +} FileSpec; + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +SetUpRemap(InputLine *line,RemapSpec *remap) +#else +SetUpRemap(line,remap) + InputLine * line; + RemapSpec * remap; +#endif +{ +char * tok,*str; +unsigned present; +register int i; +#ifdef DEBUG +Bool found; +#endif +_Xstrtokparams strtok_buf; + + present= 0; + str= &line->line[1]; + bzero((char *)remap,sizeof(RemapSpec)); + while ((tok=_XStrtok(str," ",strtok_buf))!=NULL) { +#ifdef DEBUG + found= False; +#endif + str= NULL; + if (strcmp(tok,"=")==0) + continue; + for (i=0;iremap[remap->num_remap++]= i; + break; + } + } +#ifdef DEBUG + if (!found) { + fprintf(stderr,"Unknown component \"%s\" ignored\n",tok); + } +#endif + } + if ((present&PART_MASK)==0) { +#ifdef DEBUG + unsigned mask= PART_MASK; + fprintf(stderr,"Mapping needs at one of "); + for (i=0;(inum_remap= 0; + return; + } + if ((present&COMPONENT_MASK)==0) { + PR_DEBUG("Mapping needs at least one component\n"); + PR_DEBUG("Illegal mapping ignored\n"); + remap->num_remap= 0; + return; + } + if (((present&PART_MASK)&(1<num_remap= 0; + return; + } + if (((present&COMPONENT_MASK)&(1<num_remap= 0; + return; + } + return; +} + +static Bool +#if NeedFunctionPrototypes +MatchOneOf(char *wanted,char *vals_defined) +#else +MatchOneOf(wanted,vals_defined) + char * wanted; + char * vals_defined; +#endif +{ +char *str,*next; +int want_len= strlen(wanted); + + for (str=vals_defined,next=NULL;str!=NULL;str=next) { + int len; + next= strchr(str,','); + if (next) { + len= next-str; + next++; + } + else { + len= strlen(str); + } + if ((len==want_len)&&(strncmp(wanted,str,len)==0)) + return True; + } + return False; +} + +/***====================================================================***/ + +static Bool +#if NeedFunctionPrototypes +CheckLine( InputLine * line, + RemapSpec * remap, + XkbRF_RulePtr rule) +#else +CheckLine(line,remap,rule) + InputLine * line; + RemapSpec * remap; + XkbRF_RulePtr rule; +#endif +{ +char * str,*tok; +register int nread; +FileSpec tmp; +_Xstrtokparams strtok_buf; + + if (line->line[0]=='!') { + SetUpRemap(line,remap); + return False; + } + if (remap->num_remap==0) { + PR_DEBUG("Must have a mapping before first line of data\n"); + PR_DEBUG("Illegal line of data ignored\n"); + return False; + } + bzero((char *)&tmp,sizeof(FileSpec)); + str= line->line; + for (nread= 0;(tok=_XStrtok(str," ",strtok_buf))!=NULL;nread++) { + str= NULL; + if (strcmp(tok,"=")==0) { + nread--; + continue; + } + if (nread>remap->num_remap) { + PR_DEBUG("Too many words on a line\n"); + PR_DEBUG1("Extra word \"%s\" ignored\n",tok); + continue; + } + tmp.name[remap->remap[nread]]= tok; + } + if (nreadnum_remap) { + PR_DEBUG("Too few words on a line\n"); + PR_DEBUG("line ignored\n"); + return False; + } + if ((tmp.name[MODEL]!=NULL)&&(strcmp(tmp.name[MODEL],"*")==0)) + tmp.name[MODEL]= NULL; + if ((tmp.name[LAYOUT]!=NULL)&&(strcmp(tmp.name[LAYOUT],"*")==0)) + tmp.name[LAYOUT]= NULL; + if ((tmp.name[VARIANT]!=NULL)&&(strcmp(tmp.name[VARIANT],"*")==0)) + tmp.name[VARIANT]= NULL; + + rule->flags= 0; + if (tmp.name[OPTION]) + rule->flags|= XkbRF_Delayed|XkbRF_Append; + rule->model= _XkbDupString(tmp.name[MODEL]); + rule->layout= _XkbDupString(tmp.name[LAYOUT]); + rule->variant= _XkbDupString(tmp.name[VARIANT]); + rule->option= _XkbDupString(tmp.name[OPTION]); + + rule->keycodes= _XkbDupString(tmp.name[KEYCODES]); + rule->symbols= _XkbDupString(tmp.name[SYMBOLS]); + rule->types= _XkbDupString(tmp.name[TYPES]); + rule->compat= _XkbDupString(tmp.name[COMPAT]); + rule->geometry= _XkbDupString(tmp.name[GEOMETRY]); + rule->keymap= _XkbDupString(tmp.name[KEYMAP]); + return True; +} + +static char * +#if NeedFunctionPrototypes +_Concat(char *str1,char *str2) +#else +_Concat(str1,str2) + char * str1; + char * str2; +#endif +{ +int len; + + if ((!str1)||(!str2)) + return str1; + len= strlen(str1)+strlen(str2)+1; + str1= _XkbTypedRealloc(str1,len,char); + if (str1) + strcat(str1,str2); + return str1; +} + +Bool +#if NeedFunctionPrototypes +XkbRF_ApplyRule( XkbRF_RulePtr rule, + XkbComponentNamesPtr names) +#else +XkbRF_ApplyRule(rule,names) + XkbRF_RulePtr rule; + XkbComponentNamesPtr names; +#endif +{ + rule->flags&= ~XkbRF_PendingMatch; /* clear the flag because it's applied */ + if ((rule->flags&XkbRF_Append)==0) { + if ((names->keycodes==NULL)&&(rule->keycodes!=NULL)) + names->keycodes= _XkbDupString(rule->keycodes); + + if ((names->symbols==NULL)&&(rule->symbols!=NULL)) + names->symbols= _XkbDupString(rule->symbols); + + if ((names->types==NULL)&&(rule->types!=NULL)) + names->types= _XkbDupString(rule->types); + + if ((names->compat==NULL)&&(rule->compat!=NULL)) + names->compat= _XkbDupString(rule->compat); + + if ((names->geometry==NULL)&&(rule->geometry!=NULL)) + names->geometry= _XkbDupString(rule->geometry); + + if ((names->keymap==NULL)&&(rule->keymap!=NULL)) + names->keymap= _XkbDupString(rule->keymap); + } + else { + if (rule->keycodes) + names->keycodes= _Concat(names->keycodes,rule->keycodes); + if (rule->symbols) + names->symbols= _Concat(names->symbols,rule->symbols); + if (rule->types) + names->types= _Concat(names->types,rule->types); + if (rule->compat) + names->compat= _Concat(names->compat,rule->compat); + if (rule->geometry) + names->geometry= _Concat(names->geometry,rule->geometry); + if (rule->keymap) + names->keymap= _Concat(names->keymap,rule->keymap); + } + return (names->keycodes && names->symbols && names->types && + names->compat && names->geometry ) || names->keymap; +} + +#define CHECK_MATCH(r,d) ((((r)[0]=='?')&&((r)[1]=='\0'))||(strcmp(r,d)==0)) + +Bool +#if NeedFunctionPrototypes +XkbRF_CheckApplyRule( XkbRF_RulePtr rule, + XkbRF_VarDefsPtr defs, + XkbComponentNamesPtr names) +#else +XkbRF_CheckApplyRule(rule,defs,names) + XkbRF_RulePtr rule; + XkbRF_VarDefsPtr defs; + XkbComponentNamesPtr names; +#endif +{ + if (rule->model!=NULL) { + if ((!defs->model)||(!CHECK_MATCH(rule->model,defs->model))) + return False; + } + if (rule->layout!=NULL) { + if ((!defs->layout)||(!CHECK_MATCH(rule->layout,defs->layout))) + return False; + } + if (rule->variant!=NULL) { + if ((!defs->variant)||(!CHECK_MATCH(rule->variant,defs->variant))) + return False; + } + if (rule->option!=NULL) { + if ((!defs->options)||(!MatchOneOf(rule->option,defs->options))) + return False; + } + + if ((!rule->option)&& + ((!rule->model)||(!rule->layout)||(!rule->variant))) { + /* partial map -- partial maps are applied in the order they */ + /* appear, but all partial maps come before any options. */ + rule->flags|= XkbRF_PendingMatch; + return False; + } + /* exact match, apply it now */ + return XkbRF_ApplyRule(rule,names); +} + +void +#if NeedFunctionPrototypes +XkbRF_ClearPartialMatches(XkbRF_RulesPtr rules) +#else +XkbRF_ClearPartialMatches(rules) + XkbRF_RulesPtr rules; +#endif +{ +register int i; +XkbRF_RulePtr rule; + + for (i=0,rule=rules->rules;inum_rules;i++,rule++) { + rule->flags&= ~XkbRF_PendingMatch; + } +} + +Bool +#if NeedFunctionPrototypes +XkbRF_ApplyPartialMatches(XkbRF_RulesPtr rules,XkbComponentNamesPtr names) +#else +XkbRF_ApplyPartialMatches(rules,names) + XkbRF_RulesPtr rules; + XkbComponentNamesPtr names; +#endif +{ +int i; +XkbRF_RulePtr rule; +Bool complete; + + complete= False; + for (rule=rules->rules,i=0;(inum_rules)&&(!complete);i++,rule++) { + if ((rule->flags&XkbRF_PendingMatch)==0) + continue; + complete= XkbRF_ApplyRule(rule,names); + } + return complete; +} + +void +#if NeedFunctionPrototypes +XkbRF_CheckApplyDelayedRules( XkbRF_RulesPtr rules, + XkbRF_VarDefsPtr defs, + XkbComponentNamesPtr names) +#else +XkbRF_CheckApplyDelayedRules(rules,defs,names) + XkbRF_RulesPtr rules; + XkbRF_VarDefsPtr defs; + XkbComponentNamesPtr names; +#endif +{ +int i; +XkbRF_RulePtr rule; + + for (rule=rules->rules,i=0;(inum_rules);i++,rule++) { + if ((rule->flags&XkbRF_Delayed)==0) + continue; + XkbRF_CheckApplyRule(rule,defs,names); + } + return; +} + +Bool +#if NeedFunctionPrototypes +XkbRF_CheckApplyRules( XkbRF_RulesPtr rules, + XkbRF_VarDefsPtr defs, + XkbComponentNamesPtr names) +#else +XkbRF_CheckApplyRules(rules,defs,names) + XkbRF_RulesPtr rules; + XkbRF_VarDefsPtr defs; + XkbComponentNamesPtr names; +#endif +{ +int i; +XkbRF_RulePtr rule; +Bool complete; + + complete= False; + for (rule=rules->rules,i=0;(inum_rules)&&(!complete);i++,rule++) { + if ((rule->flags&XkbRF_Delayed)!=0) + continue; + complete= XkbRF_CheckApplyRule(rule,defs,names); + } + return complete; +} + +/***====================================================================***/ + +char * +#if NeedFunctionPrototypes +XkbRF_SubstituteVars(char *name,XkbRF_VarDefsPtr defs) +#else +XkbRF_SubstituteVars(name,defs) + char * name; + XkbRF_VarDefsPtr defs; +#endif +{ +char *str,*outstr,*orig; +int len; + + orig= name; + str= index(name,'%'); + if (str==NULL) + return name; + len= strlen(name); + while (str!=NULL) { + char pfx= str[1]; + int extra_len= 0; + if ((pfx=='+')||(pfx=='|')||(pfx=='_')||(pfx=='-')) { + extra_len= 1; + str++; + } + else if (pfx=='(') { + extra_len= 2; + str++; + } + + if ((str[1]=='l')&&defs->layout) + len+= strlen(defs->layout)+extra_len; + else if ((str[1]=='m')&&defs->model) + len+= strlen(defs->model)+extra_len; + else if ((str[1]=='v')&&defs->variant) + len+= strlen(defs->variant)+extra_len; + if ((pfx=='(')&&(str[2]==')')) { + str++; + } + str= index(&str[1],'%'); + } + name= (char *)_XkbAlloc(len+1); + str= orig; + outstr= name; + while (*str!='\0') { + if (str[0]=='%') { + char pfx,sfx; + str++; + pfx= str[0]; + sfx= '\0'; + if ((pfx=='+')||(pfx=='|')||(pfx=='_')||(pfx=='-')) { + str++; + } + else if (pfx=='(') { + sfx= ')'; + str++; + } + else pfx= '\0'; + + if ((str[0]=='l')&&(defs->layout)) { + if (pfx) *outstr++= pfx; + strcpy(outstr,defs->layout); + outstr+= strlen(defs->layout); + if (sfx) *outstr++= sfx; + } + else if ((str[0]=='m')&&(defs->model)) { + if (pfx) *outstr++= pfx; + strcpy(outstr,defs->model); + outstr+= strlen(defs->model); + if (sfx) *outstr++= sfx; + } + else if ((str[0]=='v')&&(defs->variant)) { + if (pfx) *outstr++= pfx; + strcpy(outstr,defs->variant); + outstr+= strlen(defs->variant); + if (sfx) *outstr++= sfx; + } + str++; + if ((pfx=='(')&&(str[0]==')')) + str++; + } + else { + *outstr++= *str++; + } + } + *outstr++= '\0'; + if (orig!=name) + _XkbFree(orig); + return name; +} + +/***====================================================================***/ + +Bool +#if NeedFunctionPrototypes +XkbRF_GetComponents( XkbRF_RulesPtr rules, + XkbRF_VarDefsPtr defs, + XkbComponentNamesPtr names) +#else +XkbRF_GetComponents(rules,defs,names) + XkbRF_RulesPtr rules; + XkbRF_VarDefsPtr defs; + XkbComponentNamesPtr names; +#endif +{ +Bool complete; + + bzero((char *)names,sizeof(XkbComponentNamesRec)); + XkbRF_ClearPartialMatches(rules); + complete= XkbRF_CheckApplyRules(rules,defs,names); + if (!complete) + complete= XkbRF_ApplyPartialMatches(rules,names); + XkbRF_CheckApplyDelayedRules(rules,defs,names); + if (names->keycodes) + names->keycodes= XkbRF_SubstituteVars(names->keycodes,defs); + if (names->symbols) + names->symbols= XkbRF_SubstituteVars(names->symbols,defs); + if (names->types) + names->types= XkbRF_SubstituteVars(names->types,defs); + if (names->compat) + names->compat= XkbRF_SubstituteVars(names->compat,defs); + if (names->geometry) + names->geometry= XkbRF_SubstituteVars(names->geometry,defs); + if (names->keymap) + names->keymap= XkbRF_SubstituteVars(names->keymap,defs); + return (names->keycodes && names->symbols && names->types && + names->compat && names->geometry ) || names->keymap; +} + +XkbRF_RulePtr +#if NeedFunctionPrototypes +XkbRF_AddRule(XkbRF_RulesPtr rules) +#else +XkbRF_AddRule(rules) + XkbRF_RulesPtr rules; +#endif +{ + if (rules->sz_rules<1) { + rules->sz_rules= 16; + rules->num_rules= 0; + rules->rules= _XkbTypedCalloc(rules->sz_rules,XkbRF_RuleRec); + } + else if (rules->num_rules>=rules->sz_rules) { + rules->sz_rules*= 2; + rules->rules= _XkbTypedRealloc(rules->rules,rules->sz_rules, + XkbRF_RuleRec); + } + if (!rules->rules) { + rules->sz_rules= rules->num_rules= 0; +#ifdef DEBUG + fprintf(stderr,"Allocation failure in XkbRF_AddRule\n"); +#endif + return NULL; + } + bzero((char *)&rules->rules[rules->num_rules],sizeof(XkbRF_RuleRec)); + return &rules->rules[rules->num_rules++]; +} + +Bool +#if NeedFunctionPrototypes +XkbRF_LoadRules(FILE *file, XkbRF_RulesPtr rules) +#else +XkbRF_LoadRules(file,rules) + FILE * file; + XkbRF_RulesPtr rules; +#endif +{ +InputLine line; +RemapSpec remap; +XkbRF_RuleRec trule,*rule; + + if (!(rules && file)) + return False; + bzero((char *)&remap,sizeof(RemapSpec)); + InitInputLine(&line); + while (GetInputLine(file,&line,True)) { + if (CheckLine(&line,&remap,&trule)) { + if ((rule= XkbRF_AddRule(rules))!=NULL) { + *rule= trule; + bzero((char *)&trule,sizeof(XkbRF_RuleRec)); + } + } + line.num_line= 0; + } + FreeInputLine(&line); + return True; +} + +Bool +#if NeedFunctionPrototypes +XkbRF_LoadRulesByName(char *base,char *locale,XkbRF_RulesPtr rules) +#else +XkbRF_LoadRulesByName(base,locale,rules) + char * base; + char * locale; + XkbRF_RulesPtr rules; +#endif +{ +FILE * file; +char buf[PATH_MAX]; +Bool ok; + + if ((!base)||(!rules)) + return False; + if (locale) { + if (strlen(base)+strlen(locale)+2 > PATH_MAX) + return False; + sprintf(buf,"%s-%s", base, locale); + } + else { + if (strlen(base)+1 > PATH_MAX) + return False; + strcpy(buf,base); + } + + file= fopen(buf, "r"); + if ((!file)&&(locale)) { /* fallback if locale was specified */ + strcpy(buf,base); + file= fopen(buf, "r"); + } + if (!file) + return False; + ok= XkbRF_LoadRules(file,rules); + fclose(file); + return ok; +} + +/***====================================================================***/ + +#define HEAD_NONE 0 +#define HEAD_MODEL 1 +#define HEAD_LAYOUT 2 +#define HEAD_VARIANT 3 +#define HEAD_OPTION 4 +#define HEAD_EXTRA 5 + +XkbRF_VarDescPtr +#if NeedFunctionPrototypes +XkbRF_AddVarDesc(XkbRF_DescribeVarsPtr vars) +#else +XkbRF_AddVarDesc(vars) + XkbRF_DescribeVarsPtr vars; +#endif +{ + if (vars->sz_desc<1) { + vars->sz_desc= 16; + vars->num_desc= 0; + vars->desc= _XkbTypedCalloc(vars->sz_desc,XkbRF_VarDescRec); + } + else if (vars->num_desc>=vars->sz_desc) { + vars->sz_desc*= 2; + vars->desc= _XkbTypedRealloc(vars->desc,vars->sz_desc,XkbRF_VarDescRec); + } + if (!vars->desc) { + vars->sz_desc= vars->num_desc= 0; + PR_DEBUG("Allocation failure in XkbRF_AddVarDesc\n"); + return NULL; + } + vars->desc[vars->num_desc].name= NULL; + vars->desc[vars->num_desc].desc= NULL; + return &vars->desc[vars->num_desc++]; +} + +XkbRF_VarDescPtr +#if NeedFunctionPrototypes +XkbRF_AddVarDescCopy(XkbRF_DescribeVarsPtr vars,XkbRF_VarDescPtr from) +#else +XkbRF_AddVarDescCopy(vars,from) + XkbRF_DescribeVarsPtr vars; + XkbRF_VarDescPtr from; +#endif +{ +XkbRF_VarDescPtr nd; + + if ((nd=XkbRF_AddVarDesc(vars))!=NULL) { + nd->name= _XkbDupString(from->name); + nd->desc= _XkbDupString(from->desc); + } + return nd; +} + +XkbRF_DescribeVarsPtr +#if NeedFunctionPrototypes +XkbRF_AddVarToDescribe(XkbRF_RulesPtr rules,char *name) +#else +XkbRF_AddVarToDescribe(rules,name) + XkbRF_RulesPtr rules; + char * name; +#endif +{ + if (rules->sz_extra<1) { + rules->num_extra= 0; + rules->sz_extra= 1; + rules->extra_names= _XkbTypedCalloc(rules->sz_extra,char *); + rules->extra= _XkbTypedCalloc(rules->sz_extra, XkbRF_DescribeVarsRec); + } + else if (rules->num_extra>=rules->sz_extra) { + rules->sz_extra*= 2; + rules->extra_names= _XkbTypedRealloc(rules->extra_names,rules->sz_extra, + char *); + rules->extra=_XkbTypedRealloc(rules->extra, rules->sz_extra, + XkbRF_DescribeVarsRec); + } + if ((!rules->extra_names)||(!rules->extra)) { + PR_DEBUG("allocation error in extra parts\n"); + rules->sz_extra= rules->num_extra= 0; + rules->extra_names= NULL; + rules->extra= NULL; + return NULL; + } + rules->extra_names[rules->num_extra]= _XkbDupString(name); + bzero(&rules->extra[rules->num_extra],sizeof(XkbRF_DescribeVarsRec)); + return &rules->extra[rules->num_extra++]; +} + +Bool +#if NeedFunctionPrototypes +XkbRF_LoadDescriptions(FILE *file,XkbRF_RulesPtr rules) +#else +XkbRF_LoadDescriptions(file,rules) + FILE * file; + XkbRF_RulesPtr rules; +#endif +{ +InputLine line; +XkbRF_VarDescRec tmp; +char *tok; +int len,headingtype,extra_ndx; + + bzero((char *)&tmp, sizeof(XkbRF_VarDescRec)); + headingtype = HEAD_NONE; + InitInputLine(&line); + for ( ; GetInputLine(file,&line,False); line.num_line= 0) { + if (line.line[0]=='!') { + tok = strtok(&(line.line[1]), " \t"); + if (!_XkbStrCaseCmp(tok,"model")) + headingtype = HEAD_MODEL; + else if (!_XkbStrCaseCmp(tok,"layout")) + headingtype = HEAD_LAYOUT; + else if (!_XkbStrCaseCmp(tok,"variant")) + headingtype = HEAD_VARIANT; + else if (!_XkbStrCaseCmp(tok,"option")) + headingtype = HEAD_OPTION; + else { + int i; + headingtype = HEAD_EXTRA; + extra_ndx= -1; + for (i=0;(inum_extra)&&(extra_ndx<0);i++) { + if (!_XkbStrCaseCmp(tok,rules->extra_names[i])) + extra_ndx= i; + } + if (extra_ndx<0) { + XkbRF_DescribeVarsPtr var; + PR_DEBUG1("Extra heading \"%s\" encountered\n",tok); + var= XkbRF_AddVarToDescribe(rules,tok); + if (var) + extra_ndx= var-rules->extra; + else headingtype= HEAD_NONE; + } + } + continue; + } + + if (headingtype == HEAD_NONE) { + PR_DEBUG("Must have a heading before first line of data\n"); + PR_DEBUG("Illegal line of data ignored\n"); + continue; + } + + len = strlen(line.line); + if ((tmp.name= strtok(line.line, " \t")) == NULL) { + PR_DEBUG("Huh? No token on line\n"); + PR_DEBUG("Illegal line of data ignored\n"); + continue; + } + if (strlen(tmp.name) == len) { + PR_DEBUG("No description found\n"); + PR_DEBUG("Illegal line of data ignored\n"); + continue; + } + + tok = line.line + strlen(tmp.name) + 1; + while ((*tok!='\n')&&isspace(*tok)) + tok++; + if (*tok == '\0') { + PR_DEBUG("No description found\n"); + PR_DEBUG("Illegal line of data ignored\n"); + continue; + } + tmp.desc= tok; + switch (headingtype) { + case HEAD_MODEL: + XkbRF_AddVarDescCopy(&rules->models,&tmp); + break; + case HEAD_LAYOUT: + XkbRF_AddVarDescCopy(&rules->layouts,&tmp); + break; + case HEAD_VARIANT: + XkbRF_AddVarDescCopy(&rules->variants,&tmp); + break; + case HEAD_OPTION: + XkbRF_AddVarDescCopy(&rules->options,&tmp); + break; + case HEAD_EXTRA: + XkbRF_AddVarDescCopy(&rules->extra[extra_ndx],&tmp); + break; + } + } + FreeInputLine(&line); + if ((rules->models.num_desc==0) && (rules->layouts.num_desc==0) && + (rules->variants.num_desc==0) && (rules->options.num_desc==0) && + (rules->num_extra==0)) { + return False; + } + return True; +} + +Bool +#if NeedFunctionPrototypes +XkbRF_LoadDescriptionsByName(char *base,char *locale,XkbRF_RulesPtr rules) +#else +XkbRF_LoadDescriptionsByName(base,locale,rules) + char * base; + char * locale; + XkbRF_RulesPtr rules; +#endif +{ +FILE * file; +char buf[PATH_MAX]; +Bool ok; + + if ((!base)||(!rules)) + return False; + if (locale) { + if (strlen(base)+strlen(locale)+6 > PATH_MAX) + return False; + sprintf(buf,"%s-%s.lst", base, locale); + } + else { + if (strlen(base)+5 > PATH_MAX) + return False; + sprintf(buf,"%s.lst", base); + } + + file= fopen(buf, "r"); + if ((!file)&&(locale)) { /* fallback if locale was specified */ + sprintf(buf,"%s.lst", base); + + file= fopen(buf, "r"); + } + if (!file) + return False; + ok= XkbRF_LoadDescriptions(file,rules); + fclose(file); + return ok; +} + +/***====================================================================***/ + +XkbRF_RulesPtr +#if NeedFunctionPrototypes +XkbRF_Load(char *base,char *locale,Bool wantDesc,Bool wantRules) +#else +XkbRF_Load(base,locale,wantDesc,wantRules) + char *base; + char *locale; + Bool wantDesc; + Bool wantRules; +#endif +{ +XkbRF_RulesPtr rules; + + if ((!base)||((!wantDesc)&&(!wantRules))) + return NULL; + if ((rules=_XkbTypedCalloc(1,XkbRF_RulesRec))==NULL) + return NULL; + if (wantDesc&&(!XkbRF_LoadDescriptionsByName(base,locale,rules))) { + XkbRF_Free(rules,True); + return NULL; + } + if (wantRules&&(!XkbRF_LoadRulesByName(base,locale,rules))) { + XkbRF_Free(rules,True); + return NULL; + } + return rules; +} + +XkbRF_RulesPtr +XkbRF_Create(int szRules,int szExtra) +{ +XkbRF_RulesPtr rules; + + if ((rules=_XkbTypedCalloc(1,XkbRF_RulesRec))==NULL) + return NULL; + if (szRules>0) { + rules->sz_rules= szRules; + rules->rules= _XkbTypedCalloc(rules->sz_rules,XkbRF_RuleRec); + if (!rules->rules) { + _XkbFree(rules); + return NULL; + } + } + if (szExtra>0) { + rules->sz_extra= szExtra; + rules->extra= _XkbTypedCalloc(rules->sz_extra,XkbRF_DescribeVarsRec); + if (!rules->extra) { + if (rules->rules) + _XkbFree(rules->rules); + _XkbFree(rules); + return NULL; + } + } + return rules; +} + +/***====================================================================***/ + +static void +#if NeedFunctionPrototypes +XkbRF_ClearVarDescriptions(XkbRF_DescribeVarsPtr var) +#else +XkbRF_ClearVarDescriptions(var) + XkbRF_DescribeVarsPtr var; +#endif +{ +register int i; + + for (i=0;inum_desc;i++) { + if (var->desc[i].name) + _XkbFree(var->desc[i].name); + if (var->desc[i].desc) + _XkbFree(var->desc[i].desc); + var->desc[i].name= var->desc[i].desc= NULL; + } + if (var->desc) + _XkbFree(var->desc); + var->desc= NULL; + return; +} + +void +#if NeedFunctionPrototypes +XkbRF_Free(XkbRF_RulesPtr rules,Bool freeRules) +#else +XkbRF_Free(rules,freeRules) + XkbRF_RulesPtr rules; + Bool freeRules; +#endif +{ +int i; +XkbRF_RulePtr rule; + + if (!rules) + return; + XkbRF_ClearVarDescriptions(&rules->models); + XkbRF_ClearVarDescriptions(&rules->layouts); + XkbRF_ClearVarDescriptions(&rules->variants); + XkbRF_ClearVarDescriptions(&rules->options); + if (rules->extra) { + for (i = 0; i < rules->num_extra; i++) { + XkbRF_ClearVarDescriptions(&rules->extra[i]); + } + _XkbFree(rules->extra); + rules->num_extra= rules->sz_extra= 0; + rules->extra= NULL; + } + if (rules->rules) { + for (i=0,rule=rules->rules;inum_rules;i++,rule++) { + if (rule->model) _XkbFree(rule->model); + if (rule->layout) _XkbFree(rule->layout); + if (rule->variant) _XkbFree(rule->variant); + if (rule->option) _XkbFree(rule->option); + if (rule->keycodes) _XkbFree(rule->keycodes); + if (rule->symbols) _XkbFree(rule->symbols); + if (rule->types) _XkbFree(rule->types); + if (rule->compat) _XkbFree(rule->compat); + if (rule->geometry) _XkbFree(rule->geometry); + if (rule->keymap) _XkbFree(rule->keymap); + bzero((char *)rule,sizeof(XkbRF_RuleRec)); + } + _XkbFree(rules->rules); + rules->num_rules= rules->sz_rules= 0; + rules->rules= NULL; + } + if (freeRules) + _XkbFree(rules); + return; +} + +#ifndef XKB_IN_SERVER + +Bool +#if NeedFunctionPrototypes +XkbRF_GetNamesProp(Display *dpy,char **rf_rtrn,XkbRF_VarDefsPtr vd_rtrn) +#else +XkbRF_GetNamesProp(dpy,rf_rtrn,vd_rtrn) + Display * dpy; + char ** rf_rtrn; + XkbRF_VarDefsPtr vd_rtrn; +#endif +{ +Atom rules_atom,actual_type; +int fmt; +unsigned long nitems,bytes_after; +char *data,*out; +Status rtrn; + + rules_atom= XInternAtom(dpy,_XKB_RF_NAMES_PROP_ATOM,True); + if (rules_atom==None) /* property cannot exist */ + return False; + rtrn= XGetWindowProperty(dpy,DefaultRootWindow(dpy),rules_atom, + 0L,_XKB_RF_NAMES_PROP_MAXLEN,False, + XA_STRING,&actual_type, + &fmt,&nitems,&bytes_after, + (unsigned char **)&data); + if (rtrn!=Success) + return False; + if (rf_rtrn) + *rf_rtrn= NULL; + (void)bzero((char *)vd_rtrn,sizeof(XkbRF_VarDefsRec)); + if ((bytes_after>0)||(actual_type!=XA_STRING)||(fmt!=8)) { + if (data) XFree(data); + return (fmt==0?True:False); + } + + out= data; + if (out && (*out) && rf_rtrn) + *rf_rtrn= _XkbDupString(out); + out+=strlen(out)+1; + + if ((out-data)model= _XkbDupString(out); + out+=strlen(out)+1; + } + + if ((out-data)layout= _XkbDupString(out); + out+=strlen(out)+1; + } + + if ((out-data)variant= _XkbDupString(out); + out+=strlen(out)+1; + } + + + if ((out-data)options= _XkbDupString(out); + out+=strlen(out)+1; + } + XFree(data); + return True; +} + +Bool +#if NeedFunctionPrototypes +XkbRF_SetNamesProp(Display *dpy,char *rules_file,XkbRF_VarDefsPtr var_defs) +#else +XkbRF_SetNamesProp(dpy,rules_file,var_defs) + Display * dpy; + char * rules_file; + XkbRF_VarDefsPtr var_defs; +#endif +{ +int len,out; +Atom name; +char * pval; + + len= (rules_file?strlen(rules_file):0); + len+= (var_defs->model?strlen(var_defs->model):0); + len+= (var_defs->layout?strlen(var_defs->layout):0); + len+= (var_defs->variant?strlen(var_defs->variant):0); + len+= (var_defs->options?strlen(var_defs->options):0); + if (len<1) + return True; + + len+= 5; /* trailing NULs */ + + name= XInternAtom(dpy,_XKB_RF_NAMES_PROP_ATOM,False); + if (name==None) { /* should never happen */ + _XkbLibError(_XkbErrXReqFailure,"XkbRF_SetNamesProp",X_InternAtom); + return False; + } + pval= (char *)_XkbAlloc(len); + if (!pval) { + _XkbLibError(_XkbErrBadAlloc,"XkbRF_SetNamesProp",len); + return False; + } + out= 0; + if (rules_file) { + strcpy(&pval[out],rules_file); + out+= strlen(rules_file); + } + pval[out++]= '\0'; + if (var_defs->model) { + strcpy(&pval[out],var_defs->model); + out+= strlen(var_defs->model); + } + pval[out++]= '\0'; + if (var_defs->layout) { + strcpy(&pval[out],var_defs->layout); + out+= strlen(var_defs->layout); + } + pval[out++]= '\0'; + if (var_defs->variant) { + strcpy(&pval[out],var_defs->variant); + out+= strlen(var_defs->variant); + } + pval[out++]= '\0'; + if (var_defs->options) { + strcpy(&pval[out],var_defs->options); + out+= strlen(var_defs->options); + } + pval[out++]= '\0'; + if (out!=len) { + _XkbLibError(_XkbErrBadLength,"XkbRF_SetNamesProp",out); + _XkbFree(pval); + return False; + } + + XChangeProperty(dpy,DefaultRootWindow(dpy),name,XA_STRING,8,PropModeReplace, + (unsigned char *)pval,len); + _XkbFree(pval); + return True; +} + +#endif diff --git a/src/srvmisc.c b/src/srvmisc.c new file mode 100644 index 0000000..8dfde74 --- /dev/null +++ b/src/srvmisc.c @@ -0,0 +1,233 @@ +/* $Xorg: srvmisc.c,v 1.3 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif +#include +#include +#include + +#include "XKMformat.h" +#include "XKBfileInt.h" + +Bool +#if NeedFunctionPrototypes +XkbWriteToServer(XkbFileInfo *result) +#else +XkbWriteToServer(result) + XkbFileInfo * result; +#endif +{ +XkbDescPtr xkb; +Display * dpy; + + if ((result==NULL)||(result->xkb==NULL)||(result->xkb->dpy==NULL)) + return False; + xkb= result->xkb; + dpy= xkb->dpy; + if (!XkbSetMap(dpy,XkbAllMapComponentsMask,xkb)) + return False; + if (!XkbSetIndicatorMap(dpy,~0,xkb)) + return False; +#ifdef NOTYET + if (!XkbSetControls(dpy,XkbAllControlsMask,xkb)) + return False; +#endif + if (!XkbSetCompatMap(dpy,XkbAllCompatMask,xkb,True)) + return False; + if (!XkbSetNames(dpy,XkbAllNamesMask,0,xkb->map->num_types,xkb)) + return False; + if (xkb->geom) { + if (XkbSetGeometry(dpy,xkb->device_spec,xkb->geom)!=Success) + return False; + } + return True; +#ifdef NOTYET + switch (result->type) { + case XkmSemanticsFile: + func= WriteCHdrSemantics; + break; + case XkmLayoutFile: + func= WriteCHdrLayout; + break; + case XkmKeymapFile: + func= WriteCHdrKeymap; + break; + default: + _XkbLibError(_XkbErrIllegalContents,"XkbWriteToServer",result->type); + break; + } + return ok; +#endif +} + +unsigned +#if NeedFunctionPrototypes +XkbReadFromServer(Display *dpy,unsigned need,unsigned want,XkbFileInfo *result) +#else +XkbReadFromServer(dpy,need,want,result) + Display * dpy; + unsigned need; + unsigned want; + XkbFileInfo * result; +#endif +{ +unsigned which= need|want; +unsigned tmp; + + if ((result==NULL)||(dpy==NULL)) + return which; + + if (which&XkmSymbolsMask) tmp= XkbAllMapComponentsMask; + else if (which&XkmTypesMask) tmp= XkbKeyTypesMask; + if (result->xkb==NULL) { + result->xkb= XkbGetMap(dpy,tmp,XkbUseCoreKbd); + if (!result->xkb) + return which; + else which&= ~(XkmSymbolsMask|XkmTypesMask|XkmVirtualModsMask); + } + else if ((tmp)&&(XkbGetUpdatedMap(dpy,tmp,result->xkb)==Success)) + which&= ~(XkmSymbolsMask|XkmTypesMask|XkmVirtualModsMask); + + if (which&XkmIndicatorsMask) { + if (XkbGetIndicatorMap(dpy,XkbAllIndicatorsMask,result->xkb)==Success) + which&= ~XkmIndicatorsMask; + } + + if (which&XkmCompatMapMask) { + if (XkbGetCompatMap(dpy,XkbAllCompatMask,result->xkb)==Success) + which&= ~XkmCompatMapMask; + } + if (which&XkmGeometryMask) { + if (XkbGetGeometry(dpy,result->xkb)==Success) + which&= ~XkmGeometryMask; + } + XkbGetNames(dpy,XkbAllNamesMask,result->xkb); + return which; +} + +Status +#if NeedFunctionPrototypes +XkbChangeKbdDisplay(Display *newDpy,XkbFileInfo *result) +#else +XkbChangeKbdDisplay(newDpy,result) + Display * newDpy; + XkbFileInfo * result; +#endif +{ +register int i; +XkbDescPtr xkb; +Display * oldDpy; +Atom * atm; + + if ((result->xkb==NULL)||(result->xkb->dpy==newDpy)) + return Success; + xkb= result->xkb; + oldDpy= xkb->dpy; + if (xkb->names) { + XkbNamesPtr names= xkb->names; + names->keycodes= XkbChangeAtomDisplay(oldDpy,newDpy,names->keycodes); + names->geometry= XkbChangeAtomDisplay(oldDpy,newDpy,names->geometry); + names->symbols= XkbChangeAtomDisplay(oldDpy,newDpy,names->symbols); + names->types= XkbChangeAtomDisplay(oldDpy,newDpy,names->types); + names->compat= XkbChangeAtomDisplay(oldDpy,newDpy,names->compat); + names->phys_symbols= XkbChangeAtomDisplay(oldDpy,newDpy, + names->phys_symbols); + for (i=0,atm=names->vmods;iindicators;igroups;iradio_groups;inum_rg;i++,atm++) { + *atm= XkbChangeAtomDisplay(oldDpy,newDpy,*atm); + } + } + if (xkb->map) { + register int t; + XkbKeyTypePtr type; + for (t=0,type=xkb->map->types;tmap->num_types;t++,type++) { + type->name= XkbChangeAtomDisplay(oldDpy,newDpy,type->name); + if (type->level_names!=NULL) { + for (i=0,atm=type->level_names;inum_levels;i++,atm++) { + *atm= XkbChangeAtomDisplay(oldDpy,newDpy,*atm); + } + } + } + } + if (xkb->geom) { + XkbGeometryPtr geom= xkb->geom; + geom->name= XkbChangeAtomDisplay(oldDpy,newDpy,geom->name); + if (geom->shapes) { + register int s; + XkbShapePtr shape; + for (s=0,shape=geom->shapes;snum_shapes;s++,shape++) { + shape->name= XkbChangeAtomDisplay(oldDpy,newDpy,shape->name); + } + } + if (geom->sections) { + register int s; + XkbSectionPtr section; + for (s=0,section=geom->sections;snum_sections;s++,section++){ + section->name=XkbChangeAtomDisplay(oldDpy,newDpy,section->name); + if (section->doodads) { + register int d; + XkbDoodadPtr doodad; + for (d=0,doodad=section->doodads;dnum_doodads; + d++,doodad++) { + doodad->any.name= XkbChangeAtomDisplay(oldDpy,newDpy, + doodad->any.name); + } + } + if (section->overlays) { + register int o; + register XkbOverlayPtr ol; + for (o=0,ol=section->overlays;onum_overlays; + o++,ol++) { + ol->name= XkbChangeAtomDisplay(oldDpy,newDpy,ol->name); + } + } + } + } + if (geom->doodads) { + register int d; + XkbDoodadPtr doodad; + for (d=0,doodad=geom->doodads;dnum_doodads;d++,doodad++) { + doodad->any.name= XkbChangeAtomDisplay(oldDpy,newDpy, + doodad->any.name); + } + } + } + xkb->dpy= newDpy; + return Success; +} diff --git a/src/xkbatom.c b/src/xkbatom.c new file mode 100644 index 0000000..30675d1 --- /dev/null +++ b/src/xkbatom.c @@ -0,0 +1,284 @@ +/* $Xorg: xkbatom.c,v 1.4 2001/02/09 02:04:05 xorgcvs Exp $ */ +/*********************************************************** + +Copyright 1987, 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. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +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 Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL 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. + +******************************************************************/ + +/************************************************************ + Copyright 1994 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif +#include +#include +#include + +#include "XKMformat.h" +#include "XKBfileInt.h" + +/***====================================================================***/ + +#define InitialTableSize 100 + +typedef struct _Node { + struct _Node *left, *right; + Atom a; + unsigned int fingerPrint; + char *string; +} NodeRec, *NodePtr; + +#define BAD_RESOURCE 0xe0000000 + +static Atom lastAtom = None; +static NodePtr atomRoot = (NodePtr)NULL; +static unsigned long tableLength; +static NodePtr *nodeTable; + +static Atom +#if NeedFunctionPrototypes +_XkbMakeAtom(char *string,unsigned len,Bool makeit) +#else +_XkbMakeAtom(string, len, makeit) + char *string; + unsigned len; + Bool makeit; +#endif +{ + register NodePtr * np; + unsigned i; + int comp; + register unsigned int fp = 0; + + np = &atomRoot; + for (i = 0; i < (len+1)/2; i++) + { + fp = fp * 27 + string[i]; + fp = fp * 27 + string[len - 1 - i]; + } + while (*np != (NodePtr) NULL) + { + if (fp < (*np)->fingerPrint) + np = &((*np)->left); + else if (fp > (*np)->fingerPrint) + np = &((*np)->right); + else + { /* now start testing the strings */ + comp = strncmp(string, (*np)->string, (int)len); + if ((comp < 0) || ((comp == 0) && (len < strlen((*np)->string)))) + np = &((*np)->left); + else if (comp > 0) + np = &((*np)->right); + else + return(*np)->a; + } + } + if (makeit) + { + register NodePtr nd; + + nd = (NodePtr) _XkbAlloc(sizeof(NodeRec)); + if (!nd) + return BAD_RESOURCE; + nd->string = (char *) _XkbAlloc(len + 1); + if (!nd->string) { + _XkbFree(nd); + return BAD_RESOURCE; + } + strncpy(nd->string, string, (int)len); + nd->string[len] = 0; + if ((lastAtom + 1) >= tableLength) { + NodePtr *table; + + table = (NodePtr *) _XkbRealloc(nodeTable, + tableLength * (2 * sizeof(NodePtr))); + if (!table) { + if (nd->string != string) + _XkbFree(nd->string); + _XkbFree(nd); + return BAD_RESOURCE; + } + tableLength <<= 1; + nodeTable = table; + } + *np = nd; + nd->left = nd->right = (NodePtr) NULL; + nd->fingerPrint = fp; + nd->a = (++lastAtom); + *(nodeTable+lastAtom) = nd; + return nd->a; + } + else + return None; +} + +static char * +#if NeedFunctionPrototypes +_XkbNameForAtom(Atom atom) +#else +_XkbNameForAtom(atom) + Atom atom; +#endif +{ + NodePtr node; + if (atom > lastAtom) return 0; + if ((node = nodeTable[atom]) == (NodePtr)NULL) return 0; + return node->string; +} + +static void +#if NeedFunctionPrototypes +_XkbInitAtoms(void) +#else +_XkbInitAtoms() +#endif +{ + tableLength = InitialTableSize; + nodeTable = (NodePtr *)_XkbAlloc(InitialTableSize*sizeof(NodePtr)); + nodeTable[None] = (NodePtr)NULL; +} + +/***====================================================================***/ + +char * +#if NeedFunctionPrototypes +XkbAtomGetString(Display *dpy,Atom atm) +#else +XkbAtomGetString(dpy,atm) + Display * dpy; + Atom atm; +#endif +{ + if (atm==None) + return NULL; + if (dpy==NULL) + return _XkbNameForAtom(atm); + return XGetAtomName(dpy,atm); +} + +/***====================================================================***/ + +Atom +#if NeedFunctionPrototypes +XkbInternAtom(Display *dpy,char *name,Bool onlyIfExists) +#else +XkbInternAtom(dpy,name,onlyIfExists) + Display * dpy; + char * name; + Bool onlyIfExists; +#endif +{ + if (name==NULL) + return None; + if (dpy==NULL) { + return _XkbMakeAtom(name, strlen(name), (!onlyIfExists)); + } + return XInternAtom(dpy,name,onlyIfExists); +} + +/***====================================================================***/ + +Atom +#if NeedFunctionPrototypes +XkbChangeAtomDisplay(Display *oldDpy,Display *newDpy,Atom atm) +#else +XkbChangeAtomDisplay(oldDpy,newDpy,atm) + Display * oldDpy; + Display * newDpy; + Atom atm; +#endif +{ +char *tmp; + + if (atm!=None) { + tmp= XkbAtomGetString(oldDpy,atm); + if (tmp!=NULL) + return XkbInternAtom(newDpy,tmp,False); + } + return None; +} + +/***====================================================================***/ + +void +#if NeedFunctionPrototypes +XkbInitAtoms(Display *dpy) +#else +XkbInitAtoms(dpy) + Display *dpy; +#endif +{ +static int been_here= 0; + if ((dpy==NULL)&&(!been_here)) { + _XkbInitAtoms(); + been_here= 1; + } + return; +} diff --git a/src/xkbbells.c b/src/xkbbells.c new file mode 100644 index 0000000..8214eed --- /dev/null +++ b/src/xkbbells.c @@ -0,0 +1,116 @@ +/* $Xorg: xkbbells.c,v 1.3 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1995 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. + + ********************************************************/ + +#include +#include +#include "XKBbells.h" + +static char *_xkbStdBellNames[XkbBI_NumBells] = { + "Info", + "Warning", + "MinorError", + "MajorError", + "BadValue", + "InvalidLocation", + "Question", + "Start", + "End", + "Success", + "Failure", + "Wait", + "Proceed", + "Ignore", + "Iconify", + "Deconify", + "Open", + "Close", + "TerminalBell", + "MarginBell", + "CursorStuck", + "NewMail", + "LaunchApp", + "AppDeath", + "ImAlive", + "ClockChimeHour", + "ClockChimeHalf", + "ClockChimeQuarter", + "RepeatingLastBell", + "ComposeFail", + "AX_FeatureOn", + "AX_FeatureOff", + "AX_FeatureChange", + "AX_IndicatorOn", + "AX_IndicatorOff", + "AX_IndicatorChange", + "AX_SlowKeysWarning", + "AX_SlowKeyPress", + "AX_SlowKeyAccept", + "AX_SlowKeyReject", + "AX_SlowKeyRelease", + "AX_BounceKeyReject", + "AX_StickyLatch", + "AX_StickyLock", + "AX_StickyUnlock" +}; + +static Atom _xkbStdBellAtoms[XkbBI_NumBells]; + +Bool +#if NeedFunctionPrototypes +XkbStdBell(Display *dpy,Window win,int percent,int bellDef) +#else +XkbStdBell(dpy,win,percent,bellDef) + Display * dpy; + Window win; + int percent; + int bellDef; +#endif +{ + if ((bellDef<0)||(bellDef>=XkbBI_NumBells)) + bellDef= XkbBI_Info; + if (_xkbStdBellAtoms[bellDef]==None) + _xkbStdBellAtoms[bellDef]= XInternAtom(dpy,_xkbStdBellNames[bellDef],0); + return XkbBell(dpy,win,percent,_xkbStdBellAtoms[bellDef]); +} + +Bool +#if NeedFunctionPrototypes +XkbStdBellEvent(Display *dpy,Window win,int percent,int bellDef) +#else +XkbStdBellEvent(dpy,win,percent,bellDef) + Display * dpy; + Window win; + int percent; + int bellDef; +#endif +{ + if ((bellDef<0)||(bellDef>=XkbBI_NumBells)) + bellDef= XkbBI_Info; + if (_xkbStdBellAtoms[bellDef]==None) + _xkbStdBellAtoms[bellDef]= XInternAtom(dpy,_xkbStdBellNames[bellDef],0); + return XkbBellEvent(dpy,win,percent,_xkbStdBellAtoms[bellDef]); +} diff --git a/src/xkbconfig.c b/src/xkbconfig.c new file mode 100644 index 0000000..d2e6794 --- /dev/null +++ b/src/xkbconfig.c @@ -0,0 +1,1394 @@ +/* $Xorg: xkbconfig.c,v 1.4 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1995 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif + +#include + +#include + +#ifndef XKB_IN_SERVER + +#include +#include +#include +#include +#include "XKBfileInt.h" + +#else + +#include "X.h" +#define NEED_EVENTS +#include +#include "Xproto.h" +#include "misc.h" +#include "inputstr.h" +#include "dix.h" +#define XKBSRV_NEED_FILE_FUNCS +#include "XKBsrv.h" +#endif + +#include + +/***====================================================================***/ + +#define XKBCF_MAX_STR_LEN 100 +static char _XkbCF_rtrn[XKBCF_MAX_STR_LEN+1]; + +static int +#if NeedFunctionPrototypes +ScanIdent(FILE *file,int ch,XkbCFScanResultPtr val_rtrn) +#else +ScanIdent(file,ch,val_rtrn) + FILE * file; + int ch; + XkbCFScanResultPtr val_rtrn; +#endif +{ +register int i; +char * str; + + val_rtrn->str= str= _XkbCF_rtrn; + for (i=0;(isalpha(ch)||isdigit(ch)||(ch=='_'));ch=getc(file)) { + if (istr= _XkbCF_rtrn; + return XkbCF_String; + } + return XkbCF_UnterminatedString; +} + +static int +#if NeedFunctionPrototypes +ScanInteger(FILE *file,int ch,XkbCFScanResultPtr val_rtrn) +#else +ScanInteger(file,ch,val_rtrn) + FILE * file; + int ch; + XkbCFScanResultPtr val_rtrn; +#endif +{ +int i; + + if (isdigit(ch)) + ungetc(ch,file); + if (fscanf(file,"%i",&i)==1) { + val_rtrn->ival= i; + return XkbCF_Integer; + } + return XkbCF_Unknown; +} + +int +#if NeedFunctionPrototypes +XkbCFScan(FILE *file,XkbCFScanResultPtr val_rtrn,XkbConfigRtrnPtr rtrn) +#else +XkbCFScan(file,val_rtrn,rtrn) + FILE * file; + XkbCFScanResultPtr val_rtrn; + XkbConfigRtrnPtr rtrn; +#endif +{ +int ch; + + do { + ch= getc(file); + } while ((ch=='\t')||(ch==' ')); + if (isalpha(ch)) + return ScanIdent(file,ch,val_rtrn); + else if (isdigit(ch)) + return ScanInteger(file,ch,val_rtrn); + else if (ch=='"') + return ScanString(file,ch,val_rtrn); + else if (ch=='\n') { + rtrn->line++; + return XkbCF_EOL; + } + else if (ch==';') + return XkbCF_Semi; + else if (ch=='=') + return XkbCF_Equals; + else if (ch=='+') { + ch= getc(file); + if (ch=='=') + return XkbCF_PlusEquals; + if ((ch!=EOF)&&(ch!=' ')&&(ch!='\t')) + ungetc(ch,file); + return XkbCF_Plus; + } + else if (ch=='-') { + ch= getc(file); + if (ch=='=') + return XkbCF_MinusEquals; + if ((ch!=EOF)&&(ch!=' ')&&(ch!='\t')) + ungetc(ch,file); + return XkbCF_Minus; + } + else if (ch==EOF) + return XkbCF_EOF; + else if ((ch=='#')||((ch=='/')&&(getc(file)=='/'))) { + while ((ch!='\n')&&(ch!=EOF)) + ch= getc(file); + rtrn->line++; + return XkbCF_EOL; + } + return XkbCF_Unknown; +} + +/***====================================================================***/ + +#define _XkbCF_Illegal 0 +#define _XkbCF_Keymap 1 +#define _XkbCF_Keycodes 2 +#define _XkbCF_Geometry 3 +#define _XkbCF_PhysSymbols 4 +#define _XkbCF_Symbols 5 +#define _XkbCF_Types 6 +#define _XkbCF_CompatMap 7 + +#define _XkbCF_RulesFile 8 +#define _XkbCF_Model 9 +#define _XkbCF_Layout 10 +#define _XkbCF_Variant 11 +#define _XkbCF_Options 12 + +#define _XkbCF_InitialMods 13 +#define _XkbCF_InitialCtrls 14 + +#define _XkbCF_ClickVolume 15 +#define _XkbCF_BellVolume 16 +#define _XkbCF_BellPitch 17 +#define _XkbCF_BellDuration 18 +#define _XkbCF_RepeatDelay 19 +#define _XkbCF_RepeatInterval 20 +#define _XkbCF_SlowKeysDelay 21 +#define _XkbCF_DebounceDelay 22 +#define _XkbCF_MouseKeysDelay 23 +#define _XkbCF_MouseKeysInterval 24 +#define _XkbCF_MouseKeysTimeToMax 25 +#define _XkbCF_MouseKeysMaxSpeed 26 +#define _XkbCF_MouseKeysCurve 27 +#define _XkbCF_AccessXTimeout 28 +#define _XkbCF_AccessXTimeoutCtrlsOn 29 +#define _XkbCF_AccessXTimeoutCtrlsOff 30 +#define _XkbCF_AccessXTimeoutOptsOn 31 +#define _XkbCF_AccessXTimeoutOptsOff 32 + +#define _XkbCF_IgnoreLockMods 33 +#define _XkbCF_IgnoreGroupLock 34 +#define _XkbCF_InternalMods 35 + +#define _XkbCF_GroupsWrap 36 + +static Bool +#if NeedFunctionPrototypes +AddCtrlByName(XkbConfigRtrnPtr rtrn,char *name,unsigned long *ctrls_rtrn) +#else +AddCtrlByName(rtrn,name,ctrls_rtrn) + XkbConfigRtrnPtr rtrn; + char * name; + unsigned long * ctrls_rtrn; +#endif +{ + if ((_XkbStrCaseCmp(name,"repeat")==0)|| + (_XkbStrCaseCmp(name,"repeatkeys")==0)) + *ctrls_rtrn= XkbRepeatKeysMask; + else if (_XkbStrCaseCmp(name,"slowkeys")==0) + *ctrls_rtrn= XkbSlowKeysMask; + else if (_XkbStrCaseCmp(name,"bouncekeys")==0) + *ctrls_rtrn= XkbBounceKeysMask; + else if (_XkbStrCaseCmp(name,"stickykeys")==0) + *ctrls_rtrn= XkbStickyKeysMask; + else if (_XkbStrCaseCmp(name,"mousekeys")==0) + *ctrls_rtrn= XkbMouseKeysMask; + else if (_XkbStrCaseCmp(name,"mousekeysaccel")==0) + *ctrls_rtrn= XkbMouseKeysAccelMask; + else if (_XkbStrCaseCmp(name,"accessxkeys")==0) + *ctrls_rtrn= XkbAccessXKeysMask; + else if (_XkbStrCaseCmp(name,"accessxtimeout")==0) + *ctrls_rtrn= XkbAccessXTimeoutMask; + else if (_XkbStrCaseCmp(name,"accessxfeedback")==0) + *ctrls_rtrn= XkbAccessXFeedbackMask; + else if (_XkbStrCaseCmp(name,"audiblebell")==0) + *ctrls_rtrn= XkbAudibleBellMask; + else if (_XkbStrCaseCmp(name,"overlay1")==0) + *ctrls_rtrn= XkbOverlay1Mask; + else if (_XkbStrCaseCmp(name,"overlay2")==0) + *ctrls_rtrn= XkbOverlay2Mask; + else if (_XkbStrCaseCmp(name,"ignoregrouplock")==0) + *ctrls_rtrn= XkbIgnoreGroupLockMask; + else { + rtrn->error= XkbCF_ExpectedControl; + return False; + } + return True; +} + +static Bool +#if NeedFunctionPrototypes +AddAXTimeoutOptByName( XkbConfigRtrnPtr rtrn, + char * name, + unsigned short * opts_rtrn) +#else +AddAXTimeoutOptByName(rtrn,name,opts_rtrn) + XkbConfigRtrnPtr rtrn; + char * name; + unsigned short * opts_rtrn; +#endif +{ + if (_XkbStrCaseCmp(name,"slowkeyspress")==0) + *opts_rtrn= XkbAX_SKPressFBMask; + else if (_XkbStrCaseCmp(name,"slowkeysaccept")==0) + *opts_rtrn= XkbAX_SKAcceptFBMask; + else if (_XkbStrCaseCmp(name,"feature")==0) + *opts_rtrn= XkbAX_FeatureFBMask; + else if (_XkbStrCaseCmp(name,"slowwarn")==0) + *opts_rtrn= XkbAX_SlowWarnFBMask; + else if (_XkbStrCaseCmp(name,"indicator")==0) + *opts_rtrn= XkbAX_IndicatorFBMask; + else if (_XkbStrCaseCmp(name,"stickykeys")==0) + *opts_rtrn= XkbAX_StickyKeysFBMask; + else if (_XkbStrCaseCmp(name,"slowkeysrelease")==0) + *opts_rtrn= XkbAX_SKReleaseFBMask; + else if (_XkbStrCaseCmp(name,"slowkeysreject")==0) + *opts_rtrn= XkbAX_SKRejectFBMask; + else if (_XkbStrCaseCmp(name,"bouncekeysreject")==0) + *opts_rtrn= XkbAX_BKRejectFBMask; + else if (_XkbStrCaseCmp(name,"dumbbell")==0) + *opts_rtrn= XkbAX_DumbBellFBMask; + else { + rtrn->error= XkbCF_ExpectedControl; + return False; + } + return True; +} + +XkbConfigUnboundModPtr +#if NeedFunctionPrototypes +XkbCFAddModByName( XkbConfigRtrnPtr rtrn, + int what, + char * name, + Bool merge, + XkbConfigUnboundModPtr last) +#else +XkbCFAddModByName(rtrn,what,name,merge,last) + XkbConfigRtrnPtr rtrn; + int what; + char * name; + Bool merge; + XkbConfigUnboundModPtr last; +#endif +{ + if (rtrn->num_unbound_mods>=rtrn->sz_unbound_mods) { + rtrn->sz_unbound_mods+= 5; + rtrn->unbound_mods= _XkbTypedRealloc(rtrn->unbound_mods, + rtrn->sz_unbound_mods, + XkbConfigUnboundModRec); + if (rtrn->unbound_mods==NULL) { + rtrn->error= XkbCF_BadAlloc; + return False; + } + } + if (last==NULL) { + last= &rtrn->unbound_mods[rtrn->num_unbound_mods++]; + last->what= what; + last->mods= 0; + last->vmods= 0; + last->merge= merge; + last->name= NULL; + } + if (_XkbStrCaseCmp(name,"shift")==0) + last->mods|= ShiftMask; + else if (_XkbStrCaseCmp(name,"lock")==0) + last->mods|= LockMask; + else if ((_XkbStrCaseCmp(name,"control")==0)|| + (_XkbStrCaseCmp(name,"ctrl")==0)) + last->mods|= ControlMask; + else if (_XkbStrCaseCmp(name,"mod1")==0) + last->mods|= Mod1Mask; + else if (_XkbStrCaseCmp(name,"mod2")==0) + last->mods|= Mod2Mask; + else if (_XkbStrCaseCmp(name,"mod3")==0) + last->mods|= Mod3Mask; + else if (_XkbStrCaseCmp(name,"mod4")==0) + last->mods|= Mod4Mask; + else if (_XkbStrCaseCmp(name,"mod5")==0) + last->mods|= Mod5Mask; + else { + if (last->name!=NULL) { + last= &rtrn->unbound_mods[rtrn->num_unbound_mods++]; + last->what= what; + last->mods= 0; + last->vmods= 0; + last->merge= merge; + last->name= NULL; + } + last->name= _XkbDupString(name); + } + return last; +} + +int +#if NeedFunctionPrototypes +XkbCFBindMods(XkbConfigRtrnPtr rtrn,XkbDescPtr xkb) +#else +XkbCFBindMods(rtrn,xkb) + XkbConfigRtrnPtr rtrn; + XkbDescPtr xkb; +#endif +{ +register int n,v; +Atom name; +XkbConfigUnboundModPtr mod; +int missing; + + if (rtrn->num_unbound_mods<1) + return 0; + if ((xkb==NULL) || (xkb->names==NULL)) + return -1; + + missing= 0; + for (n=0,mod=rtrn->unbound_mods;nnum_unbound_mods;n++,mod++) { + if (mod->name!=NULL) { + name= XkbInternAtom(xkb->dpy,mod->name,True); + if (name==None) + continue; + for (v=0;vnames->vmods[v]==name) { + mod->vmods= (1<name); + mod->name= NULL; + break; + } + } + if (mod->name!=NULL) + missing++; + } + } + return missing; +} + +Bool +#if NeedFunctionPrototypes +XkbCFApplyMods(XkbConfigRtrnPtr rtrn,int what,XkbConfigModInfoPtr info) +#else +XkbCFApplyMods(rtrn,what,info) + XkbConfigRtrnPtr rtrn; + int what; + XkbConfigModInfoPtr info; +#endif +{ +register int n; +XkbConfigUnboundModPtr mod; + + if (rtrn->num_unbound_mods<1) + return True; + + for (n=0,mod=rtrn->unbound_mods;nnum_unbound_mods;n++,mod++) { + if (mod->what!=what) + continue; + if (mod->merge==XkbCF_MergeRemove) { + info->mods_clear|= mod->mods; + info->vmods_clear|= mod->vmods; + } + else { + if (mod->merge==XkbCF_MergeSet) + info->replace= True; + info->mods|= mod->mods; + info->vmods|= mod->vmods; + } + if (mod->name==NULL) { + mod->what= _XkbCF_Illegal; + } + else { + mod->mods= 0; + mod->vmods= 0; + } + } + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +DefaultParser( FILE * file, + XkbConfigFieldsPtr fields, + XkbConfigFieldPtr field, + XkbDescPtr xkb, + XkbConfigRtrnPtr rtrn) +#else +DefaultParser(file,fields,field,xkb,rtrn) + FILE * file; + XkbConfigFieldsPtr fields; + XkbConfigFieldPtr field; + XkbDescPtr xkb; + XkbConfigRtrnPtr rtrn; +#endif +{ +int tok; +XkbCFScanResultRec val; +char ** str; +int merge; +unsigned long * ctrls; +unsigned short * opts; +int * pival; +int onoff; +XkbConfigUnboundModPtr last; +unsigned what; + + tok= XkbCFScan(file,&val,rtrn); + str= NULL; + onoff= 0; + pival= NULL; + switch (field->field_id) { + case _XkbCF_RulesFile: if (!str) str= &rtrn->rules_file; + case _XkbCF_Model: if (!str) str= &rtrn->model; + case _XkbCF_Layout: if (!str) str= &rtrn->layout; + case _XkbCF_Variant: if (!str) str= &rtrn->variant; + case _XkbCF_Options: if (!str) str= &rtrn->options; + case _XkbCF_Keymap: if (!str) str= &rtrn->keymap; + case _XkbCF_Keycodes: if (!str) str= &rtrn->keycodes; + case _XkbCF_Geometry: if (!str) str= &rtrn->geometry; + case _XkbCF_PhysSymbols:if (!str) str= &rtrn->phys_symbols; + case _XkbCF_Symbols: if (!str) str= &rtrn->symbols; + case _XkbCF_Types: if (!str) str= &rtrn->types; + case _XkbCF_CompatMap: if (!str) str= &rtrn->compat; + if (tok!=XkbCF_Equals) { + rtrn->error= XkbCF_MissingEquals; + goto BAILOUT; + } + tok= XkbCFScan(file,&val,rtrn); + if ((tok!=XkbCF_String)&&(tok!=XkbCF_Ident)) { + rtrn->error= XkbCF_ExpectedString; + return False; + } + tok= XkbCFScan(file,&val,rtrn); + if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) { + rtrn->error= XkbCF_ExpectedEOS; + return False; + } + if (*str!=NULL) + _XkbFree(*str); + *str= _XkbDupString(val.str); + break; + case _XkbCF_InitialMods: + case _XkbCF_IgnoreLockMods: + case _XkbCF_InternalMods: + what= XkbCF_InitialMods; + if (field->field_id==_XkbCF_InitialMods) + rtrn->defined|= (what=XkbCF_InitialMods); + else if (field->field_id==_XkbCF_InternalMods) + rtrn->defined|= (what=XkbCF_InternalMods); + else if (field->field_id==_XkbCF_IgnoreLockMods) + rtrn->defined|= (what=XkbCF_IgnoreLockMods); + if (tok==XkbCF_Equals) merge= XkbCF_MergeSet; + else if (tok==XkbCF_MinusEquals) merge= XkbCF_MergeRemove; + else if (tok==XkbCF_PlusEquals) merge= XkbCF_MergeAdd; + else { + rtrn->error= XkbCF_MissingEquals; + goto BAILOUT; + } + tok= XkbCFScan(file,&val,rtrn); + if ((tok==XkbCF_EOL)||(tok==XkbCF_Semi)||(tok==XkbCF_EOF)) { + rtrn->error= XkbCF_ExpectedModifier; + return False; + } + last= NULL; + while ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) { + if ((tok!=XkbCF_Ident)&&(tok!=XkbCF_String)) { + rtrn->error= XkbCF_ExpectedModifier; + return False; + } + last=XkbCFAddModByName(rtrn,what,val.str,merge,last); + if (last==NULL) + return False; + if (merge==XkbCF_MergeSet) + merge= XkbCF_MergeAdd; + tok= XkbCFScan(file,&val,rtrn); + if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_EOF)&&(tok!=XkbCF_Semi)) { + if (tok!=XkbCF_Plus) { + rtrn->error= XkbCF_ExpectedOperator; + return False; + } + tok= XkbCFScan(file,&val,rtrn); + } + } + break; + case _XkbCF_InitialCtrls: + rtrn->defined|= XkbCF_InitialCtrls; + opts= NULL; + ctrls= NULL; + if (tok==XkbCF_PlusEquals) + ctrls= &rtrn->initial_ctrls; + else if (tok==XkbCF_MinusEquals) + ctrls= &rtrn->initial_ctrls_clear; + else if (tok==XkbCF_Equals) { + ctrls= &rtrn->initial_ctrls; + rtrn->replace_initial_ctrls= True; + *ctrls= 0; + } + else { + rtrn->error= XkbCF_MissingEquals; + goto BAILOUT; + } + tok= XkbCFScan(file,&val,rtrn); + if ((tok==XkbCF_EOL)||(tok==XkbCF_Semi)||(tok==XkbCF_EOF)) { + rtrn->error= XkbCF_ExpectedControl; + return False; + } + while ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) { + if ((tok!=XkbCF_Ident)&&(tok!=XkbCF_String)) { + rtrn->error= XkbCF_ExpectedControl; + return False; + } + if (!AddCtrlByName(rtrn,val.str,ctrls)) { + return False; + } + tok= XkbCFScan(file,&val,rtrn); + if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_EOF)&&(tok!=XkbCF_Semi)) { + if (tok!=XkbCF_Plus) { + rtrn->error= XkbCF_ExpectedOperator; + return False; + } + tok= XkbCFScan(file,&val,rtrn); + } + } + break; + case _XkbCF_AccessXTimeoutCtrlsOn: + case _XkbCF_AccessXTimeoutCtrlsOff: + case _XkbCF_AccessXTimeoutOptsOff: + case _XkbCF_AccessXTimeoutOptsOn: + if (field->field_id==_XkbCF_AccessXTimeoutOptsOff) + field->field_id= _XkbCF_AccessXTimeoutCtrlsOff; + else if (field->field_id==_XkbCF_AccessXTimeoutCtrlsOn) + field->field_id= _XkbCF_AccessXTimeoutCtrlsOn; + + if (field->field_id==_XkbCF_AccessXTimeoutCtrlsOff) + rtrn->defined|= XkbCF_AccessXTimeoutCtrlsOff; + else if (field->field_id==_XkbCF_AccessXTimeoutCtrlsOn) + rtrn->defined|= XkbCF_AccessXTimeoutCtrlsOn; + + opts= NULL; + if (tok==XkbCF_MinusEquals) { + ctrls= &rtrn->axt_ctrls_ignore; + opts= &rtrn->axt_opts_ignore; + } + else if ((tok==XkbCF_PlusEquals)||(tok==XkbCF_Equals)) { + if (field->field_id==_XkbCF_AccessXTimeoutCtrlsOff) { + ctrls= &rtrn->axt_ctrls_off; + opts= &rtrn->axt_opts_off; + if (tok==XkbCF_Equals) + rtrn->replace_axt_ctrls_off= True; + } + else { + ctrls= &rtrn->axt_ctrls_on; + opts= &rtrn->axt_opts_on; + if (tok==XkbCF_Equals) + rtrn->replace_axt_ctrls_on= True; + } + *ctrls= 0; + } + else { + rtrn->error= XkbCF_MissingEquals; + goto BAILOUT; + } + tok= XkbCFScan(file,&val,rtrn); + if ((tok==XkbCF_EOL)||(tok==XkbCF_Semi)||(tok==XkbCF_EOF)) { + rtrn->error= XkbCF_ExpectedControl; + return False; + } + while ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) { + if ((tok!=XkbCF_Ident)&&(tok!=XkbCF_String)) { + rtrn->error= XkbCF_ExpectedControl; + return False; + } + if (!AddCtrlByName(rtrn,val.str,ctrls)) { + if (!AddAXTimeoutOptByName(rtrn,val.str,opts)) + return False; + if (field->field_id==_XkbCF_AccessXTimeoutCtrlsOff) { + rtrn->defined|= XkbCF_AccessXTimeoutOptsOff; + if (rtrn->replace_axt_ctrls_off) + rtrn->replace_axt_opts_off= True; + } + else { + rtrn->defined|= XkbCF_AccessXTimeoutOptsOn; + if (rtrn->replace_axt_ctrls_on) + rtrn->replace_axt_opts_on= True; + } + } + tok= XkbCFScan(file,&val,rtrn); + if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_EOF)&&(tok!=XkbCF_Semi)) { + if (tok!=XkbCF_Plus) { + rtrn->error= XkbCF_ExpectedOperator; + return False; + } + tok= XkbCFScan(file,&val,rtrn); + } + } + break; + case _XkbCF_ClickVolume: + if (!pival) { + pival= &rtrn->click_volume; + onoff= 100; + } + case _XkbCF_BellVolume: + if (!pival) { + pival= &rtrn->bell_volume; + onoff= 100; + } + case _XkbCF_BellPitch: + if (!pival) + pival= &rtrn->bell_pitch; + case _XkbCF_BellDuration: + if (!pival) + pival= &rtrn->bell_duration; + case _XkbCF_RepeatDelay: + if (!pival) + pival= &rtrn->repeat_delay; + case _XkbCF_RepeatInterval: + if (!pival) + pival= &rtrn->repeat_interval; + case _XkbCF_SlowKeysDelay: + if (!pival) + pival= &rtrn->slow_keys_delay; + case _XkbCF_DebounceDelay: + if (!pival) + pival= &rtrn->debounce_delay; + case _XkbCF_MouseKeysDelay: + if (!pival) + pival= &rtrn->mk_delay; + case _XkbCF_MouseKeysInterval: + if (!pival) + pival= &rtrn->mk_interval; + case _XkbCF_MouseKeysTimeToMax: + if (!pival) + pival= &rtrn->mk_time_to_max; + case _XkbCF_MouseKeysMaxSpeed: + if (!pival) + pival= &rtrn->mk_max_speed; + case _XkbCF_MouseKeysCurve: + if (!pival) + pival= &rtrn->mk_curve; + case _XkbCF_AccessXTimeout: + if (!pival) + pival= &rtrn->ax_timeout; + if (tok!=XkbCF_Equals) { + rtrn->error= XkbCF_MissingEquals; + goto BAILOUT; + } + tok= XkbCFScan(file,&val,rtrn); + if (tok!=XkbCF_Integer) { + Bool ok= False; + if ((onoff)&&(tok==XkbCF_Ident)&&(val.str!=NULL)) { + if (_XkbStrCaseCmp(val.str,"on")) { + val.ival= onoff; + ok= True; + } + else if (_XkbStrCaseCmp(val.str,"off")) { + val.ival= 0; + ok= True; + } + } + if (!ok) { + rtrn->error= XkbCF_ExpectedInteger; + goto BAILOUT; + } + } + *pival= val.ival; + rtrn->defined|= XkbCF_AccessXTimeout; + tok= XkbCFScan(file,&val,rtrn); + if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) { + rtrn->error= XkbCF_ExpectedEOS; + return False; + } + break; + case _XkbCF_GroupsWrap: + if (tok!=XkbCF_Equals) { + rtrn->error= XkbCF_MissingEquals; + goto BAILOUT; + } + tok= XkbCFScan(file,&val,rtrn); + if (tok==XkbCF_Ident) { + if (_XkbStrCaseCmp(val.str,"wrap")==0) { + rtrn->groups_wrap= XkbSetGroupInfo(0,XkbWrapIntoRange,0); + } + else if (_XkbStrCaseCmp(val.str,"clamp")==0) { + rtrn->groups_wrap= XkbSetGroupInfo(0,XkbClampIntoRange,0); + } + else { + rtrn->error= XkbCF_ExpectedOORGroupBehavior; + return False; + } + } + else if ((tok==XkbCF_Integer)&&(XkbIsLegalGroup(val.ival-1))) { + rtrn->groups_wrap= XkbSetGroupInfo(0,XkbRedirectIntoRange, + val.ival-1); + } + else { + rtrn->error= XkbCF_ExpectedOORGroupBehavior; + return False; + } + rtrn->defined|= XkbCF_GroupsWrap; + tok= XkbCFScan(file,&val,rtrn); + if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) { + rtrn->error= XkbCF_ExpectedEOS; + return False; + } + break; + default: + rtrn->error= XkbCF_ExpectedInteger; + goto BAILOUT; + + } + return True; +BAILOUT: + return False; +} + +static Bool +#if NeedFunctionPrototypes +DefaultCleanUp(XkbConfigRtrnPtr rtrn) +#else +DefaultCleanUp(rtrn) + XkbConfigRtrnPtr rtrn; +#endif +{ + if (rtrn->keymap) _XkbFree(rtrn->keymap); + if (rtrn->keycodes) _XkbFree(rtrn->keycodes); + if (rtrn->geometry) _XkbFree(rtrn->geometry); + if (rtrn->phys_symbols) _XkbFree(rtrn->phys_symbols); + if (rtrn->symbols) _XkbFree(rtrn->symbols); + if (rtrn->types) _XkbFree(rtrn->types); + if (rtrn->compat) _XkbFree(rtrn->compat); + rtrn->keycodes= rtrn->geometry= NULL; + rtrn->symbols= rtrn->phys_symbols= NULL; + rtrn->types= rtrn->compat= NULL; + if ((rtrn->unbound_mods!=NULL)&&(rtrn->num_unbound_mods>0)) { + register int i; + for (i=0;inum_unbound_mods;i++) { + if (rtrn->unbound_mods[i].name!=NULL) { + _XkbFree(rtrn->unbound_mods[i].name); + rtrn->unbound_mods[i].name= NULL; + } + } + _XkbFree(rtrn->unbound_mods); + rtrn->sz_unbound_mods= 0; + rtrn->num_unbound_mods= 0; + rtrn->unbound_mods= NULL; + } + return True; +} + +static Bool +#if NeedFunctionPrototypes +DefaultApplyNames(XkbConfigRtrnPtr rtrn,XkbDescPtr xkb) +#else +DefaultApplyNames(rtrn,xkb) + XkbConfigRtrnPtr rtrn; + XkbDescPtr xkb; +#endif +{ +char *str; + + if (XkbAllocNames(xkb,XkbComponentNamesMask,0,0)!=Success) + return False; + if ((str=rtrn->keycodes)!=NULL) { + xkb->names->keycodes= XkbInternAtom(xkb->dpy,str,False); + _XkbFree(str); + rtrn->keycodes= NULL; + } + if ((str=rtrn->geometry)!=NULL) { + xkb->names->geometry= XkbInternAtom(xkb->dpy,str,False); + _XkbFree(str); + rtrn->geometry= NULL; + } + if ((str=rtrn->symbols)!=NULL) { + xkb->names->symbols= XkbInternAtom(xkb->dpy,str,False); + _XkbFree(str); + rtrn->symbols= NULL; + } + if ((str=rtrn->phys_symbols)!=NULL) { + xkb->names->phys_symbols= XkbInternAtom(xkb->dpy,str,False); + _XkbFree(str); + rtrn->phys_symbols= NULL; + } + if ((str=rtrn->types)!=NULL) { + xkb->names->types= XkbInternAtom(xkb->dpy,str,False); + _XkbFree(str); + rtrn->types= NULL; + } + if ((str=rtrn->compat)!=NULL) { + xkb->names->compat= XkbInternAtom(xkb->dpy,str,False); + _XkbFree(str); + rtrn->compat= NULL; + } + return True; +} + +static Bool +#if NeedFunctionPrototypes +DefaultApplyControls(XkbConfigRtrnPtr rtrn,XkbDescPtr xkb) +#else +DefaultApplyControls(rtrn,xkb) + XkbConfigRtrnPtr rtrn; + XkbDescPtr xkb; +#endif +{ +unsigned on,off; +XkbControlsPtr ctrls; +unsigned int mask; + + if (XkbAllocControls(xkb,XkbAllControlsMask)!=Success) + return False; + ctrls= xkb->ctrls; + if (rtrn->replace_initial_ctrls) + ctrls->enabled_ctrls= rtrn->initial_ctrls; + else ctrls->enabled_ctrls|= rtrn->initial_ctrls; + ctrls->enabled_ctrls&= ~rtrn->initial_ctrls_clear; + if (rtrn->internal_mods.replace) { + ctrls->internal.real_mods= rtrn->internal_mods.mods; + ctrls->internal.vmods= rtrn->internal_mods.vmods; + } + else { + ctrls->internal.real_mods&= ~rtrn->internal_mods.mods_clear; + ctrls->internal.vmods&= ~rtrn->internal_mods.vmods_clear; + ctrls->internal.real_mods|= rtrn->internal_mods.mods; + ctrls->internal.vmods|= rtrn->internal_mods.vmods; + } + mask= 0; + (void)XkbVirtualModsToReal(xkb,ctrls->internal.vmods,&mask); + ctrls->internal.mask= (ctrls->internal.real_mods|mask); + + if (rtrn->ignore_lock_mods.replace) { + ctrls->ignore_lock.real_mods= rtrn->ignore_lock_mods.mods; + ctrls->ignore_lock.vmods= rtrn->ignore_lock_mods.vmods; + } + else { + ctrls->ignore_lock.real_mods&= ~rtrn->ignore_lock_mods.mods_clear; + ctrls->ignore_lock.vmods&= ~rtrn->ignore_lock_mods.vmods_clear; + ctrls->ignore_lock.real_mods|= rtrn->ignore_lock_mods.mods; + ctrls->ignore_lock.vmods|= rtrn->ignore_lock_mods.vmods; + } + mask= 0; + (void)XkbVirtualModsToReal(xkb,ctrls->ignore_lock.vmods,&mask); + ctrls->ignore_lock.mask= (ctrls->ignore_lock.real_mods|mask); + + if (rtrn->repeat_delay>0) + ctrls->repeat_delay= rtrn->repeat_delay; + if (rtrn->repeat_interval>0) + ctrls->repeat_interval= rtrn->repeat_interval; + if (rtrn->slow_keys_delay>0) + ctrls->slow_keys_delay= rtrn->slow_keys_delay; + if (rtrn->debounce_delay>0) + ctrls->debounce_delay= rtrn->debounce_delay; + if (rtrn->mk_delay>0) + ctrls->mk_delay= rtrn->mk_delay; + if (rtrn->mk_interval>0) + ctrls->mk_interval= rtrn->mk_interval; + if (rtrn->mk_time_to_max>0) + ctrls->mk_time_to_max= rtrn->mk_time_to_max; + if (rtrn->mk_max_speed>0) + ctrls->mk_max_speed= rtrn->mk_max_speed; + if (rtrn->mk_curve>0) + ctrls->mk_curve= rtrn->mk_curve; + if (rtrn->defined&XkbCF_AccessXTimeout) + ctrls->ax_timeout= rtrn->ax_timeout; + + /* any value set to both off and on is reset to ignore */ + if ((off=(rtrn->axt_ctrls_on&rtrn->axt_ctrls_off))!=0) + rtrn->axt_ctrls_ignore|= off; + + /* ignore takes priority over on and off */ + rtrn->axt_ctrls_on&= ~rtrn->axt_ctrls_ignore; + rtrn->axt_ctrls_off&= ~rtrn->axt_ctrls_ignore; + + if (!rtrn->replace_axt_ctrls_off) { + off= (ctrls->axt_ctrls_mask&(~ctrls->axt_ctrls_values)); + off&= ~rtrn->axt_ctrls_on; + off|= rtrn->axt_ctrls_off; + } + else off= rtrn->axt_ctrls_off; + if (!rtrn->replace_axt_ctrls_on) { + on= (ctrls->axt_ctrls_mask&ctrls->axt_ctrls_values); + on&= ~rtrn->axt_ctrls_off; + on|= rtrn->axt_ctrls_on; + } + else on= rtrn->axt_ctrls_on; + ctrls->axt_ctrls_mask= (on|off)&~rtrn->axt_ctrls_ignore; + ctrls->axt_ctrls_values= on&~rtrn->axt_ctrls_ignore; + + /* any value set to both off and on is reset to ignore */ + if ((off=(rtrn->axt_opts_on&rtrn->axt_opts_off))!=0) + rtrn->axt_opts_ignore|= off; + + /* ignore takes priority over on and off */ + rtrn->axt_opts_on&= ~rtrn->axt_opts_ignore; + rtrn->axt_opts_off&= ~rtrn->axt_opts_ignore; + + if (rtrn->replace_axt_opts_off) { + off= (ctrls->axt_opts_mask&(~ctrls->axt_opts_values)); + off&= ~rtrn->axt_opts_on; + off|= rtrn->axt_opts_off; + } + else off= rtrn->axt_opts_off; + if (!rtrn->replace_axt_opts_on) { + on= (ctrls->axt_opts_mask&ctrls->axt_opts_values); + on&= ~rtrn->axt_opts_off; + on|= rtrn->axt_opts_on; + } + else on= rtrn->axt_opts_on; + ctrls->axt_opts_mask= (unsigned short)((on|off)&~rtrn->axt_ctrls_ignore); + ctrls->axt_opts_values= (unsigned short)(on&~rtrn->axt_ctrls_ignore); + + if (rtrn->defined&XkbCF_GroupsWrap) { + int n; + n= XkbNumGroups(ctrls->groups_wrap); + rtrn->groups_wrap= XkbSetNumGroups(rtrn->groups_wrap,n); + ctrls->groups_wrap= rtrn->groups_wrap; + } + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +DefaultFinish( XkbConfigFieldsPtr fields, + XkbDescPtr xkb, + XkbConfigRtrnPtr rtrn, + int what) +#else +DefaultFinish(fields,xkb,rtrn,what) + XkbConfigFieldsPtr fields; + XkbDescPtr xkb; + XkbConfigRtrnPtr rtrn; + int what; +#endif +{ + if ((what==XkbCF_Destroy)||(what==XkbCF_CleanUp)) + return DefaultCleanUp(rtrn); + if (what==XkbCF_Check) { + if ((rtrn->symbols==NULL)&&(rtrn->phys_symbols!=NULL)) + rtrn->symbols= _XkbDupString(rtrn->phys_symbols); + } + if ((what==XkbCF_Apply)||(what==XkbCF_Check)) { + if (xkb && xkb->names && (rtrn->num_unbound_mods>0)) + XkbCFBindMods(rtrn,xkb); + XkbCFApplyMods(rtrn,XkbCF_InitialMods,&rtrn->initial_mods); + XkbCFApplyMods(rtrn,XkbCF_InternalMods,&rtrn->internal_mods); + XkbCFApplyMods(rtrn,XkbCF_IgnoreLockMods,&rtrn->ignore_lock_mods); + } + if (what==XkbCF_Apply) { + if (xkb!=NULL) { + DefaultApplyNames(rtrn,xkb); + DefaultApplyControls(rtrn,xkb); + XkbCFBindMods(rtrn,xkb); + } + } + return True; +} + +static XkbConfigFieldRec _XkbCFDfltFields[] = { + { "rules", _XkbCF_RulesFile }, + { "model", _XkbCF_Model }, + { "layout", _XkbCF_Layout }, + { "variant", _XkbCF_Variant }, + { "options", _XkbCF_Options }, + { "keymap", _XkbCF_Keymap }, + { "keycodes", _XkbCF_Keycodes }, + { "geometry", _XkbCF_Geometry }, + { "realsymbols",_XkbCF_PhysSymbols }, + { "actualsymbols",_XkbCF_PhysSymbols }, + { "symbols", _XkbCF_Symbols }, + { "symbolstouse",_XkbCF_Symbols }, + { "types", _XkbCF_Types }, + { "compat", _XkbCF_CompatMap }, + { "modifiers", _XkbCF_InitialMods }, + { "controls", _XkbCF_InitialCtrls }, + { "click", _XkbCF_ClickVolume }, + { "clickvolume",_XkbCF_ClickVolume }, + { "bell", _XkbCF_BellVolume }, + { "bellvolume", _XkbCF_BellVolume }, + { "bellpitch", _XkbCF_BellPitch }, + { "bellduration",_XkbCF_BellDuration }, + { "repeatdelay",_XkbCF_RepeatDelay }, + { "repeatinterval",_XkbCF_RepeatInterval }, + { "slowkeysdelay",_XkbCF_SlowKeysDelay }, + { "debouncedelay",_XkbCF_DebounceDelay }, + { "mousekeysdelay",_XkbCF_MouseKeysDelay }, + { "mousekeysinterval",_XkbCF_MouseKeysInterval }, + { "mousekeystimetomax",_XkbCF_MouseKeysTimeToMax }, + { "mousekeysmaxspeed",_XkbCF_MouseKeysMaxSpeed }, + { "mousekeyscurve",_XkbCF_MouseKeysCurve }, + { "accessxtimeout",_XkbCF_AccessXTimeout }, + { "axtimeout",_XkbCF_AccessXTimeout }, + { "accessxtimeoutctrlson",_XkbCF_AccessXTimeoutCtrlsOn }, + { "axtctrlson", _XkbCF_AccessXTimeoutCtrlsOn }, + { "accessxtimeoutctrlsoff",_XkbCF_AccessXTimeoutCtrlsOff }, + { "axtctrlsoff",_XkbCF_AccessXTimeoutCtrlsOff }, + { "ignorelockmods",_XkbCF_IgnoreLockMods }, + { "ignorelockmodifiers",_XkbCF_IgnoreLockMods }, + { "ignoregrouplock",_XkbCF_IgnoreGroupLock }, + { "internalmods",_XkbCF_InternalMods }, + { "internalmodifiers",_XkbCF_InternalMods }, + { "outofrangegroups",_XkbCF_GroupsWrap }, + { "groups", _XkbCF_GroupsWrap } +}; +#define _XkbCFNumDfltFields (sizeof(_XkbCFDfltFields)/sizeof(XkbConfigFieldRec)) + +static XkbConfigFieldsRec _XkbCFDflts = { + 0, /* cfg_id */ + _XkbCFNumDfltFields, /* num_fields */ + _XkbCFDfltFields, /* fields */ + DefaultParser, /* parser */ + DefaultFinish, /* finish */ + NULL, /* priv */ + NULL /* next */ +}; + +XkbConfigFieldsPtr XkbCFDflts= &_XkbCFDflts; + +/***====================================================================***/ + +XkbConfigFieldsPtr +#if NeedFunctionPrototypes +XkbCFDup(XkbConfigFieldsPtr fields) +#else +XkbCFDup(fields) + XkbConfigFieldsPtr fields; +#endif +{ +XkbConfigFieldsPtr pNew; + + pNew= _XkbTypedAlloc(XkbConfigFieldsRec); + if (pNew!=NULL) { + memcpy(pNew,fields,sizeof(XkbConfigFieldsRec)); + if ((pNew->fields!=NULL)&&(pNew->num_fields>0)) { + pNew->fields= _XkbTypedCalloc(pNew->num_fields,XkbConfigFieldRec); + if (pNew->fields) { + memcpy(fields->fields,pNew->fields, + (pNew->num_fields*sizeof(XkbConfigFieldRec))); + } + else { + _XkbFree(pNew); + return NULL; + } + } + else { + pNew->num_fields= 0; + pNew->fields= NULL; + } + pNew->next= NULL; + } + return pNew; +} + +XkbConfigFieldsPtr +#if NeedFunctionPrototypes +XkbCFFree(XkbConfigFieldsPtr fields,Bool all) +#else +XkbCFFree(fields,all) + XkbConfigFieldsPtr fields; + Bool all; +#endif +{ +XkbConfigFieldsPtr next; + + next= NULL; + while (fields!=NULL) { + next= fields->next; + if (fields!=XkbCFDflts) { + if (fields->fields) { + _XkbFree(fields->fields); + fields->fields= NULL; + fields->num_fields= 0; + } + _XkbFree(fields); + } + fields= (all?next:NULL); + } + return next; +} + +Bool +#if NeedFunctionPrototypes +XkbCFApplyRtrnValues( XkbConfigRtrnPtr rtrn, + XkbConfigFieldsPtr fields, + XkbDescPtr xkb) +#else +XkbCFApplyRtrnValues(rtrn,fields,xkb) + XkbConfigRtrnPtr rtrn; + XkbConfigFieldsPtr fields; + XkbDescPtr xkb; +#endif +{ +Bool ok; + + if ((fields==NULL)||(rtrn==NULL)||(xkb==NULL)) + return False; + for (ok=True;fields!=NULL;fields=fields->next) { + if (fields->finish!=NULL) + ok= (*fields->finish)(fields,xkb,rtrn,XkbCF_Apply)&&ok; + } + return ok; +} + +XkbConfigRtrnPrivPtr +#if NeedFunctionPrototypes +XkbCFAddPrivate( XkbConfigRtrnPtr rtrn, + XkbConfigFieldsPtr fields, + XPointer ptr) +#else +XkbCFAddPrivate(rtrn,fields,ptr) + XkbConfigRtrnPtr rtrn; + XkbConfigFieldsPtr fields; + XPointer ptr; +#endif +{ +XkbConfigRtrnPrivPtr priv; + + if ((rtrn==NULL)||(fields==NULL)) + return NULL; + priv= _XkbTypedAlloc(XkbConfigRtrnPrivRec); + if (priv!=NULL) { + priv->cfg_id= fields->cfg_id; + priv->priv= ptr; + priv->next= rtrn->priv; + rtrn->priv= priv; + } + return priv; +} + +void +#if NeedFunctionPrototypes +XkbCFFreeRtrn( XkbConfigRtrnPtr rtrn, + XkbConfigFieldsPtr fields, + XkbDescPtr xkb) +#else +XkbCFFreeRtrn(rtrn,fields,xkb) + XkbConfigRtrnPtr rtrn; + XkbConfigFieldsPtr fields; + XkbDescPtr xkb; +#endif +{ +XkbConfigRtrnPrivPtr tmp,next; + + if ((fields==NULL)||(rtrn==NULL)) + return; + while (fields!=NULL) { + if (fields->finish!=NULL) + (*fields->finish)(fields,xkb,rtrn,XkbCF_Destroy); + fields= fields->next; + } + for (tmp=rtrn->priv;tmp!=NULL;tmp=next) { + next= tmp->next; + bzero((char *)tmp,sizeof(XkbConfigRtrnPrivRec)); + _XkbFree(tmp); + } + bzero((char *)rtrn,sizeof(XkbConfigRtrnRec)); + return; +} + +Bool +#if NeedFunctionPrototypes +XkbCFParse( FILE * file, + XkbConfigFieldsPtr fields, + XkbDescPtr xkb, + XkbConfigRtrnPtr rtrn) +#else +XkbCFParse(file,fields,xkb,rtrn) + FILE * file; + XkbConfigFieldsPtr fields; + XkbDescPtr xkb; + XkbConfigRtrnPtr rtrn; +#endif +{ +int tok; +XkbCFScanResultRec val; +XkbConfigFieldsPtr tmp; + + if ((file==NULL)||(fields==NULL)||(rtrn==NULL)) + return False; + for (tok=0,tmp=fields;tmp!=NULL;tmp=tmp->next,tok++) { + fields->cfg_id= tok; + } + bzero((char *)rtrn,sizeof(XkbConfigRtrnRec)); + rtrn->line= 1; + rtrn->click_volume= -1; + rtrn->bell_volume= -1; + while ((tok=XkbCFScan(file,&val,rtrn))!=XkbCF_EOF) { + if (tok==XkbCF_Ident) { + Bool done; + for (tmp=fields,done=False;(tmp!=NULL)&&(!done);tmp=tmp->next) { + register int i; + XkbConfigFieldPtr f; + + for (i=0,f=tmp->fields;(inum_fields)&&(!done);i++,f++) { + if (_XkbStrCaseCmp(val.str,f->field)!=0) + continue; + if ((*tmp->parser)(file,tmp,f,xkb,rtrn)) + done= True; + else goto BAILOUT; + } + } + } + else if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)) { + rtrn->error= XkbCF_MissingIdent; + goto BAILOUT; + } + } + for (tmp=fields;tmp!=NULL;tmp=tmp->next) { + if ((tmp->finish)&&(!(*tmp->finish)(tmp,xkb,rtrn,XkbCF_Check))) + goto BAILOUT; + } + return True; +BAILOUT: + for (tmp=fields;tmp!=NULL;tmp=tmp->next) { + if (tmp->finish) + (*tmp->finish)(tmp,xkb,rtrn,XkbCF_CleanUp); + } + return False; +} + +void +#if NeedFunctionPrototypes +XkbCFReportError(FILE *file,char *name,int error,int line) +#else +XkbCFReportError(file,name,error,line) + FILE * file; + char * name; + int error; + int line; +#endif +{ +char * msg; + + switch(error) { + case XkbCF_BadAlloc: + msg= "allocation failed\n"; break; + case XkbCF_UnterminatedString: + msg= "unterminated string on line %d"; break; + case XkbCF_MissingIdent: + msg= "expected identifier on line %d"; break; + case XkbCF_MissingEquals: + msg= "expected '=' on line %d"; break; + case XkbCF_ExpectedEOS: + msg= "expected ';' or newline on line %d"; break; + case XkbCF_ExpectedBoolean: + msg= "expected a boolean value on line %d"; break; + case XkbCF_ExpectedInteger: + msg= "expected a numeric value on line %d"; break; + case XkbCF_ExpectedString: + msg= "expected a string on line %d"; break; + case XkbCF_ExpectedModifier: + msg= "expected a modifier name on line %d"; break; + case XkbCF_ExpectedControl: + msg= "expected a control name on line %d"; break; + case XkbCF_ExpectedAXOption: + msg= "expected an AccessX option on line %d"; break; + case XkbCF_ExpectedOperator: + msg= "expected '+' or '-' on line %d"; break; + case XkbCF_ExpectedOORGroupBehavior: + msg= "expected wrap, clamp or group number on line %d"; break; + default: + msg= "unknown error on line %d"; break; + } + fprintf(file,msg,line); + if (name) fprintf(file," of %s\n",name); + else fprintf(file,"\n"); + return; +} diff --git a/src/xkbdraw.c b/src/xkbdraw.c new file mode 100644 index 0000000..fffc832 --- /dev/null +++ b/src/xkbdraw.c @@ -0,0 +1,151 @@ +/* $Xorg: xkbdraw.c,v 1.3 2000/08/17 19:46:43 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1995 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif + +#include +#include +#include +#include +#include +#include +#include "XKMformat.h" +#include "XKBfileInt.h" + +static void +#if NeedFunctionPrototypes +_XkbAddDrawable(XkbDrawablePtr *pfirst,XkbDrawablePtr *plast,XkbDrawablePtr tmp) +#else +_XkbAddDrawable(pfirst,plast,tmp) + XkbDrawablePtr * pfirst; + XkbDrawablePtr * plast; + XkbDrawablePtr tmp; +#endif +{ +XkbDrawablePtr old; + + if (*pfirst==NULL) { + *pfirst= *plast= tmp; + } + else if (tmp->priority>=(*plast)->priority) { + (*plast)->next= tmp; + *plast= tmp; + } + else if (tmp->priority<(*pfirst)->priority) { + tmp->next= (*pfirst); + (*pfirst)= tmp; + } + else { + old= *pfirst; + while ((old->next)&&(old->next->priority<=tmp->priority)) { + old= old->next; + } + tmp->next= old->next; + old->next= tmp; + } + return; +} + +XkbDrawablePtr +#if NeedFunctionPrototypes +XkbGetOrderedDrawables(XkbGeometryPtr geom,XkbSectionPtr section) +#else +XkbGetOrderedDrawables(geom,section) + XkbGeometryPtr geom; + XkbSectionPtr section; +#endif +{ +XkbDrawablePtr first,last,tmp; +int i; + + first= last= NULL; + if (geom!=NULL) { + XkbSectionPtr section; + XkbDoodadPtr doodad; + for (i=0,section=geom->sections;inum_sections;i++,section++) { + tmp= _XkbTypedCalloc(1,XkbDrawableRec); + if (!tmp) { + XkbFreeOrderedDrawables(first); + return NULL; + } + tmp->type= XkbDW_Section; + tmp->priority= section->priority; + tmp->u.section= section; + tmp->next= NULL; + _XkbAddDrawable(&first,&last,tmp); + } + for (i=0,doodad=geom->doodads;inum_doodads;i++,doodad++) { + tmp= _XkbTypedCalloc(1,XkbDrawableRec); + if (!tmp) { + XkbFreeOrderedDrawables(first); + return NULL; + } + tmp->type= XkbDW_Doodad; + tmp->priority= doodad->any.priority; + tmp->u.doodad= doodad; + tmp->next= NULL; + _XkbAddDrawable(&first,&last,tmp); + } + } + if (section!=NULL) { + XkbDoodadPtr doodad; + for (i=0,doodad=section->doodads;inum_doodads;i++,doodad++) { + tmp= _XkbTypedCalloc(1,XkbDrawableRec); + if (!tmp) { + XkbFreeOrderedDrawables(first); + return NULL; + } + tmp->type= XkbDW_Doodad; + tmp->priority= doodad->any.priority; + tmp->u.doodad= doodad; + tmp->next= NULL; + _XkbAddDrawable(&first,&last,tmp); + } + } + return first; +} + +void +#if NeedFunctionPrototypes +XkbFreeOrderedDrawables(XkbDrawablePtr draw) +#else +XkbFreeOrderedDrawables(draw) + XkbDrawablePtr draw; +#endif +{ +XkbDrawablePtr tmp; + + for (;draw!=NULL;draw=tmp) { + tmp= draw->next; + _XkbFree(draw); + } + return; +} diff --git a/src/xkberrs.c b/src/xkberrs.c new file mode 100644 index 0000000..41df420 --- /dev/null +++ b/src/xkberrs.c @@ -0,0 +1,70 @@ +/* $Xorg: xkberrs.c,v 1.3 2000/08/17 19:46:44 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif +#include +#include +#include + +char * _XkbErrMessages[] = { + "success", /* _XkbSuccess */ + "key names not defined", /* _XkbErrMissingNames */ + "key types not defined", /* _XkbErrMissingTypes */ + "required key types not present", /* _XkbErrMissingReqTypes */ + "symbols not defined", /* _XkbErrMissingSymbols */ + "virtual modifier bindings not defined",/* _XkbErrMissingVMods */ + "indicators not defined", /* _XkbErrMissingIndicators */ + "compatibility map not defined", /* _XkbErrMissingCompatMap */ + "symbol interpretations not defined", /* _XkbErrMissingSymInterps */ + "geometry not defined", /* _XkbErrMissingGeometry */ + "illegal doodad type", /* _XkbErrIllegalDoodad */ + "illegal TOC type", /* _XkbErrIllegalTOCType */ + "illegal contents", /* _XkbErrIllegalContents */ + "empty file", /* _XkbErrEmptyFile */ + "file not found", /* _XkbErrFileNotFound */ + "cannot open", /* _XkbErrFileCannotOpen */ + "bad value", /* _XkbErrBadValue */ + "bad match", /* _XkbErrBadMatch */ + "illegal name for type", /* _XkbErrBadTypeName */ + "illegal width for type", /* _XkbErrBadTypeWidth */ + "bad file type", /* _XkbErrBadFileType */ + "bad file version", /* _XkbErrBadFileVersion */ + "error in Xkm file", /* _XkbErrBadFileFormat */ + "allocation failed", /* _XkbErrBadAlloc */ + "bad length", /* _XkbErrBadLength */ + "X request failed", /* _XkbErrXReqFailure */ + "not implemented" /* _XkbErrBadImplementation */ +}; + +unsigned _XkbErrCode; +char * _XkbErrLocation= NULL; +unsigned _XkbErrData; + diff --git a/src/xkbmisc.c b/src/xkbmisc.c new file mode 100644 index 0000000..d07a704 --- /dev/null +++ b/src/xkbmisc.c @@ -0,0 +1,716 @@ +/* $Xorg: xkbmisc.c,v 1.4 2000/08/17 19:46:44 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1995 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif + +#define XK_CYRILLIC + +#include +#include + +#ifndef XKB_IN_SERVER + +#include +#include +#include +#include +#include "XKMformat.h" +#include "XKBfileInt.h" + +#else + +#include "X.h" +#define NEED_EVENTS +#include +#include "Xproto.h" +#include "misc.h" +#include "inputstr.h" +#include "dix.h" +#include "XKBstr.h" +#define XKBSRV_NEED_FILE_FUNCS 1 +#include "XKBsrv.h" +#include + +#endif + +unsigned +#if NeedFunctionPrototypes +_XkbKSCheckCase(KeySym ks) +#else +_XkbKSCheckCase(ks) + KeySym ks; +#endif +{ +unsigned set,rtrn; +unsigned char ch; + + set= (ks & (~0xff)); + ch= (char)(ks&0xff); + rtrn= 0; + switch (set) { + case 0: /* latin 1 */ + if (((ch>=XK_A)&&(ch<=XK_Z))|| + ((ch>=XK_Agrave)&&(ch<=XK_THORN)&&(ch!=XK_multiply))) { + rtrn|= _XkbKSUpper; + } + if (((ch>=XK_a)&&(ch<=XK_z))|| + ((ch>=XK_agrave)&&(ch<=XK_ydiaeresis))) { + rtrn|= _XkbKSLower; + } + break; + } + return rtrn; +} + +/***===================================================================***/ + +int +#if NeedFunctionPrototypes +_XkbStrCaseCmp(char *str1,char *str2) +#else +_XkbStrCaseCmp(str1,str2) + char * str1; + char * str2; +#endif +{ + char buf1[512],buf2[512]; + char c, *s; + register int n; + + for (n=0, s = buf1; (c = *str1++); n++) { + if (isupper(c)) + c = tolower(c); + if (n>510) + break; + *s++ = c; + } + *s = '\0'; + for (n=0, s = buf2; (c = *str2++); n++) { + if (isupper(c)) + c = tolower(c); + if (n>510) + break; + *s++ = c; + } + *s = '\0'; + return (strcmp(buf1, buf2)); +} + +/***===================================================================***/ + +Bool +#if NeedFunctionPrototypes +XkbLookupGroupAndLevel( XkbDescPtr xkb, + int key, + int * mods_inout, + int * grp_inout, + int * lvl_rtrn) +#else +XkbLookupGroupAndLevel(xkb,key,mods_inout,grp_inout,lvl_rtrn) + XkbDescPtr xkb; + int key; + int * mods_inout; + int * grp_inout; + int * lvl_rtrn; +#endif +{ +int nG,eG; + + if ((!xkb)||(!XkbKeycodeInRange(xkb,key))||(!grp_inout)) + return False; + + nG= XkbKeyNumGroups(xkb,key); + eG= *grp_inout; + + if ( nG==0 ) { + *grp_inout= 0; + if (lvl_rtrn!=NULL) + *lvl_rtrn= 0; + return False; + } + else if ( nG==1 ) { + eG= 0; + } + else if ( eG>=nG ) { + unsigned gI= XkbKeyGroupInfo(xkb,key); + switch (XkbOutOfRangeGroupAction(gI)) { + default: + eG %= nG; + break; + case XkbClampIntoRange: + eG = nG-1; + break; + case XkbRedirectIntoRange: + eG = XkbOutOfRangeGroupNumber(gI); + if (eG>=nG) + eG= 0; + break; + } + } + *grp_inout= eG; + if (mods_inout!=NULL) { + XkbKeyTypePtr type; + int preserve; + + type = XkbKeyKeyType(xkb,key,eG); + if (lvl_rtrn!=NULL) + *lvl_rtrn= 0; + preserve= 0; + if (type->map) { /* find the shift level */ + register int i; + register XkbKTMapEntryPtr entry; + for (i=0,entry=type->map;imap_count;i++,entry++) { + if ((entry->active)&& + (((*mods_inout)&type->mods.mask)==entry->mods.mask)){ + if (lvl_rtrn!=NULL) + *lvl_rtrn= entry->level; + if (type->preserve) + preserve= type->preserve[i].mask; + break; + } + } + } + (*mods_inout)&= ~(type->mods.mask&(~preserve)); + } + return True; +} + +/***===================================================================***/ + +static Bool +#if NeedFunctionPrototypes +XkbWriteSectionFromName(FILE *file,char *sectionName,char *name) +#else +XkbWriteSectionFromName(file,sectionName,name) + FILE * file; + char * sectionName; + char * name; +#endif +{ + fprintf(file," xkb_%-20s { include \"%s\" };\n",sectionName,name); + return True; +} + +#define NEED_DESC(n) ((!n)||((n)[0]=='+')||((n)[0]=='|')||(strchr((n),'%'))) +#define COMPLETE(n) ((n)&&(!NEED_DESC(n))) + +/* ARGSUSED */ +static void +#if NeedFunctionPrototypes +_AddIncl( FILE * file, + XkbFileInfo * result, + Bool topLevel, + Bool showImplicit, + int index, + void * priv) +#else +_AddIncl(file,result,topLevel,showImplicit,index,priv) + FILE * file; + XkbFileInfo * result; + Bool topLevel; + Bool showImplicit; + int index; + void * priv; +#endif +{ + if ((priv)&&(strcmp(priv,"%")!=0)) + fprintf(file," include \"%s\"\n",(char *)priv); + return; +} + +Bool +#if NeedFunctionPrototypes +XkbWriteXKBKeymapForNames( FILE * file, + XkbComponentNamesPtr names, + Display * dpy, + XkbDescPtr xkb, + unsigned want, + unsigned need) +#else +XkbWriteXKBKeymapForNames(file,names,dpy,xkb,want,need) + FILE * file; + XkbComponentNamesPtr names; + Display * dpy; + XkbDescPtr xkb; + unsigned want; + unsigned need; +#endif +{ +char * name,*tmp; +unsigned complete; +XkbNamesPtr old_names; +int multi_section; +unsigned wantNames,wantConfig,wantDflts; +XkbFileInfo finfo; + + bzero(&finfo,sizeof(XkbFileInfo)); + + complete= 0; + if ((name=names->keymap)==NULL) name= "default"; + if (COMPLETE(names->keycodes)) complete|= XkmKeyNamesMask; + if (COMPLETE(names->types)) complete|= XkmTypesMask; + if (COMPLETE(names->compat)) complete|= XkmCompatMapMask; + if (COMPLETE(names->symbols)) complete|= XkmSymbolsMask; + if (COMPLETE(names->geometry)) complete|= XkmGeometryMask; + want|= (complete|need); + if (want&XkmSymbolsMask) + want|= XkmKeyNamesMask|XkmTypesMask; + + if (want==0) + return False; + + if (xkb!=NULL) { + old_names= xkb->names; + finfo.type= 0; + finfo.defined= 0; + finfo.xkb= xkb; + if (!XkbDetermineFileType(&finfo,XkbXKBFile,NULL)) + return False; + } + else old_names= NULL; + + wantConfig= want&(~complete); + if (xkb!=NULL) { + if (wantConfig&XkmTypesMask) { + if ((!xkb->map) || (xkb->map->num_typescompat) || (xkb->compat->num_si<1)) + wantConfig&= ~XkmCompatMapMask; + } + if (wantConfig&XkmSymbolsMask) { + if ((!xkb->map) || (!xkb->map->key_sym_map)) + wantConfig&= ~XkmSymbolsMask; + } + if (wantConfig&XkmIndicatorsMask) { + if (!xkb->indicators) + wantConfig&= ~XkmIndicatorsMask; + } + if (wantConfig&XkmKeyNamesMask) { + if ((!xkb->names)||(!xkb->names->keys)) + wantConfig&= ~XkmKeyNamesMask; + } + if ((wantConfig&XkmGeometryMask)&&(!xkb->geom)) + wantConfig&= ~XkmGeometryMask; + } + else { + wantConfig= 0; + } + complete|= wantConfig; + + wantDflts= 0; + wantNames= want&(~complete); + if ((xkb!=NULL) && (old_names!=NULL)) { + if (wantNames&XkmTypesMask) { + if (old_names->types!=None) { + tmp= XkbAtomGetString(dpy,old_names->types); + names->types= _XkbDupString(tmp); + } + else { + wantDflts|= XkmTypesMask; + } + complete|= XkmTypesMask; + } + if (wantNames&XkmCompatMapMask) { + if (old_names->compat!=None) { + tmp= XkbAtomGetString(dpy,old_names->compat); + names->compat= _XkbDupString(tmp); + } + else wantDflts|= XkmCompatMapMask; + complete|= XkmCompatMapMask; + } + if (wantNames&XkmSymbolsMask) { + if (old_names->symbols==None) + return False; + tmp= XkbAtomGetString(dpy,old_names->symbols); + names->symbols= _XkbDupString(tmp); + complete|= XkmSymbolsMask; + } + if (wantNames&XkmKeyNamesMask) { + if (old_names->keycodes!=None) { + tmp= XkbAtomGetString(dpy,old_names->keycodes); + names->keycodes= _XkbDupString(tmp); + } + else wantDflts|= XkmKeyNamesMask; + complete|= XkmKeyNamesMask; + } + if (wantNames&XkmGeometryMask) { + if (old_names->geometry==None) + return False; + tmp= XkbAtomGetString(dpy,old_names->geometry); + names->geometry= _XkbDupString(tmp); + complete|= XkmGeometryMask; + wantNames&= ~XkmGeometryMask; + } + } + if (complete&XkmCompatMapMask) + complete|= XkmIndicatorsMask|XkmVirtualModsMask; + else if (complete&(XkmSymbolsMask|XkmTypesMask)) + complete|= XkmVirtualModsMask; + if (need & (~complete)) + return False; + if ((complete&XkmSymbolsMask)&&((XkmKeyNamesMask|XkmTypesMask)&(~complete))) + return False; + + multi_section= 1; + if (((complete&XkmKeymapRequired)==XkmKeymapRequired)&& + ((complete&(~XkmKeymapLegal))==0)) { + fprintf(file,"xkb_keymap \"%s\" {\n",name); + } + else if (((complete&XkmSemanticsRequired)==XkmSemanticsRequired)&& + ((complete&(~XkmSemanticsLegal))==0)) { + fprintf(file,"xkb_semantics \"%s\" {\n",name); + } + else if (((complete&XkmLayoutRequired)==XkmLayoutRequired)&& + ((complete&(~XkmLayoutLegal))==0)) { + fprintf(file,"xkb_layout \"%s\" {\n",name); + } + else if (XkmSingleSection(complete&(~XkmVirtualModsMask))) { + multi_section= 0; + } + else { + return False; + } + + wantNames= complete&(~(wantConfig|wantDflts)); + name= names->keycodes; + if (wantConfig&XkmKeyNamesMask) + XkbWriteXKBKeycodes(file,&finfo,False,False,_AddIncl,name); + else if (wantDflts&XkmKeyNamesMask) + fprintf(stderr,"Default symbols not implemented yet!\n"); + else if (wantNames&XkmKeyNamesMask) + XkbWriteSectionFromName(file,"keycodes",name); + + name= names->types; + if (wantConfig&XkmTypesMask) + XkbWriteXKBKeyTypes(file,&finfo,False,False,_AddIncl,name); + else if (wantDflts&XkmTypesMask) + fprintf(stderr,"Default types not implemented yet!\n"); + else if (wantNames&XkmTypesMask) + XkbWriteSectionFromName(file,"types",name); + + name= names->compat; + if (wantConfig&XkmCompatMapMask) + XkbWriteXKBCompatMap(file,&finfo,False,False,_AddIncl,name); + else if (wantDflts&XkmCompatMapMask) + fprintf(stderr,"Default interps not implemented yet!\n"); + else if (wantNames&XkmCompatMapMask) + XkbWriteSectionFromName(file,"compatibility",name); + + name= names->symbols; + if (wantConfig&XkmSymbolsMask) + XkbWriteXKBSymbols(file,&finfo,False,False,_AddIncl,name); + else if (wantNames&XkmSymbolsMask) + XkbWriteSectionFromName(file,"symbols",name); + + name= names->geometry; + if (wantConfig&XkmGeometryMask) + XkbWriteXKBGeometry(file,&finfo,False,False,_AddIncl,name); + else if (wantNames&XkmGeometryMask) + XkbWriteSectionFromName(file,"geometry",name); + + if (multi_section) + fprintf(file,"};\n"); + return True; +} + +/***====================================================================***/ + +/*ARGSUSED*/ +Status +#if NeedFunctionPrototypes +XkbMergeFile(XkbDescPtr xkb,XkbFileInfo finfo) +#else +XkbMergeFile(xkb,finfo) + XkbDescPtr xkb; + XkbFileInfo *finfo; +#endif +{ + return BadImplementation; +} + +/***====================================================================***/ + +int +#if NeedFunctionPrototypes +XkbFindKeycodeByName(XkbDescPtr xkb,char *name,Bool use_aliases) +#else +XkbFindKeycodeByName(xkb,name,use_aliases) + XkbDescPtr xkb; + char * name; + Bool use_aliases; +#endif +{ +register int i; + + if ((!xkb)||(!xkb->names)||(!xkb->names->keys)) + return 0; + for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) { + if (strncmp(xkb->names->keys[i].name,name,XkbKeyNameLength)==0) + return i; + } + if (!use_aliases) + return 0; + if (xkb->geom && xkb->geom->key_aliases) { + XkbKeyAliasPtr a; + a= xkb->geom->key_aliases; + for (i=0;igeom->num_key_aliases;i++,a++) { + if (strncmp(name,a->alias,XkbKeyNameLength)==0) + return XkbFindKeycodeByName(xkb,a->real,False); + } + } + if (xkb->names && xkb->names->key_aliases) { + XkbKeyAliasPtr a; + a= xkb->names->key_aliases; + for (i=0;inames->num_key_aliases;i++,a++) { + if (strncmp(name,a->alias,XkbKeyNameLength)==0) + return XkbFindKeycodeByName(xkb,a->real,False); + } + } + return 0; +} + + +unsigned +#if NeedFunctionPrototypes +XkbConvertGetByNameComponents(Bool toXkm,unsigned orig) +#else +XkbConvertGetByNameComponents(toXkm,orig) + Bool toXkm; + unsigned orig; +#endif +{ +unsigned rtrn; + + rtrn= 0; + if (toXkm) { + if (orig&XkbGBN_TypesMask) rtrn|= XkmTypesMask; + if (orig&XkbGBN_CompatMapMask) rtrn|= XkmCompatMapMask; + if (orig&XkbGBN_SymbolsMask) rtrn|= XkmSymbolsMask; + if (orig&XkbGBN_IndicatorMapMask) rtrn|= XkmIndicatorsMask; + if (orig&XkbGBN_KeyNamesMask) rtrn|= XkmKeyNamesMask; + if (orig&XkbGBN_GeometryMask) rtrn|= XkmGeometryMask; + } + else { + if (orig&XkmTypesMask) rtrn|= XkbGBN_TypesMask; + if (orig&XkmCompatMapMask) rtrn|= XkbGBN_CompatMapMask; + if (orig&XkmSymbolsMask) rtrn|= XkbGBN_SymbolsMask; + if (orig&XkmIndicatorsMask) rtrn|= XkbGBN_IndicatorMapMask; + if (orig&XkmKeyNamesMask) rtrn|= XkbGBN_KeyNamesMask; + if (orig&XkmGeometryMask) rtrn|= XkbGBN_GeometryMask; + if (orig!=0) rtrn|= XkbGBN_OtherNamesMask; + } + return rtrn; +} + +unsigned +#if NeedFunctionPrototypes +XkbConvertXkbComponents(Bool toXkm,unsigned orig) +#else +XkbConvertXkbComponents(toXkm,orig) + Bool toXkm; + unsigned orig; +#endif +{ +unsigned rtrn; + + rtrn= 0; + if (toXkm) { + if (orig&XkbClientMapMask) rtrn|= XkmTypesMask|XkmSymbolsMask; + if (orig&XkbServerMapMask) rtrn|= XkmTypesMask|XkmSymbolsMask; + if (orig&XkbCompatMapMask) rtrn|= XkmCompatMapMask; + if (orig&XkbIndicatorMapMask) rtrn|= XkmIndicatorsMask; + if (orig&XkbNamesMask) rtrn|= XkmKeyNamesMask; + if (orig&XkbGeometryMask) rtrn|= XkmGeometryMask; + } + else { + if (orig!=0) rtrn|= XkbNamesMask; + if (orig&XkmTypesMask) rtrn|= XkbClientMapMask; + if (orig&XkmCompatMapMask) + rtrn|= XkbCompatMapMask|XkbIndicatorMapMask; + if (orig&XkmSymbolsMask) rtrn|=XkbClientMapMask|XkbServerMapMask; + if (orig&XkmIndicatorsMask) rtrn|= XkbIndicatorMapMask; + if (orig&XkmKeyNamesMask) + rtrn|= XkbNamesMask|XkbIndicatorMapMask; + if (orig&XkmGeometryMask) rtrn|= XkbGeometryMask; + } + return rtrn; +} + +Bool +#if NeedFunctionPrototypes +XkbDetermineFileType(XkbFileInfoPtr finfo,int format,int *opts_missing) +#else +XkbDetermineFileType(finfo,format,opts_missing) + XkbFileInfoPtr finfo; + int format; + int * opts_missing; +#endif +{ +unsigned present; +XkbDescPtr xkb; + + if ((!finfo)||(!finfo->xkb)) + return False; + if (opts_missing) + *opts_missing= 0; + xkb= finfo->xkb; + present= 0; + if ((xkb->names)&&(xkb->names->keys)) present|= XkmKeyNamesMask; + if ((xkb->map)&&(xkb->map->types)) present|= XkmTypesMask; + if (xkb->compat) present|= XkmCompatMapMask; + if ((xkb->map)&&(xkb->map->num_syms>1)) present|= XkmSymbolsMask; + if (xkb->indicators) present|= XkmIndicatorsMask; + if (xkb->geom) present|= XkmGeometryMask; + if (!present) + return False; + else switch (present) { + case XkmKeyNamesMask: + finfo->type= XkmKeyNamesIndex; + finfo->defined= present; + return True; + case XkmTypesMask: + finfo->type= XkmTypesIndex; + finfo->defined= present; + return True; + case XkmCompatMapMask: + finfo->type= XkmCompatMapIndex; + finfo->defined= present; + return True; + case XkmSymbolsMask: + if (format!=XkbXKMFile) { + finfo->type= XkmSymbolsIndex; + finfo->defined= present; + return True; + } + break; + case XkmGeometryMask: + finfo->type= XkmGeometryIndex; + finfo->defined= present; + return True; + } + if ((present&(~XkmSemanticsLegal))==0) { + if ((XkmSemanticsRequired&present)==XkmSemanticsRequired) { + if (opts_missing) + *opts_missing= XkmSemanticsOptional&(~present); + finfo->type= XkmSemanticsFile; + finfo->defined= present; + return True; + } + } + else if ((present&(~XkmLayoutLegal))==0) { + if ((XkmLayoutRequired&present)==XkmLayoutRequired) { + if (opts_missing) + *opts_missing= XkmLayoutOptional&(~present); + finfo->type= XkmLayoutFile; + finfo->defined= present; + return True; + } + } + else if ((present&(~XkmKeymapLegal))==0) { + if ((XkmKeymapRequired&present)==XkmKeymapRequired) { + if (opts_missing) + *opts_missing= XkmKeymapOptional&(~present); + finfo->type= XkmKeymapFile; + finfo->defined= present; + return True; + } + } + return False; +} + +/* all latin-1 alphanumerics, plus parens, slash, minus, underscore and */ +/* wildcards */ + +static unsigned char componentSpecLegal[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x83, + 0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff +}; + +void +#if NeedFunctionPrototypes +XkbEnsureSafeMapName(char *name) +#else +XkbEnsureSafeMapName(name) + char *name; +#endif +{ + if (name==NULL) + return; + while (*name!='\0') { + if ((componentSpecLegal[(*name)/8]&(1<<((*name)%8)))==0) + *name= '_'; + name++; + } + return; +} + +/***====================================================================***/ + +#define UNMATCHABLE(c) (((c)=='(')||((c)==')')||((c)=='/')) + +Bool +#if NeedFunctionPrototypes +XkbNameMatchesPattern(char *name,char *ptrn) +#else +XkbNameMatchesPattern(name,ptrn) + char * name; + char * ptrn; +#endif +{ + while (ptrn[0]!='\0') { + if (name[0]=='\0') { + if (ptrn[0]=='*') { + ptrn++; + continue; + } + return False; + } + if (ptrn[0]=='?') { + if (UNMATCHABLE(name[0])) + return False; + } + else if (ptrn[0]=='*') { + if ((!UNMATCHABLE(name[0]))&&XkbNameMatchesPattern(name+1,ptrn)) + return True; + return XkbNameMatchesPattern(name,ptrn+1); + } + else if (ptrn[0]!=name[0]) + return False; + name++; + ptrn++; + } + /* if we get here, the pattern is exhausted (-:just like me:-) */ + return (name[0]=='\0'); +} diff --git a/src/xkbout.c b/src/xkbout.c new file mode 100644 index 0000000..8453253 --- /dev/null +++ b/src/xkbout.c @@ -0,0 +1,1216 @@ +/* $Xorg: xkbout.c,v 1.3 2000/08/17 19:46:44 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif +#include + +#ifndef XKB_IN_SERVER + +#include +#include +#include + +#include "XKMformat.h" +#include "XKBfileInt.h" + +#else + +#include "X.h" +#define NEED_EVENTS +#include +#include "Xproto.h" +#include "misc.h" +#include "inputstr.h" +#include "dix.h" +#include "XKBstr.h" +#define XKBSRV_NEED_FILE_FUNCS 1 +#include "XKBsrv.h" + +#include +#include "extensions/XKBfile.h" + +#endif + +#define VMOD_HIDE_VALUE 0 +#define VMOD_SHOW_VALUE 1 +#define VMOD_COMMENT_VALUE 2 + +static Bool +#if NeedFunctionPrototypes +WriteXKBVModDecl(FILE *file,Display *dpy,XkbDescPtr xkb,int showValue) +#else +WriteXKBVModDecl(file,dpy,xkb,showValue) + FILE * file; + Display * dpy; + XkbDescPtr xkb; + int showValue; +#endif +{ +register int i,nMods; +Atom * vmodNames; + + if (xkb==NULL) + return False; + if (xkb->names!=NULL) + vmodNames= xkb->names->vmods; + else vmodNames= NULL; + + for (i=nMods=0;iserver)&&(xkb->server->vmods[i]!=XkbNoModifierMask)) { + if (showValue==VMOD_COMMENT_VALUE) { + fprintf(file,"/* = %s */", + XkbModMaskText(xkb->server->vmods[i],XkbXKBFile)); + } + else { + fprintf(file,"= %s", + XkbModMaskText(xkb->server->vmods[i],XkbXKBFile)); + } + } + nMods++; + } + } + if (nMods>0) + fprintf(file,";\n\n"); + return True; +} + +/***====================================================================***/ + +static Bool +#if NeedFunctionPrototypes +WriteXKBAction(FILE *file,XkbFileInfo *result,XkbAnyAction *action) +#else +WriteXKBAction(file,result,action) + FILE * file; + XkbFileInfo * result; + XkbAnyAction * action; +#endif +{ +XkbDescPtr xkb; +Display * dpy; + + xkb= result->xkb; + dpy= xkb->dpy; + fprintf(file,"%s",XkbActionText(dpy,xkb,(XkbAction *)action,XkbXKBFile)); + return True; +} + +/***====================================================================***/ + +Bool +#if NeedFunctionPrototypes +XkbWriteXKBKeycodes( FILE * file, + XkbFileInfo * result, + Bool topLevel, + Bool showImplicit, + XkbFileAddOnFunc addOn, + void * priv) +#else +XkbWriteXKBKeycodes(file,result,topLevel,showImplicit,addOn,priv) + FILE * file; + XkbFileInfo * result; + Bool topLevel; + Bool showImplicit; + XkbFileAddOnFunc addOn; + void * priv; +#endif +{ +Atom kcName; +register unsigned i; +XkbDescPtr xkb; +Display * dpy; +char * alternate; + + xkb= result->xkb; + dpy= xkb->dpy; + if ((!xkb)||(!xkb->names)||(!xkb->names->keys)) { + _XkbLibError(_XkbErrMissingNames,"XkbWriteXKBKeycodes",0); + return False; + } + kcName= xkb->names->keycodes; + if (kcName!=None) + fprintf(file,"xkb_keycodes \"%s\" {\n", + XkbAtomText(dpy,kcName,XkbXKBFile)); + else fprintf(file,"xkb_keycodes {\n"); + fprintf(file," minimum = %d;\n",xkb->min_key_code); + fprintf(file," maximum = %d;\n",xkb->max_key_code); + for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) { + if (xkb->names->keys[i].name[0]!='\0') { + if (XkbFindKeycodeByName(xkb,xkb->names->keys[i].name,True)!=i) + alternate= "alternate "; + else alternate= ""; + fprintf(file," %s%6s = %d;\n",alternate, + XkbKeyNameText(xkb->names->keys[i].name,XkbXKBFile), + i); + } + } + if (xkb->indicators!=NULL) { + for (i=0;iindicators->phys_indicators&(1<names->indicators[i]!=None) { + fprintf(file,"%sindicator %d = \"%s\";\n",type,i+1, + XkbAtomText(dpy,xkb->names->indicators[i],XkbXKBFile)); + } + } + } + if (xkb->names->key_aliases!=NULL) { + XkbKeyAliasPtr pAl; + pAl= xkb->names->key_aliases; + for (i=0;inames->num_key_aliases;i++,pAl++) { + fprintf(file," alias %6s = %6s;\n", + XkbKeyNameText(pAl->alias,XkbXKBFile), + XkbKeyNameText(pAl->real,XkbXKBFile)); + } + } + if (addOn) + (*addOn)(file,result,topLevel,showImplicit,XkmKeyNamesIndex,priv); + fprintf(file,"};\n\n"); + return True; +} + +Bool +#if NeedFunctionPrototypes +XkbWriteXKBKeyTypes( FILE * file, + XkbFileInfo * result, + Bool topLevel, + Bool showImplicit, + XkbFileAddOnFunc addOn, + void * priv) +#else +XkbWriteXKBKeyTypes(file,result,topLevel,showImplicit,addOn,priv) + FILE * file; + XkbFileInfo * result; + Bool topLevel; + Bool showImplicit; + XkbFileAddOnFunc addOn; + void * priv; +#endif +{ +Display * dpy; +register unsigned i,n; +XkbKeyTypePtr type; +XkbKTMapEntryPtr entry; +XkbDescPtr xkb; + + xkb= result->xkb; + dpy= xkb->dpy; + if ((!xkb)||(!xkb->map)||(!xkb->map->types)) { + _XkbLibError(_XkbErrMissingTypes,"XkbWriteXKBKeyTypes",0); + return False; + } + if (xkb->map->num_typesnames==NULL)||(xkb->names->types==None)) + fprintf(file,"xkb_types {\n\n"); + else fprintf(file,"xkb_types \"%s\" {\n\n", + XkbAtomText(dpy,xkb->names->types,XkbXKBFile)); + WriteXKBVModDecl(file,dpy,xkb, + (showImplicit?VMOD_COMMENT_VALUE:VMOD_HIDE_VALUE)); + + type= xkb->map->types; + for (i=0;imap->num_types;i++,type++) { + fprintf(file," type \"%s\" {\n", + XkbAtomText(dpy,type->name,XkbXKBFile)); + fprintf(file," modifiers= %s;\n", + XkbVModMaskText(dpy,xkb,type->mods.real_mods,type->mods.vmods, + XkbXKBFile)); + entry= type->map; + for (n=0;nmap_count;n++,entry++) { + char *str; + str=XkbVModMaskText(dpy,xkb,entry->mods.real_mods,entry->mods.vmods, + XkbXKBFile); + fprintf(file," map[%s]= Level%d;\n",str,entry->level+1); + if ((type->preserve)&&((type->preserve[n].real_mods)|| + (type->preserve[n].vmods))) { + fprintf(file," preserve[%s]= ",str); + fprintf(file,"%s;\n",XkbVModMaskText(dpy,xkb, + type->preserve[n].real_mods, + type->preserve[n].vmods, + XkbXKBFile)); + } + } + if (type->level_names!=NULL) { + Atom *name= type->level_names; + for (n=0;nnum_levels;n++,name++) { + if ((*name)==None) + continue; + fprintf(file," level_name[Level%d]= \"%s\";\n",n+1, + XkbAtomText(dpy,*name,XkbXKBFile)); + } + } + fprintf(file," };\n"); + } + if (addOn) + (*addOn)(file,result,topLevel,showImplicit,XkmTypesIndex,priv); + fprintf(file,"};\n\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteXKBIndicatorMap( FILE * file, + XkbFileInfo * result, + Atom name, + XkbIndicatorMapPtr led, + XkbFileAddOnFunc addOn, + void * priv) +#else +WriteXKBIndicatorMap(file,result,name,led,addOn,priv) + FILE * file; + XkbFileInfo * result; + Atom name; + XkbIndicatorMapPtr led; + XkbFileAddOnFunc addOn; + void * priv; +#endif +{ +XkbDescPtr xkb; + + xkb= result->xkb; + fprintf(file," indicator \"%s\" {\n",XkbAtomGetString(xkb->dpy,name)); + if (led->flags&XkbIM_NoExplicit) + fprintf(file," !allowExplicit;\n"); + if (led->flags&XkbIM_LEDDrivesKB) + fprintf(file," indicatorDrivesKeyboard;\n"); + if (led->which_groups!=0) { + if (led->which_groups!=XkbIM_UseEffective) { + fprintf(file," whichGroupState= %s;\n", + XkbIMWhichStateMaskText(led->which_groups,XkbXKBFile)); + } + fprintf(file," groups= 0x%02x;\n",led->groups); + } + if (led->which_mods!=0) { + if (led->which_mods!=XkbIM_UseEffective) { + fprintf(file," whichModState= %s;\n", + XkbIMWhichStateMaskText(led->which_mods,XkbXKBFile)); + } + fprintf(file," modifiers= %s;\n", + XkbVModMaskText(xkb->dpy,xkb, + led->mods.real_mods,led->mods.vmods, + XkbXKBFile)); + } + if (led->ctrls!=0) { + fprintf(file," controls= %s;\n", + XkbControlsMaskText(led->ctrls,XkbXKBFile)); + } + if (addOn) + (*addOn)(file,result,False,True,XkmIndicatorsIndex,priv); + fprintf(file," };\n"); + return True; +} + +Bool +#if NeedFunctionPrototypes +XkbWriteXKBCompatMap( FILE * file, + XkbFileInfo * result, + Bool topLevel, + Bool showImplicit, + XkbFileAddOnFunc addOn, + void * priv) +#else +XkbWriteXKBCompatMap(file,result,topLevel,showImplicit,addOn,priv) + FILE * file; + XkbFileInfo * result; + Bool topLevel; + Bool showImplicit; + XkbFileAddOnFunc addOn; + void * priv; +#endif +{ +Display * dpy; +register unsigned i; +XkbSymInterpretPtr interp; +XkbDescPtr xkb; + + xkb= result->xkb; + dpy= xkb->dpy; + if ((!xkb)||(!xkb->compat)||(!xkb->compat->sym_interpret)) { + _XkbLibError(_XkbErrMissingCompatMap,"XkbWriteXKBCompatMap",0); + return False; + } + if ((xkb->names==NULL)||(xkb->names->compat==None)) + fprintf(file,"xkb_compatibility {\n\n"); + else fprintf(file,"xkb_compatibility \"%s\" {\n\n", + XkbAtomText(dpy,xkb->names->compat,XkbXKBFile)); + WriteXKBVModDecl(file,dpy,xkb, + (showImplicit?VMOD_COMMENT_VALUE:VMOD_HIDE_VALUE)); + + fprintf(file," interpret.useModMapMods= AnyLevel;\n"); + fprintf(file," interpret.repeat= False;\n"); + fprintf(file," interpret.locking= False;\n"); + interp= xkb->compat->sym_interpret; + for (i=0;icompat->num_si;i++,interp++) { + fprintf(file," interpret %s+%s(%s) {\n", + ((interp->sym==NoSymbol)?"Any": + XkbKeysymText(interp->sym,XkbXKBFile)), + XkbSIMatchText(interp->match,XkbXKBFile), + XkbModMaskText(interp->mods,XkbXKBFile)); + if (interp->virtual_mod!=XkbNoModifier) { + fprintf(file," virtualModifier= %s;\n", + XkbVModIndexText(dpy,xkb,interp->virtual_mod,XkbXKBFile)); + } + if (interp->match&XkbSI_LevelOneOnly) + fprintf(file," useModMapMods=level1;\n"); + if (interp->flags&XkbSI_LockingKey) + fprintf(file," locking= True;\n"); + if (interp->flags&XkbSI_AutoRepeat) + fprintf(file," repeat= True;\n"); + fprintf(file," action= "); + WriteXKBAction(file,result,&interp->act); + fprintf(file,";\n"); + fprintf(file," };\n"); + } + for (i=0;icompat->groups[i]; + if ((gc->real_mods==0)&&(gc->vmods==0)) + continue; + fprintf(file," group %d = %s;\n",i+1,XkbVModMaskText(xkb->dpy,xkb, + gc->real_mods,gc->vmods, + XkbXKBFile)); + } + if (xkb->indicators) { + for (i=0;iindicators->maps[i]; + if ((map->flags!=0)||(map->which_groups!=0)||(map->groups!=0)|| + (map->which_mods!=0)|| + (map->mods.real_mods!=0)||(map->mods.vmods!=0)|| + (map->ctrls!=0)) { + WriteXKBIndicatorMap(file,result,xkb->names->indicators[i],map, + addOn,priv); + } + } + } + if (addOn) + (*addOn)(file,result,topLevel,showImplicit,XkmCompatMapIndex,priv); + fprintf(file,"};\n\n"); + return True; +} + +Bool +#if NeedFunctionPrototypes +XkbWriteXKBSymbols( FILE * file, + XkbFileInfo * result, + Bool topLevel, + Bool showImplicit, + XkbFileAddOnFunc addOn, + void * priv) +#else +XkbWriteXKBSymbols(file,result,topLevel,showImplicit,addOn,priv) + FILE * file; + XkbFileInfo * result; + Bool topLevel; + Bool showImplicit; + XkbFileAddOnFunc addOn; + void * priv; +#endif +{ +Display * dpy; +register unsigned i,tmp; +XkbDescPtr xkb; +XkbClientMapPtr map; +XkbServerMapPtr srv; +Bool showActions; + + xkb= result->xkb; + map= xkb->map; + srv= xkb->server; + dpy= xkb->dpy; + if ((!xkb)||(!map)||(!map->syms)||(!map->key_sym_map)) { + _XkbLibError(_XkbErrMissingSymbols,"XkbWriteXKBSymbols",0); + return False; + } + if ((!xkb->names)||(!xkb->names->keys)) { + _XkbLibError(_XkbErrMissingNames,"XkbWriteXKBSymbols",0); + return False; + } + if ((xkb->names==NULL)||(xkb->names->symbols==None)) + fprintf(file,"xkb_symbols {\n\n"); + else fprintf(file,"xkb_symbols \"%s\" {\n\n", + XkbAtomText(dpy,xkb->names->symbols,XkbXKBFile)); + for (tmp=i=0;inames->groups[i]!=None) { + fprintf(file," name[group%d]=\"%s\";\n",i+1, + XkbAtomText(dpy,xkb->names->groups[i],XkbXKBFile)); + tmp++; + } + } + if (tmp>0) + fprintf(file,"\n"); + for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) { + Bool simple; + if ((int)XkbKeyNumSyms(xkb,i)<1) + continue; + if (XkbFindKeycodeByName(xkb,xkb->names->keys[i].name,True)!=i) + continue; + simple= True; + fprintf(file," key %6s {", + XkbKeyNameText(xkb->names->keys[i].name,XkbXKBFile)); + if (srv->explicit) { + if (((srv->explicit[i]&XkbExplicitKeyTypesMask)!=0)|| + (showImplicit)) { + int typeNdx,g; + Bool multi; + char * comment=" "; + + if ((srv->explicit[i]&XkbExplicitKeyTypesMask)==0) + comment= "//"; + multi= False; + typeNdx= XkbKeyKeyTypeIndex(xkb,i,0); + for (g=1;(gexplicit[i]&(1<types[typeNdx].name, + XkbXKBFile)); + } + else if (showImplicit) { + fprintf(file,"\n// type[group%d]= \"%s\",",g+1, + XkbAtomText(dpy,map->types[typeNdx].name, + XkbXKBFile)); + } + } + } + else { + fprintf(file,"\n%s type= \"%s\",",comment, + XkbAtomText(dpy,map->types[typeNdx].name, + XkbXKBFile)); + } + simple= False; + } + if (((srv->explicit[i]&XkbExplicitAutoRepeatMask)!=0)&& + (xkb->ctrls!=NULL)) { + if (xkb->ctrls->per_key_repeat[i/8]&(1<<(i%8))) + fprintf(file,"\n repeat= Yes,"); + else fprintf(file,"\n repeat= No,"); + simple= False; + } + if ((xkb->server!=NULL)&&(xkb->server->vmodmap!=NULL)&& + (xkb->server->vmodmap[i]!=0)) { + if ((srv->explicit[i]&XkbExplicitVModMapMask)!=0) { + fprintf(file,"\n virtualMods= %s,", + XkbVModMaskText(dpy,xkb,0, + xkb->server->vmodmap[i], + XkbXKBFile)); + } + else if (showImplicit) { + fprintf(file,"\n// virtualMods= %s,", + XkbVModMaskText(dpy,xkb,0, + xkb->server->vmodmap[i], + XkbXKBFile)); + } + } + } + switch (XkbOutOfRangeGroupAction(XkbKeyGroupInfo(xkb,i))) { + case XkbClampIntoRange: + fprintf(file,"\n groupsClamp,"); + break; + case XkbRedirectIntoRange: + fprintf(file,"\n groupsRedirect= Group%d,", + XkbOutOfRangeGroupNumber(XkbKeyGroupInfo(xkb,i))+1); + break; + } + if (srv->behaviors!=NULL) { + unsigned type; + type= srv->behaviors[i].type&XkbKB_OpMask; + + if (type!=XkbKB_Default) { + simple= False; + fprintf(file,"\n %s,", + XkbBehaviorText(xkb,&srv->behaviors[i],XkbXKBFile)); + } + } + if ((srv->explicit==NULL) || showImplicit || + ((srv->explicit[i]&XkbExplicitInterpretMask)!=0)) + showActions= XkbKeyHasActions(xkb,i); + else showActions= False; + + if (((unsigned)XkbKeyNumGroups(xkb,i)>1)||showActions) + simple= False; + if (simple) { + KeySym *syms; + unsigned s; + + syms= XkbKeySymsPtr(xkb,i); + fprintf(file," [ "); + for (s=0;smodmap) { + for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) { + if (map->modmap[i]!=0) { + register int n,bit; + for (bit=1,n=0;nmodmap[i]&bit) { + char buf[5]; + memcpy(buf,xkb->names->keys[i].name,4); + buf[4]= '\0'; + fprintf(file," modifier_map %s { <%s> };\n", + XkbModIndexText(n,XkbXKBFile),buf); + } + } + } + } + } + if (addOn) + (*addOn)(file,result,topLevel,showImplicit,XkmSymbolsIndex,priv); + fprintf(file,"};\n\n"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteXKBOutline( FILE * file, + XkbShapePtr shape, + XkbOutlinePtr outline, + int lastRadius, + int first, + int indent) +#else +WriteXKBOutline(file,shape,outline,lastRadius,first,indent) + FILE * file; + XkbShapePtr shape; + XkbOutlinePtr outline; + int lastRadius; + int first; + int indent; +#endif +{ +register int i; +XkbPointPtr pt; +char * iStr; + + fprintf(file,"%s",iStr= XkbIndentText(first)); + if (first!=indent) + iStr= XkbIndentText(indent); + if (outline->corner_radius!=lastRadius) { + fprintf(file,"corner= %s,", + XkbGeomFPText(outline->corner_radius,XkbMessage)); + if (shape!=NULL) { + fprintf(file,"\n%s",iStr); + } + } + if (shape) { + if (outline==shape->approx) + fprintf(file,"approx= "); + else if (outline==shape->primary) + fprintf(file,"primary= "); + } + fprintf(file,"{"); + for (pt=outline->points,i=0;inum_points;i++,pt++) { + if (i==0) fprintf(file," "); + else if ((i%4)==0) fprintf(file,",\n%s ",iStr); + else fprintf(file,", "); + fprintf(file,"[ %3s, %3s ]",XkbGeomFPText(pt->x,XkbXKBFile), + XkbGeomFPText(pt->y,XkbXKBFile)); + } + fprintf(file," }"); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteXKBDoodad( FILE * file, + Display * dpy, + unsigned indent, + XkbGeometryPtr geom, + XkbDoodadPtr doodad) +#else +WriteXKBDoodad(file,dpy,indent,geom,doodad) + FILE * file; + Display * dpy; + unsigned indent; + XkbGeometryPtr geom; + XkbDoodadPtr doodad; +#endif +{ +register char * i_str; +XkbShapePtr shape; +XkbColorPtr color; + + i_str= XkbIndentText(indent); + fprintf(file,"%s%s \"%s\" {\n",i_str, + XkbDoodadTypeText(doodad->any.type,XkbMessage), + XkbAtomText(dpy,doodad->any.name,XkbMessage)); + fprintf(file,"%s top= %s;\n",i_str, + XkbGeomFPText(doodad->any.top,XkbXKBFile)); + fprintf(file,"%s left= %s;\n",i_str, + XkbGeomFPText(doodad->any.left,XkbXKBFile)); + fprintf(file,"%s priority= %d;\n",i_str,doodad->any.priority); + switch (doodad->any.type) { + case XkbOutlineDoodad: + case XkbSolidDoodad: + if (doodad->shape.angle!=0) { + fprintf(file,"%s angle= %s;\n",i_str, + XkbGeomFPText(doodad->shape.angle,XkbXKBFile)); + } + if (doodad->shape.color_ndx!=0) { + fprintf(file,"%s color= \"%s\";\n",i_str, + XkbShapeDoodadColor(geom,&doodad->shape)->spec); + } + shape= XkbShapeDoodadShape(geom,&doodad->shape); + fprintf(file,"%s shape= \"%s\";\n",i_str, + XkbAtomText(dpy,shape->name,XkbXKBFile)); + break; + case XkbTextDoodad: + if (doodad->text.angle!=0) { + fprintf(file,"%s angle= %s;\n",i_str, + XkbGeomFPText(doodad->text.angle,XkbXKBFile)); + } + if (doodad->text.width!=0) { + fprintf(file,"%s width= %s;\n",i_str, + XkbGeomFPText(doodad->text.width,XkbXKBFile)); + + } + if (doodad->text.height!=0) { + fprintf(file,"%s height= %s;\n",i_str, + XkbGeomFPText(doodad->text.height,XkbXKBFile)); + + } + if (doodad->text.color_ndx!=0) { + color= XkbTextDoodadColor(geom,&doodad->text); + fprintf(file,"%s color= \"%s\";\n",i_str, + XkbStringText(color->spec,XkbXKBFile)); + } + fprintf(file,"%s XFont= \"%s\";\n",i_str, + XkbStringText(doodad->text.font,XkbXKBFile)); + fprintf(file,"%s text= \"%s\";\n",i_str, + XkbStringText(doodad->text.text,XkbXKBFile)); + break; + case XkbIndicatorDoodad: + shape= XkbIndicatorDoodadShape(geom,&doodad->indicator); + color= XkbIndicatorDoodadOnColor(geom,&doodad->indicator); + fprintf(file,"%s onColor= \"%s\";\n",i_str, + XkbStringText(color->spec,XkbXKBFile)); + color= XkbIndicatorDoodadOffColor(geom,&doodad->indicator); + fprintf(file,"%s offColor= \"%s\";\n",i_str, + XkbStringText(color->spec,XkbXKBFile)); + fprintf(file,"%s shape= \"%s\";\n",i_str, + XkbAtomText(dpy,shape->name,XkbXKBFile)); + break; + case XkbLogoDoodad: + fprintf(file,"%s logoName= \"%s\";\n",i_str, + XkbStringText(doodad->logo.logo_name,XkbXKBFile)); + if (doodad->shape.angle!=0) { + fprintf(file,"%s angle= %s;\n",i_str, + XkbGeomFPText(doodad->logo.angle,XkbXKBFile)); + } + if (doodad->shape.color_ndx!=0) { + fprintf(file,"%s color= \"%s\";\n",i_str, + XkbLogoDoodadColor(geom,&doodad->logo)->spec); + } + shape= XkbLogoDoodadShape(geom,&doodad->logo); + fprintf(file,"%s shape= \"%s\";\n",i_str, + XkbAtomText(dpy,shape->name,XkbXKBFile)); + break; + } + fprintf(file,"%s};\n",i_str); + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +WriteXKBOverlay( FILE * file, + Display * dpy, + unsigned indent, + XkbGeometryPtr geom, + XkbOverlayPtr ol) +#else +WriteXKBOverlay(file,dpy,indent,geom,ol) + FILE * file; + Display * dpy; + unsigned indent; + XkbGeometryPtr geom; + XkbOverlayPtr ol; +#endif +{ +register char * i_str; +int r,k,nOut; +XkbOverlayRowPtr row; +XkbOverlayKeyPtr key; + + i_str= XkbIndentText(indent); + if (ol->name!=None) { + fprintf(file,"%soverlay \"%s\" {\n",i_str, + XkbAtomText(dpy,ol->name,XkbMessage)); + } + else fprintf(file,"%soverlay {\n",i_str); + for (nOut=r=0,row=ol->rows;rnum_rows;r++,row++) { + for (k=0,key=row->keys;knum_keys;k++,key++) { + char *over,*under; + over= XkbKeyNameText(key->over.name,XkbXKBFile); + under= XkbKeyNameText(key->under.name,XkbXKBFile); + if (nOut==0) + fprintf(file,"%s %6s=%6s",i_str,under,over); + else if ((nOut%4)==0) + fprintf(file,",\n%s %6s=%6s",i_str,under,over); + else fprintf(file,", %6s=%6s",under,over); + nOut++; + } + } + fprintf(file,"\n%s};\n",i_str); + return True; +} + +static Bool +#if NeedFunctionPrototypes +WriteXKBSection( FILE * file, + Display * dpy, + XkbSectionPtr s, + XkbGeometryPtr geom) +#else +WriteXKBSection(file,dpy,s,geom) + FILE * file; + Display * dpy; + XkbSectionPtr s; + XkbGeometryPtr geom; +#endif +{ +register int i; +XkbRowPtr row; +int dfltKeyColor; + + fprintf(file," section \"%s\" {\n", + XkbAtomText(dpy,s->name,XkbXKBFile)); + if (s->rows&&(s->rows->num_keys>0)) { + dfltKeyColor= s->rows->keys[0].color_ndx; + fprintf(file," key.color= \"%s\";\n", + XkbStringText(geom->colors[dfltKeyColor].spec,XkbXKBFile)); + } + fprintf(file," priority= %d;\n",s->priority); + fprintf(file," top= %s;\n",XkbGeomFPText(s->top,XkbXKBFile)); + fprintf(file," left= %s;\n",XkbGeomFPText(s->left,XkbXKBFile)); + fprintf(file," width= %s;\n",XkbGeomFPText(s->width,XkbXKBFile)); + fprintf(file," height= %s;\n", + XkbGeomFPText(s->height,XkbXKBFile)); + if (s->angle!=0) { + fprintf(file," angle= %s;\n", + XkbGeomFPText(s->angle,XkbXKBFile)); + } + for (i=0,row=s->rows;inum_rows;i++,row++) { + fprintf(file," row {\n"); + fprintf(file," top= %s;\n", + XkbGeomFPText(row->top,XkbXKBFile)); + fprintf(file," left= %s;\n", + XkbGeomFPText(row->left,XkbXKBFile)); + if (row->vertical) + fprintf(file," vertical;\n"); + if (row->num_keys>0) { + register int k; + register XkbKeyPtr key; + int forceNL=0; + int nThisLine= 0; + fprintf(file," keys {\n"); + for (k=0,key=row->keys;knum_keys;k++,key++) { + XkbShapePtr shape; + if (key->color_ndx!=dfltKeyColor) + forceNL= 1; + if (k==0) { + fprintf(file," "); + nThisLine= 0; + } + else if (((nThisLine%2)==1)||(forceNL)) { + fprintf(file,",\n "); + forceNL= nThisLine= 0; + } + else { + fprintf(file,", "); + nThisLine++; + } + shape= XkbKeyShape(geom,key); + fprintf(file,"{ %6s, \"%s\", %3s", + XkbKeyNameText(key->name.name,XkbXKBFile), + XkbAtomText(dpy,shape->name,XkbXKBFile), + XkbGeomFPText(key->gap,XkbXKBFile)); + if (key->color_ndx!=dfltKeyColor) { + fprintf(file,", color=\"%s\"",XkbKeyColor(geom,key)->spec); + forceNL= 1; + } + fprintf(file," }"); + } + fprintf(file,"\n };\n"); + } + fprintf(file," };\n"); + } + if (s->doodads!=NULL) { + XkbDoodadPtr doodad; + for (i=0,doodad=s->doodads;inum_doodads;i++,doodad++) { + WriteXKBDoodad(file,dpy,8,geom,doodad); + } + } + if (s->overlays!=NULL) { + XkbOverlayPtr ol; + for (i=0,ol=s->overlays;inum_overlays;i++,ol++) { + WriteXKBOverlay(file,dpy,8,geom,ol); + } + } + fprintf(file," }; // End of \"%s\" section\n\n", + XkbAtomText(dpy,s->name,XkbXKBFile)); + return True; +} + +Bool +#if NeedFunctionPrototypes +XkbWriteXKBGeometry( FILE * file, + XkbFileInfo * result, + Bool topLevel, + Bool showImplicit, + XkbFileAddOnFunc addOn, + void * priv) +#else +XkbWriteXKBGeometry(file,result,topLevel,showImplicit,addOn,priv) + FILE * file; + XkbFileInfo * result; + Bool topLevel; + Bool showImplicit; + XkbFileAddOnFunc addOn; + void * priv; +#endif +{ +Display * dpy; +register unsigned i,n; +XkbDescPtr xkb; +XkbGeometryPtr geom; + + xkb= result->xkb; + if ((!xkb)||(!xkb->geom)) { + _XkbLibError(_XkbErrMissingGeometry,"XkbWriteXKBGeometry",0); + return False; + } + dpy= xkb->dpy; + geom= xkb->geom; + if (geom->name==None) + fprintf(file,"xkb_geometry {\n\n"); + else fprintf(file,"xkb_geometry \"%s\" {\n\n", + XkbAtomText(dpy,geom->name,XkbXKBFile)); + fprintf(file," width= %s;\n", + XkbGeomFPText(geom->width_mm,XkbXKBFile)); + fprintf(file," height= %s;\n\n", + XkbGeomFPText(geom->height_mm,XkbXKBFile)); + + if (geom->key_aliases!=NULL) { + XkbKeyAliasPtr pAl; + pAl= geom->key_aliases; + for (i=0;inum_key_aliases;i++,pAl++) { + fprintf(file," alias %6s = %6s;\n", + XkbKeyNameText(pAl->alias,XkbXKBFile), + XkbKeyNameText(pAl->real,XkbXKBFile)); + } + fprintf(file,"\n"); + } + + if (geom->base_color!=NULL) + fprintf(file," baseColor= \"%s\";\n", + XkbStringText(geom->base_color->spec,XkbXKBFile)); + if (geom->label_color!=NULL) + fprintf(file," labelColor= \"%s\";\n", + XkbStringText(geom->label_color->spec,XkbXKBFile)); + if (geom->label_font!=NULL) + fprintf(file," xfont= \"%s\";\n", + XkbStringText(geom->label_font,XkbXKBFile)); + if ((geom->num_colors>0)&&(showImplicit)) { + XkbColorPtr color; + for (color=geom->colors,i=0;inum_colors;i++,color++) { + fprintf(file,"// color[%d]= \"%s\"\n",i, + XkbStringText(color->spec,XkbXKBFile)); + } + fprintf(file,"\n"); + } + if (geom->num_properties>0) { + XkbPropertyPtr prop; + for (prop=geom->properties,i=0;inum_properties;i++,prop++) { + fprintf(file," %s= \"%s\";\n",prop->name, + XkbStringText(prop->value,XkbXKBFile)); + } + fprintf(file,"\n"); + } + if (geom->num_shapes>0) { + XkbShapePtr shape; + XkbOutlinePtr outline; + int lastR; + for (shape=geom->shapes,i=0;inum_shapes;i++,shape++) { + lastR=0; + fprintf(file," shape \"%s\" {", + XkbAtomText(dpy,shape->name,XkbXKBFile)); + outline= shape->outlines; + if (shape->num_outlines>1) { + for (n=0;nnum_outlines;n++,outline++) { + if (n==0) fprintf(file,"\n"); + else fprintf(file,",\n"); + WriteXKBOutline(file,shape,outline,lastR,8,8); + lastR= outline->corner_radius; + } + fprintf(file,"\n };\n"); + } + else { + WriteXKBOutline(file,NULL,outline,lastR,1,8); + fprintf(file," };\n"); + } + } + } + if (geom->num_sections>0) { + XkbSectionPtr section; + for (section=geom->sections,i=0;inum_sections;i++,section++){ + WriteXKBSection(file,dpy,section,geom); + } + } + if (geom->num_doodads>0) { + XkbDoodadPtr doodad; + for (i=0,doodad=geom->doodads;inum_doodads;i++,doodad++) { + WriteXKBDoodad(file,dpy,4,geom,doodad); + } + } + if (addOn) + (*addOn)(file,result,topLevel,showImplicit,XkmGeometryIndex,priv); + fprintf(file,"};\n\n"); + return True; +} + +/*ARGSUSED*/ +Bool +#if NeedFunctionPrototypes +XkbWriteXKBSemantics( FILE * file, + XkbFileInfo * result, + Bool topLevel, + Bool showImplicit, + XkbFileAddOnFunc addOn, + void * priv) +#else +XkbWriteXKBSemantics(file,result,topLevel,showImplicit,addOn,priv) + FILE * file; + XkbFileInfo * result; + Bool topLevel; + Bool showImplicit; + XkbFileAddOnFunc addOn; + void * priv; +#endif +{ +Bool ok; + + fprintf(file,"xkb_semantics {\n"); + ok= XkbWriteXKBKeyTypes(file,result,False,False,addOn,priv); + ok= ok&&XkbWriteXKBCompatMap(file,result,False,False,addOn,priv); + fprintf(file,"};\n"); + return ok; +} + +/*ARGSUSED*/ +Bool +#if NeedFunctionPrototypes +XkbWriteXKBLayout( FILE * file, + XkbFileInfo * result, + Bool topLevel, + Bool showImplicit, + XkbFileAddOnFunc addOn, + void * priv) +#else +XkbWriteXKBLayout(file,result,topLevel,showImplicit,addOn,priv) + FILE * file; + XkbFileInfo * result; + Bool topLevel; + Bool showImplicit; + XkbFileAddOnFunc addOn; + void * priv; +#endif +{ +Bool ok; +XkbDescPtr xkb; + + xkb= result->xkb; + fprintf(file,"xkb_layout {\n"); + ok= XkbWriteXKBKeycodes(file,result,False,showImplicit,addOn,priv); + ok= ok&&XkbWriteXKBSymbols(file,result,False,showImplicit,addOn,priv); + if (xkb->geom) + ok= ok&&XkbWriteXKBGeometry(file,result,False,showImplicit,addOn,priv); + fprintf(file,"};\n"); + return ok; +} + +/*ARGSUSED*/ +Bool +#if NeedFunctionPrototypes +XkbWriteXKBKeymap( FILE * file, + XkbFileInfo * result, + Bool topLevel, + Bool showImplicit, + XkbFileAddOnFunc addOn, + void * priv) +#else +XkbWriteXKBKeymap(file,result,topLevel,showImplicit,addOn,priv) + FILE * file; + XkbFileInfo * result; + Bool topLevel; + Bool showImplicit; + XkbFileAddOnFunc addOn; + void * priv; +#endif +{ +Bool ok; +XkbDescPtr xkb; + + xkb= result->xkb; + fprintf(file,"xkb_keymap {\n"); + ok= XkbWriteXKBKeycodes(file,result,False,showImplicit,addOn,priv); + ok= ok&&XkbWriteXKBKeyTypes(file,result,False,showImplicit,addOn,priv); + ok= ok&&XkbWriteXKBCompatMap(file,result,False,showImplicit,addOn,priv); + ok= ok&&XkbWriteXKBSymbols(file,result,False,showImplicit,addOn,priv); + if (xkb->geom) + ok= ok&&XkbWriteXKBGeometry(file,result,False,showImplicit,addOn,priv); + fprintf(file,"};\n"); + return ok; +} + +Bool +#if NeedFunctionPrototypes +XkbWriteXKBFile( FILE * out, + XkbFileInfo * result, + Bool showImplicit, + XkbFileAddOnFunc addOn, + void * priv) +#else +XkbWriteXKBFile(out,result,showImplicit,addOn,priv) + FILE * out; + XkbFileInfo * result; + Bool showImplicit; + XkbFileAddOnFunc addOn; + void * priv; +#endif +{ +Bool ok; +Bool (*func)( +#if NeedFunctionPrototypes + FILE * /* file */, + XkbFileInfo * /* result */, + Bool /* topLevel */, + Bool /* showImplicit */, + XkbFileAddOnFunc /* addOn */, + void * /* priv */ +#endif +); + + switch (result->type) { + case XkmSemanticsFile: + func= XkbWriteXKBSemantics; + break; + case XkmLayoutFile: + func= XkbWriteXKBLayout; + break; + case XkmKeymapFile: + func= XkbWriteXKBKeymap; + break; + case XkmTypesIndex: + func= XkbWriteXKBKeyTypes; + break; + case XkmCompatMapIndex: + func= XkbWriteXKBCompatMap; + break; + case XkmSymbolsIndex: + func= XkbWriteXKBSymbols; + break; + case XkmKeyNamesIndex: + func= XkbWriteXKBKeycodes; + break; + case XkmGeometryFile: + case XkmGeometryIndex: + func= XkbWriteXKBGeometry; + break; + case XkmVirtualModsIndex: + case XkmIndicatorsIndex: + _XkbLibError(_XkbErrBadImplementation, + XkbConfigText(result->type,XkbMessage),0); + return False; + } + if (out==NULL) { + _XkbLibError(_XkbErrFileCannotOpen,"XkbWriteXkbFile",0); + ok= False; + } + else { + ok= (*func)(out,result,True,showImplicit,addOn,priv); + } + if (!ok) { + return False; + } + return True; +} + diff --git a/src/xkbtext.c b/src/xkbtext.c new file mode 100644 index 0000000..18c07a1 --- /dev/null +++ b/src/xkbtext.c @@ -0,0 +1,1700 @@ +/* $Xorg: xkbtext.c,v 1.3 2000/08/17 19:46:44 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif + +#include + +#ifndef XKB_IN_SERVER + +#include +#include +#include + +#include "XKMformat.h" +#include "XKBfileInt.h" + +#else + +#include "X.h" +#define NEED_EVENTS +#include "Xproto.h" +#include "misc.h" +#include "inputstr.h" +#include "dix.h" +#include "XKBstr.h" +#define XKBSRV_NEED_FILE_FUNCS 1 +#include "XKBsrv.h" +#include "XKBgeom.h" + +#endif + +/***====================================================================***/ + +#define BUFFER_SIZE 512 + +static char textBuffer[BUFFER_SIZE]; +static int tbNext= 0; + +static char * +#if NeedFunctionPrototypes +tbGetBuffer(unsigned size) +#else +tbGetBuffer(size) + unsigned size; +#endif +{ +char *rtrn; + + if (size>=BUFFER_SIZE) + return NULL; + if ((BUFFER_SIZE-tbNext)<=size) + tbNext= 0; + rtrn= &textBuffer[tbNext]; + tbNext+= size; + return rtrn; +} + +/***====================================================================***/ + +char * +#if NeedFunctionPrototypes +XkbAtomText(Display *dpy,Atom atm,unsigned format) +#else +XkbAtomText(dpy,atm,format) + Display * dpy; + Atom atm; + unsigned format; +#endif +{ +char *rtrn,*tmp; + + tmp= XkbAtomGetString(dpy,atm); + if (tmp!=NULL) { + int len; + len= strlen(tmp)+1; + if (len>BUFFER_SIZE) + len= BUFFER_SIZE-2; + rtrn= tbGetBuffer(len); + strncpy(rtrn,tmp,len); + rtrn[len]= '\0'; + } + else { + rtrn= tbGetBuffer(1); + rtrn[0]= '\0'; + } + if (format==XkbCFile) { + for (tmp=rtrn;*tmp!='\0';tmp++) { + if ((tmp==rtrn)&&(!isalpha(*tmp))) + *tmp= '_'; + else if (!isalnum(*tmp)) + *tmp= '_'; + } + } + return XkbStringText(rtrn,format); +} + +/***====================================================================***/ + +char * +#if NeedFunctionPrototypes +XkbVModIndexText(Display *dpy,XkbDescPtr xkb,unsigned ndx,unsigned format) +#else +XkbVModIndexText(dpy,xkb,ndx,format) + Display * dpy; + XkbDescPtr xkb; + unsigned ndx; + unsigned format; +#endif +{ +register int len; +register Atom *vmodNames; +char *rtrn,*tmp; +char numBuf[20]; + + if (xkb && xkb->names) + vmodNames= xkb->names->vmods; + else vmodNames= NULL; + + tmp= NULL; + if (ndx>=XkbNumVirtualMods) + tmp= "illegal"; + else if (vmodNames&&(vmodNames[ndx]!=None)) + tmp= XkbAtomGetString(dpy,vmodNames[ndx]); + if (tmp==NULL) + sprintf(tmp=numBuf,"%d",ndx); + + len= strlen(tmp)+1; + if (format==XkbCFile) + len+= 4; + if (len>=BUFFER_SIZE) + len= BUFFER_SIZE-1; + rtrn= tbGetBuffer(len); + if (format==XkbCFile) { + strcpy(rtrn,"vmod_"); + strncpy(&rtrn[5],tmp,len-4); + } + else strncpy(rtrn,tmp,len); + return rtrn; +} + +char * +#if NeedFunctionPrototypes +XkbVModMaskText( Display * dpy, + XkbDescPtr xkb, + unsigned modMask, + unsigned mask, + unsigned format) +#else +XkbVModMaskText(dpy,xkb,modMask,mask,format) + Display * dpy; + XkbDescPtr xkb; + unsigned modMask; + unsigned mask; + unsigned format; +#endif +{ +register int i,bit; +int len; +char *mm,*rtrn; +char *str,buf[BUFFER_SIZE]; + + if ((modMask==0)&&(mask==0)) { + rtrn= tbGetBuffer(5); + if (format==XkbCFile) + sprintf(rtrn,"0"); + else sprintf(rtrn,"none"); + return rtrn; + } + if (modMask!=0) + mm= XkbModMaskText(modMask,format); + else mm= NULL; + + str= buf; + buf[0]= '\0'; + if (mask) { + char *tmp; + for (i=0,bit=1;i=BUFFER_SIZE) + len= BUFFER_SIZE-1; + rtrn= tbGetBuffer(len+1); + rtrn[0]= '\0'; + + if (mm!=NULL) { + i= strlen(mm); + if (i>len) + i= len; + strcpy(rtrn,mm); + } + else { + i=0; + } + if (str!=NULL) { + if (mm!=NULL) { + if (format==XkbCFile) strcat(rtrn,"|"); + else strcat(rtrn,"+"); + } + strncat(rtrn,str,len-i); + } + rtrn[len]= '\0'; + return rtrn; +} + +static char *modNames[XkbNumModifiers] = { + "Shift", "Lock", "Control", "Mod1", "Mod2", "Mod3", "Mod4", "Mod5" +}; + +char * +#if NeedFunctionPrototypes +XkbModIndexText(unsigned ndx,unsigned format) +#else +XkbModIndexText(ndx,format) + unsigned ndx; + unsigned format; +#endif +{ +char * rtrn; +char buf[100]; + + if (format==XkbCFile) { + if (ndx0) { + len= strlen(from); + if (len<((*pLeft)-3)) { + strcat(to,from); + *pLeft-= len; + return True; + } + } + *pLeft= -1; + return False; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +CopyNoActionArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int*sz) +#else +CopyNoActionArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ + return True; +} + +static Bool +#if NeedFunctionPrototypes +CopyModActionArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf, + int* sz) +#else +CopyModActionArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbModAction * act; +unsigned tmp; + + act= &action->mods; + tmp= XkbModActionVMods(act); + TryCopyStr(buf,"modifiers=",sz); + if (act->flags&XkbSA_UseModMapMods) + TryCopyStr(buf,"modMapMods",sz); + else if (act->real_mods || tmp) { + TryCopyStr(buf, + XkbVModMaskText(dpy,xkb,act->real_mods,tmp,XkbXKBFile), + sz); + } + else TryCopyStr(buf,"none",sz); + if (act->type==XkbSA_LockMods) + return True; + if (act->flags&XkbSA_ClearLocks) + TryCopyStr(buf,",clearLocks",sz); + if (act->flags&XkbSA_LatchToLock) + TryCopyStr(buf,",latchToLock",sz); + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +CopyGroupActionArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf, + int *sz) +#else +CopyGroupActionArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbGroupAction * act; +char tbuf[32]; + + act= &action->group; + TryCopyStr(buf,"group=",sz); + if (act->flags&XkbSA_GroupAbsolute) + sprintf(tbuf,"%d",XkbSAGroup(act)+1); + else if (XkbSAGroup(act)<0) + sprintf(tbuf,"%d",XkbSAGroup(act)); + else sprintf(tbuf,"+%d",XkbSAGroup(act)); + TryCopyStr(buf,tbuf,sz); + if (act->type==XkbSA_LockGroup) + return True; + if (act->flags&XkbSA_ClearLocks) + TryCopyStr(buf,",clearLocks",sz); + if (act->flags&XkbSA_LatchToLock) + TryCopyStr(buf,",latchToLock",sz); + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +CopyMovePtrArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz) +#else +CopyMovePtrArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbPtrAction * act; +int x,y; +char tbuf[32]; + + act= &action->ptr; + x= XkbPtrActionX(act); + y= XkbPtrActionY(act); + if ((act->flags&XkbSA_MoveAbsoluteX)||(x<0)) + sprintf(tbuf,"x=%d",x); + else sprintf(tbuf,"x=+%d",x); + TryCopyStr(buf,tbuf,sz); + + if ((act->flags&XkbSA_MoveAbsoluteY)||(y<0)) + sprintf(tbuf,",y=%d",y); + else sprintf(tbuf,",y=+%d",y); + TryCopyStr(buf,tbuf,sz); + if (act->flags&XkbSA_NoAcceleration) + TryCopyStr(buf,",!accel",sz); + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +CopyPtrBtnArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz) +#else +CopyPtrBtnArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbPtrBtnAction * act; +char tbuf[32]; + + act= &action->btn; + TryCopyStr(buf,"button=",sz); + if ((act->button>0)&&(act->button<6)) { + sprintf(tbuf,"%d",act->button); + TryCopyStr(buf,tbuf,sz); + } + else TryCopyStr(buf,"default",sz); + if (act->count>0) { + sprintf(tbuf,",count=%d",act->count); + TryCopyStr(buf,tbuf,sz); + } + if (action->type==XkbSA_LockPtrBtn) { + switch (act->flags&(XkbSA_LockNoUnlock|XkbSA_LockNoLock)) { + case XkbSA_LockNoLock: + sprintf(tbuf,",affect=unlock"); break; + case XkbSA_LockNoUnlock: + sprintf(tbuf,",affect=lock"); break; + case XkbSA_LockNoUnlock|XkbSA_LockNoLock: + sprintf(tbuf,",affect=neither"); break; + default: + sprintf(tbuf,",affect=both"); break; + } + TryCopyStr(buf,tbuf,sz); + } + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +CopySetPtrDfltArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf, + int *sz) +#else +CopySetPtrDfltArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbPtrDfltAction * act; +char tbuf[32]; + + act= &action->dflt; + if (act->affect==XkbSA_AffectDfltBtn) { + TryCopyStr(buf,"affect=button,button=",sz); + if ((act->flags&XkbSA_DfltBtnAbsolute)||(XkbSAPtrDfltValue(act)<0)) + sprintf(tbuf,"%d",XkbSAPtrDfltValue(act)); + else sprintf(tbuf,"+%d",XkbSAPtrDfltValue(act)); + TryCopyStr(buf,tbuf,sz); + } + return True; +} + +static Bool +#if NeedFunctionPrototypes +CopyISOLockArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz) +#else +CopyISOLockArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbISOAction * act; +char tbuf[64]; + + act= &action->iso; + if (act->flags&XkbSA_ISODfltIsGroup) { + TryCopyStr(tbuf,"group=",sz); + if (act->flags&XkbSA_GroupAbsolute) + sprintf(tbuf,"%d",XkbSAGroup(act)+1); + else if (XkbSAGroup(act)<0) + sprintf(tbuf,"%d",XkbSAGroup(act)); + else sprintf(tbuf,"+%d",XkbSAGroup(act)); + TryCopyStr(buf,tbuf,sz); + } + else { + unsigned tmp; + tmp= XkbModActionVMods(act); + TryCopyStr(buf,"modifiers=",sz); + if (act->flags&XkbSA_UseModMapMods) + TryCopyStr(buf,"modMapMods",sz); + else if (act->real_mods || tmp) { + if (act->real_mods) { + TryCopyStr(buf,XkbModMaskText(act->real_mods,XkbXKBFile),sz); + if (tmp) + TryCopyStr(buf,"+",sz); + } + if (tmp) + TryCopyStr(buf,XkbVModMaskText(dpy,xkb,0,tmp,XkbXKBFile),sz); + } + else TryCopyStr(buf,"none",sz); + } + TryCopyStr(buf,",affect=",sz); + if ((act->affect&XkbSA_ISOAffectMask)==0) + TryCopyStr(buf,"all",sz); + else { + int nOut= 0; + if ((act->affect&XkbSA_ISONoAffectMods)==0) { + TryCopyStr(buf,"mods",sz); + nOut++; + } + if ((act->affect&XkbSA_ISONoAffectGroup)==0) { + sprintf(tbuf,"%sgroups",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if ((act->affect&XkbSA_ISONoAffectPtr)==0) { + sprintf(tbuf,"%spointer",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if ((act->affect&XkbSA_ISONoAffectCtrls)==0) { + sprintf(tbuf,"%scontrols",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + } + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +CopySwitchScreenArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf, + int *sz) +#else +CopySwitchScreenArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbSwitchScreenAction * act; +char tbuf[32]; + + act= &action->screen; + if ((act->flags&XkbSA_SwitchAbsolute)||(XkbSAScreen(act)<0)) + sprintf(tbuf,"screen=%d",XkbSAScreen(act)); + else sprintf(tbuf,"screen=+%d",XkbSAScreen(act)); + TryCopyStr(buf,tbuf,sz); + if (act->flags&XkbSA_SwitchApplication) + TryCopyStr(buf,",!same",sz); + else TryCopyStr(buf,",same",sz); + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +CopySetLockControlsArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action, + char *buf,int *sz) +#else +CopySetLockControlsArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbCtrlsAction * act; +unsigned tmp; +char tbuf[32]; + + act= &action->ctrls; + tmp= XkbActionCtrls(act); + TryCopyStr(buf,"controls=",sz); + if (tmp==0) + TryCopyStr(buf,"none",sz); + else if ((tmp&XkbAllBooleanCtrlsMask)==XkbAllBooleanCtrlsMask) + TryCopyStr(buf,"all",sz); + else { + int nOut= 0; + if (tmp&XkbRepeatKeysMask) { + sprintf(tbuf,"%sRepeatKeys",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbSlowKeysMask) { + sprintf(tbuf,"%sSlowKeys",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbBounceKeysMask) { + sprintf(tbuf,"%sBounceKeys",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbStickyKeysMask) { + sprintf(tbuf,"%sStickyKeys",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbMouseKeysMask) { + sprintf(tbuf,"%sMouseKeys",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbMouseKeysAccelMask) { + sprintf(tbuf,"%sMouseKeysAccel",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbAccessXKeysMask) { + sprintf(tbuf,"%sAccessXKeys",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbAccessXTimeoutMask) { + sprintf(tbuf,"%sAccessXTimeout",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbAccessXFeedbackMask) { + sprintf(tbuf,"%sAccessXFeedback",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbAudibleBellMask) { + sprintf(tbuf,"%sAudibleBell",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbOverlay1Mask) { + sprintf(tbuf,"%sOverlay1",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbOverlay2Mask) { + sprintf(tbuf,"%sOverlay2",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + if (tmp&XkbIgnoreGroupLockMask) { + sprintf(tbuf,"%sIgnoreGroupLock",(nOut>0?"+":"")); + TryCopyStr(buf,tbuf,sz); + nOut++; + } + } + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +CopyActionMessageArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf, + int *sz) +#else +CopyActionMessageArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbMessageAction * act; +unsigned all; +char tbuf[32]; + + act= &action->msg; + all= XkbSA_MessageOnPress|XkbSA_MessageOnRelease; + TryCopyStr(buf,"report=",sz); + if ((act->flags&all)==0) + TryCopyStr(buf,"none",sz); + else if ((act->flags&all)==all) + TryCopyStr(buf,"all",sz); + else if (act->flags&XkbSA_MessageOnPress) + TryCopyStr(buf,"KeyPress",sz); + else TryCopyStr(buf,"KeyRelease",sz); + sprintf(tbuf,",data[0]=0x%02x",act->message[0]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[1]=0x%02x",act->message[1]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[2]=0x%02x",act->message[2]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[3]=0x%02x",act->message[3]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[4]=0x%02x",act->message[4]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[5]=0x%02x",act->message[5]); TryCopyStr(buf,tbuf,sz); + return True; +} + +static Bool +#if NeedFunctionPrototypes +CopyRedirectKeyArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf, + int *sz) +#else +CopyRedirectKeyArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbRedirectKeyAction * act; +char tbuf[32],*tmp; +unsigned kc; +unsigned vmods,vmods_mask; + + act= &action->redirect; + kc= act->new_key; + vmods= XkbSARedirectVMods(act); + vmods_mask= XkbSARedirectVModsMask(act); + if (xkb && xkb->names && xkb->names->keys && (kc<=xkb->max_key_code) && + (xkb->names->keys[kc].name[0]!='\0')) { + char *kn; + kn= XkbKeyNameText(xkb->names->keys[kc].name,XkbXKBFile); + sprintf(tbuf,"key=%s",kn); + } + else sprintf(tbuf,"key=%d",kc); + TryCopyStr(buf,tbuf,sz); + if ((act->mods_mask==0)&&(vmods_mask==0)) + return True; + if ((act->mods_mask==XkbAllModifiersMask)&& + (vmods_mask==XkbAllVirtualModsMask)) { + tmp= XkbVModMaskText(dpy,xkb,act->mods,vmods,XkbXKBFile); + TryCopyStr(buf,",mods=",sz); + TryCopyStr(buf,tmp,sz); + } + else { + if ((act->mods_mask&act->mods)||(vmods_mask&vmods)) { + tmp= XkbVModMaskText(dpy,xkb,act->mods_mask&act->mods, + vmods_mask&vmods,XkbXKBFile); + TryCopyStr(buf,",mods= ",sz); + TryCopyStr(buf,tmp,sz); + } + if ((act->mods_mask&(~act->mods))||(vmods_mask&(~vmods))) { + tmp= XkbVModMaskText(dpy,xkb,act->mods_mask&(~act->mods), + vmods_mask&(~vmods),XkbXKBFile); + TryCopyStr(buf,",clearMods= ",sz); + TryCopyStr(buf,tmp,sz); + } + } + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +CopyDeviceBtnArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf, + int *sz) +#else +CopyDeviceBtnArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbDeviceBtnAction * act; +char tbuf[32]; + + act= &action->devbtn; + sprintf(tbuf,"device= %d",act->device); TryCopyStr(buf,tbuf,sz); + TryCopyStr(buf,",button=",sz); + sprintf(tbuf,"%d",act->button); + TryCopyStr(buf,tbuf,sz); + if (act->count>0) { + sprintf(tbuf,",count=%d",act->count); + TryCopyStr(buf,tbuf,sz); + } + if (action->type==XkbSA_LockDeviceBtn) { + switch (act->flags&(XkbSA_LockNoUnlock|XkbSA_LockNoLock)) { + case XkbSA_LockNoLock: + sprintf(tbuf,",affect=unlock"); break; + case XkbSA_LockNoUnlock: + sprintf(tbuf,",affect=lock"); break; + case XkbSA_LockNoUnlock|XkbSA_LockNoLock: + sprintf(tbuf,",affect=neither"); break; + default: + sprintf(tbuf,",affect=both"); break; + } + TryCopyStr(buf,tbuf,sz); + } + return True; +} + +/*ARGSUSED*/ +static Bool +#if NeedFunctionPrototypes +CopyOtherArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz) +#else +CopyOtherArgs(dpy,xkb,action,buf,sz) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + char * buf; + int * sz; +#endif +{ +XkbAnyAction * act; +char tbuf[32]; + + act= &action->any; + sprintf(tbuf,"type=0x%02x",act->type); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[0]=0x%02x",act->data[0]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[1]=0x%02x",act->data[1]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[2]=0x%02x",act->data[2]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[3]=0x%02x",act->data[3]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[4]=0x%02x",act->data[4]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[5]=0x%02x",act->data[5]); TryCopyStr(buf,tbuf,sz); + sprintf(tbuf,",data[6]=0x%02x",act->data[6]); TryCopyStr(buf,tbuf,sz); + return True; +} + +typedef Bool (*actionCopy)( +#if NeedFunctionPrototypes + Display * /* dpy */, + XkbDescPtr /* xkb */, + XkbAction * /* action */, + char * /* buf */, + int* /* sz */ +#endif +); +static actionCopy copyActionArgs[XkbSA_NumActions] = { + CopyNoActionArgs /* NoAction */, + CopyModActionArgs /* SetMods */, + CopyModActionArgs /* LatchMods */, + CopyModActionArgs /* LockMods */, + CopyGroupActionArgs /* SetGroup */, + CopyGroupActionArgs /* LatchGroup */, + CopyGroupActionArgs /* LockGroup */, + CopyMovePtrArgs /* MovePtr */, + CopyPtrBtnArgs /* PtrBtn */, + CopyPtrBtnArgs /* LockPtrBtn */, + CopySetPtrDfltArgs /* SetPtrDflt */, + CopyISOLockArgs /* ISOLock */, + CopyNoActionArgs /* Terminate */, + CopySwitchScreenArgs /* SwitchScreen */, + CopySetLockControlsArgs /* SetControls */, + CopySetLockControlsArgs /* LockControls */, + CopyActionMessageArgs /* ActionMessage*/, + CopyRedirectKeyArgs /* RedirectKey */, + CopyDeviceBtnArgs /* DeviceBtn */, + CopyDeviceBtnArgs /* LockDeviceBtn*/ +}; + +#define ACTION_SZ 256 + +char * +#if NeedFunctionPrototypes +XkbActionText(Display *dpy,XkbDescPtr xkb,XkbAction *action,unsigned format) +#else +XkbActionText(dpy,xkb,action,format) + Display * dpy; + XkbDescPtr xkb; + XkbAction * action; + unsigned format; +#endif +{ +char buf[ACTION_SZ],*tmp; +int sz; + + if (format==XkbCFile) { + sprintf(buf, + "{ %20s, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x }", + XkbActionTypeText(action->type,XkbCFile), + action->any.data[0],action->any.data[1],action->any.data[2], + action->any.data[3],action->any.data[4],action->any.data[5], + action->any.data[6]); + } + else { + sprintf(buf,"%s(",XkbActionTypeText(action->type,XkbXKBFile)); + sz= ACTION_SZ-strlen(buf)+2; /* room for close paren and NULL */ + if (action->type<(unsigned)XkbSA_NumActions) + (*copyActionArgs[action->type])(dpy,xkb,action,buf,&sz); + else CopyOtherArgs(dpy,xkb,action,buf,&sz); + TryCopyStr(buf,")",&sz); + } + tmp= tbGetBuffer(strlen(buf)+1); + if (tmp!=NULL) + strcpy(tmp,buf); + return tmp; +} + +char * +#if NeedFunctionPrototypes +XkbBehaviorText(XkbDescPtr xkb,XkbBehavior *behavior,unsigned format) +#else +XkbBehaviorText(xkb,behavior,format) + XkbDescPtr xkb; + XkbBehavior * behavior; + unsigned format; +#endif +{ +char buf[256],*tmp; + + if (format==XkbCFile) { + if (behavior->type==XkbKB_Default) + sprintf(buf,"{ 0, 0 }"); + else sprintf(buf,"{ %3d, 0x%02x }",behavior->type,behavior->data); + } + else { + unsigned type,permanent; + type= behavior->type&XkbKB_OpMask; + permanent=((behavior->type&XkbKB_Permanent)!=0); + + if (type==XkbKB_Lock) { + sprintf(buf,"lock= %s,",(permanent?"Permanent":"True")); + } + else if (type==XkbKB_RadioGroup) { + int g; + char *tmp; + g= ((behavior->data)&(~XkbKB_RGAllowNone))+1; + if (XkbKB_RGAllowNone&behavior->data) { + sprintf(buf,"allowNone,"); + tmp= &buf[strlen(buf)]; + } + else tmp= buf; + if (permanent) + sprintf(tmp,"permanentRadioGroup= %d",g); + else sprintf(tmp,"radioGroup= %d",g); + } + else if ((type==XkbKB_Overlay1)||(type==XkbKB_Overlay2)) { + int ndx,kc; + char *kn; + + ndx= ((type==XkbKB_Overlay1)?1:2); + kc= behavior->data; + if ((xkb)&&(xkb->names)&&(xkb->names->keys)) + kn= XkbKeyNameText(xkb->names->keys[kc].name,XkbXKBFile); + else { + static char tbuf[8]; + sprintf(tbuf,"%d",kc); + kn= tbuf; + } + if (permanent) + sprintf(buf,"permanentOverlay%d= %s",ndx,kn); + else sprintf(buf,"overlay%d= %s",ndx,kn); + } + } + tmp= tbGetBuffer(strlen(buf)+1); + if (tmp!=NULL) + strcpy(tmp,buf); + return tmp; +} + +/***====================================================================***/ + +char * +#if NeedFunctionPrototypes +XkbIndentText(unsigned size) +#else +XkbIndentText(size) + unsigned size; +#endif +{ +static char buf[32]; +register int i; + + if (size>31) + size= 31; + + for (i=0;ired= color->green= color->blue= 0; + return True; + } + else if (_XkbStrCaseEqual(def,"white")) { + color->red= color->green= color->blue= PIXEL_MAX; + return True; + } + else if ((sscanf(def,"grey%d",&tmp)==1)|| + (sscanf(def,"gray%d",&tmp)==1)|| + (sscanf(def,"Grey%d",&tmp)==1)|| + (sscanf(def,"Gray%d",&tmp)==1)) { + if ((tmp>0)&&(tmp<=100)) { + tmp= (PIXEL_MAX*tmp)/100; + color->red= color->green= color->blue= tmp; + return True; + } + } + else if ((tmp=(_XkbStrCaseEqual(def,"red")*100))|| + (sscanf(def,"red%d",&tmp)==1)) { + if ((tmp>0)&&(tmp<=100)) { + tmp= (PIXEL_MAX*tmp)/100; + color->red= tmp; + color->green= color->blue= 0; + return True; + } + } + else if ((tmp=(_XkbStrCaseEqual(def,"green")*100))|| + (sscanf(def,"green%d",&tmp)==1)) { + if ((tmp>0)&&(tmp<=100)) { + tmp= (PIXEL_MAX*tmp)/100; + color->green= tmp; + color->red= color->blue= 0; + return True; + } + } + else if ((tmp=(_XkbStrCaseEqual(def,"blue")*100))|| + (sscanf(def,"blue%d",&tmp)==1)) { + if ((tmp>0)&&(tmp<=100)) { + tmp= (PIXEL_MAX*tmp)/100; + color->blue= tmp; + color->red= color->green= 0; + return True; + } + } + else if ((tmp=(_XkbStrCaseEqual(def,"magenta")*100))|| + (sscanf(def,"magenta%d",&tmp)==1)) { + if ((tmp>0)&&(tmp<=100)) { + tmp= (PIXEL_MAX*tmp)/100; + color->green= 0; + color->red= color->blue= tmp; + return True; + } + } + else if ((tmp=(_XkbStrCaseEqual(def,"cyan")*100))|| + (sscanf(def,"cyan%d",&tmp)==1)) { + if ((tmp>0)&&(tmp<=100)) { + tmp= (PIXEL_MAX*tmp)/100; + color->red= 0; + color->green= color->blue= tmp; + return True; + } + } + else if ((tmp=(_XkbStrCaseEqual(def,"yellow")*100))|| + (sscanf(def,"yellow%d",&tmp)==1)) { + if ((tmp>0)&&(tmp<=100)) { + tmp= (PIXEL_MAX*tmp)/100; + color->blue= 0; + color->red= color->green= tmp; + return True; + } + } + return False; +} + +#endif diff --git a/src/xkmout.c b/src/xkmout.c new file mode 100644 index 0000000..c4aaadf --- /dev/null +++ b/src/xkmout.c @@ -0,0 +1,1628 @@ +/* $Xorg: xkmout.c,v 1.3 2000/08/17 19:46:44 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ + +#include +#include +#ifndef X_NOT_STDC_ENV +#include +#endif +#include +#include +#include +#include + +#include "XKMformat.h" +#include "XKBfileInt.h" + +typedef struct _XkmInfo { + unsigned short bound_vmods; + unsigned short named_vmods; + unsigned char num_bound; + unsigned char group_compat; + unsigned short num_group_compat; + unsigned short num_leds; + int total_vmodmaps; +} XkmInfo; + +/***====================================================================***/ + +#define xkmPutCARD8(f,v) (putc(v,f),1) + +static int +#if NeedFunctionPrototypes +xkmPutCARD16(FILE *file,unsigned val) +#else +xkmPutCARD16(file,val) + FILE * file; + unsigned val; +#endif +{ +CARD16 tmp= val; + + fwrite(&tmp,2,1,file); + return 2; +} + +static int +#if NeedFunctionPrototypes +xkmPutCARD32(FILE *file,unsigned long val) +#else +xkmPutCARD32(file,val) + FILE * file; + unsigned long val; +#endif +{ +CARD32 tmp= val; + + fwrite(&tmp,4,1,file); + return 4; +} + +static int +#if NeedFunctionPrototypes +xkmPutPadding(FILE *file,unsigned pad) +#else +xkmPutPadding(file,pad) + FILE * file; + unsigned pad; +#endif +{ +int i; + for (i=0;ixkb; + dpy= xkb->dpy; + if ((!xkb)||(!xkb->names)||(!xkb->server)) { + _XkbLibError(_XkbErrMissingVMods,"SizeXKMVirtualMods",0); + return 0; + } + bound=named=0; + for (i=nBound=nNamed=szNames=0,bit=1;iserver->vmods[i]!=XkbNoModifierMask) { + bound|= bit; + nBound++; + } + if (xkb->names->vmods[i]!=None) { + named|= bit; + szNames+= xkmSizeCountedAtomString(dpy,xkb->names->vmods[i]); + nNamed++; + } + } + info->num_bound= nBound; + info->bound_vmods= bound; + info->named_vmods= named; + if ((nBound==0)&&(nNamed==0)) + return 0; + toc->type= XkmVirtualModsIndex; + toc->format= MSBFirst; + toc->size= 4+XkbPaddedSize(nBound)+szNames+SIZEOF(xkmSectionInfo); + toc->offset= *offset_inout; + (*offset_inout)+= toc->size; + return 1; +} + +static unsigned +#if NeedFunctionPrototypes +WriteXKMVirtualMods(FILE *file,XkbFileInfo *result,XkmInfo *info) +#else +WriteXKMVirtualMods(file,result,info) + FILE * file; + XkbFileInfo * result; + XkmInfo * info; +#endif +{ +register unsigned int i,bit; +XkbDescPtr xkb; +Display * dpy; +unsigned size= 0; + + xkb= result->xkb; + dpy= xkb->dpy; + size+= xkmPutCARD16(file,info->bound_vmods); + size+= xkmPutCARD16(file,info->named_vmods); + for (i=0,bit=1;ibound_vmods&bit) + size+= xkmPutCARD8(file,xkb->server->vmods[i]); + } + if ((i= XkbPaddedSize(info->num_bound)-info->num_bound)>0) + size+= xkmPutPadding(file,i); + for (i=0,bit=1;inamed_vmods&bit) { + register char *name; + name= XkbAtomGetString(dpy,xkb->names->vmods[i]); + size+= xkmPutCountedString(file,name); + } + } + return size; +} + +/***====================================================================***/ + +static unsigned +#if NeedFunctionPrototypes +SizeXKMKeycodes(XkbFileInfo *result,xkmSectionInfo *toc,int *offset_inout) +#else +SizeXKMKeycodes(result,toc,offset_inout) + XkbFileInfo * result; + xkmSectionInfo * toc; + int * offset_inout; +#endif +{ +XkbDescPtr xkb; +Atom kcName; +int size=0; +Display * dpy; + + xkb= result->xkb; + dpy= xkb->dpy; + if ((!xkb)||(!xkb->names)||(!xkb->names->keys)) { + _XkbLibError(_XkbErrMissingNames,"SizeXKMKeycodes",0); + return 0; + } + kcName= xkb->names->keycodes; + size+= 4; /* min and max keycode */ + size+= xkmSizeCountedAtomString(dpy,kcName); + size+= XkbNumKeys(xkb)*sizeof(XkbKeyNameRec); + if (xkb->names->num_key_aliases>0) { + if (xkb->names->key_aliases!=NULL) + size+= xkb->names->num_key_aliases*sizeof(XkbKeyAliasRec); + else xkb->names->num_key_aliases= 0; + } + toc->type= XkmKeyNamesIndex; + toc->format= MSBFirst; + toc->size= size+SIZEOF(xkmSectionInfo); + toc->offset= (*offset_inout); + (*offset_inout)+= toc->size; + return 1; +} + +static unsigned +#if NeedFunctionPrototypes +WriteXKMKeycodes(FILE *file,XkbFileInfo *result) +#else +WriteXKMKeycodes(file,result) + FILE * file; + XkbFileInfo * result; +#endif +{ +XkbDescPtr xkb; +Atom kcName; +char *start; +Display * dpy; +unsigned tmp,size= 0; + + xkb= result->xkb; + dpy= xkb->dpy; + kcName= xkb->names->keycodes; + start= xkb->names->keys[xkb->min_key_code].name; + + size+= xkmPutCountedString(file,XkbAtomGetString(dpy,kcName)); + size+= xkmPutCARD8(file,xkb->min_key_code); + size+= xkmPutCARD8(file,xkb->max_key_code); + size+= xkmPutCARD8(file,xkb->names->num_key_aliases); + size+= xkmPutPadding(file,1); + tmp= fwrite(start,sizeof(XkbKeyNameRec),XkbNumKeys(xkb),file); + size+= tmp*sizeof(XkbKeyNameRec); + if (xkb->names->num_key_aliases>0) { + tmp= fwrite((char *)xkb->names->key_aliases, + sizeof(XkbKeyAliasRec),xkb->names->num_key_aliases, + file); + size+= tmp*sizeof(XkbKeyAliasRec); + } + return size; +} + +/***====================================================================***/ + +static unsigned +#if NeedFunctionPrototypes +SizeXKMKeyTypes(XkbFileInfo *result,xkmSectionInfo *toc,int *offset_inout) +#else +SizeXKMKeyTypes(result,toc,offset_inout) + XkbFileInfo * result; + xkmSectionInfo * toc; + int * offset_inout; +#endif +{ +register unsigned i,n,size; +XkbKeyTypePtr type; +XkbDescPtr xkb; +Display * dpy; +char * name; + + xkb= result->xkb; + dpy= xkb->dpy; + if ((!xkb)||(!xkb->map)||(!xkb->map->types)) { + _XkbLibError(_XkbErrMissingTypes,"SizeXKBKeyTypes",0); + return 0; + } + if (xkb->map->num_typesnames) name= XkbAtomGetString(dpy,xkb->names->types); + else name= NULL; + size= xkmSizeCountedString(name); + size+= 4; /* room for # of key types + padding */ + for (i=0,type=xkb->map->types;imap->num_types;i++,type++) { + size+= SIZEOF(xkmKeyTypeDesc); + size+= SIZEOF(xkmKTMapEntryDesc)*type->map_count; + size+= xkmSizeCountedAtomString(dpy,type->name); + if (type->preserve) + size+= SIZEOF(xkmModsDesc)*type->map_count; + if (type->level_names) { + Atom *names; + names= type->level_names; + for (n=0;n<(unsigned)type->num_levels;n++) { + size+= xkmSizeCountedAtomString(dpy,names[n]); + } + } + } + toc->type= XkmTypesIndex; + toc->format= MSBFirst; + toc->size= size+SIZEOF(xkmSectionInfo); + toc->offset= (*offset_inout); + (*offset_inout)+= toc->size; + return 1; +} + +static unsigned +#if NeedFunctionPrototypes +WriteXKMKeyTypes(FILE *file,XkbFileInfo *result) +#else +WriteXKMKeyTypes(file,result) + FILE * file; + XkbFileInfo * result; +#endif +{ +register unsigned i,n; +XkbDescPtr xkb; +XkbKeyTypePtr type; +xkmKeyTypeDesc wire; +XkbKTMapEntryPtr entry; +xkmKTMapEntryDesc wire_entry; +Atom * names; +Display * dpy; +unsigned tmp,size= 0; +char * name; + + xkb= result->xkb; + dpy= xkb->dpy; + if (xkb->names) name= XkbAtomGetString(dpy,xkb->names->types); + else name= NULL; + size+= xkmPutCountedString(file,name); + size+= xkmPutCARD16(file,xkb->map->num_types); + size+= xkmPutPadding(file,2); + type= xkb->map->types; + for (i=0;imap->num_types;i++,type++) { + wire.realMods= type->mods.real_mods; + wire.virtualMods= type->mods.vmods; + wire.numLevels= type->num_levels; + wire.nMapEntries= type->map_count; + wire.preserve= (type->preserve!=NULL); + if (type->level_names!=NULL) + wire.nLevelNames= type->num_levels; + else wire.nLevelNames= 0; + tmp= fwrite(&wire,SIZEOF(xkmKeyTypeDesc),1,file); + size+= tmp*SIZEOF(xkmKeyTypeDesc); + for (n=0,entry= type->map;nmap_count;n++,entry++) { + wire_entry.level= entry->level; + wire_entry.realMods= entry->mods.real_mods; + wire_entry.virtualMods= entry->mods.vmods; + tmp= fwrite(&wire_entry,SIZEOF(xkmKTMapEntryDesc),1,file); + size+= tmp*SIZEOF(xkmKTMapEntryDesc); + } + size+= xkmPutCountedString(file,XkbAtomGetString(dpy,type->name)); + if (type->preserve) { + xkmModsDesc p_entry; + XkbModsPtr pre; + for (n=0,pre=type->preserve;nmap_count;n++,pre++) { + p_entry.realMods= pre->real_mods; + p_entry.virtualMods= pre->vmods; + tmp= fwrite(&p_entry,SIZEOF(xkmModsDesc),1,file); + size+= tmp*SIZEOF(xkmModsDesc); + } + } + if (type->level_names!=NULL) { + names= type->level_names; + for (n=0;nxkb; + dpy= xkb->dpy; + if ((!xkb)||(!xkb->compat)||(!xkb->compat->sym_interpret)) { + _XkbLibError(_XkbErrMissingCompatMap,"SizeXKMCompatMap",0); + return 0; + } + if (xkb->names) name= XkbAtomGetString(dpy,xkb->names->compat); + else name= NULL; + + for (i=groups=nGroups=0;icompat->groups[i].real_mods!=0)|| + (xkb->compat->groups[i].vmods!=0)) { + groups|= (1<group_compat= groups; + info->num_group_compat= nGroups; + size= 4; /* room for num_si and group_compat mask */ + size+= xkmSizeCountedString(name); + size+= (SIZEOF(xkmSymInterpretDesc)*xkb->compat->num_si); + size+= (SIZEOF(xkmModsDesc)*nGroups); + toc->type= XkmCompatMapIndex; + toc->format= MSBFirst; + toc->size= size+SIZEOF(xkmSectionInfo); + toc->offset= (*offset_inout); + (*offset_inout)+= toc->size; + return 1; +} + +static unsigned +#if NeedFunctionPrototypes +WriteXKMCompatMap(FILE *file,XkbFileInfo *result,XkmInfo *info) +#else +WriteXKMCompatMap(file,result,info) + FILE * file; + XkbFileInfo * result; + XkmInfo * info; +#endif +{ +register unsigned i; +char * name; +XkbDescPtr xkb; +XkbSymInterpretPtr interp; +xkmSymInterpretDesc wire; +Display * dpy; +unsigned tmp,size=0; + + xkb= result->xkb; + dpy= xkb->dpy; + if (xkb->names) name= XkbAtomGetString(dpy,xkb->names->compat); + else name= NULL; + size+= xkmPutCountedString(file,name); + size+= xkmPutCARD16(file,xkb->compat->num_si); + size+= xkmPutCARD8(file,info->group_compat); + size+= xkmPutPadding(file,1); + interp= xkb->compat->sym_interpret; + for (i=0;icompat->num_si;i++,interp++) { + wire.sym= interp->sym; + wire.mods= interp->mods; + wire.match= interp->match; + wire.virtualMod= interp->virtual_mod; + wire.flags= interp->flags; + wire.actionType= interp->act.type; + wire.actionData[0]= interp->act.data[0]; + wire.actionData[1]= interp->act.data[1]; + wire.actionData[2]= interp->act.data[2]; + wire.actionData[3]= interp->act.data[3]; + wire.actionData[4]= interp->act.data[4]; + wire.actionData[5]= interp->act.data[5]; + wire.actionData[6]= interp->act.data[6]; + tmp= fwrite(&wire,SIZEOF(xkmSymInterpretDesc),1,file); + size+= tmp*SIZEOF(xkmSymInterpretDesc); + } + if (info->group_compat) { + register unsigned bit; + xkmModsDesc modsWire; + for (i=0,bit=1;igroup_compat&bit) { + modsWire.realMods= xkb->compat->groups[i].real_mods; + modsWire.virtualMods= xkb->compat->groups[i].vmods; + fwrite(&modsWire,SIZEOF(xkmModsDesc),1,file); + size+= SIZEOF(xkmModsDesc); + } + } + } + return size; +} + +/***====================================================================***/ + +static unsigned +#if NeedFunctionPrototypes +SizeXKMSymbols( XkbFileInfo * result, + XkmInfo * info, + xkmSectionInfo * toc, + int * offset_inout) +#else +SizeXKMSymbols(result,info,toc,offset_inout) + XkbFileInfo * result; + XkmInfo * info; + xkmSectionInfo * toc; + int * offset_inout; +#endif +{ +Display * dpy; +XkbDescPtr xkb; +unsigned size; +register int i,nSyms; +char * name; + + xkb= result->xkb; + dpy= xkb->dpy; + if ((!xkb)||(!xkb->map)||((!xkb->map->syms))) { + _XkbLibError(_XkbErrMissingSymbols,"SizeXKMSymbols",0); + return 0; + } + if (xkb->names && (xkb->names->symbols!=None)) + name= XkbAtomGetString(dpy,xkb->names->symbols); + else name= NULL; + size= xkmSizeCountedString(name); + size+= 4; /* min and max keycode, group names mask */ + for (i=0;inames->groups[i]!=None) + size+= xkmSizeCountedAtomString(dpy,xkb->names->groups[i]); + } + info->total_vmodmaps= 0; + for (i=xkb->min_key_code;i<=(int)xkb->max_key_code;i++) { + nSyms= XkbKeyNumSyms(xkb,i); + size+= SIZEOF(xkmKeySymMapDesc)+(nSyms*4); + if (xkb->server) { + if (xkb->server->explicit[i]&XkbExplicitKeyTypesMask) { + register int g; + for (g=XkbKeyNumGroups(xkb,i)-1;g>=0;g--) { + if (xkb->server->explicit[i]&(1<name); + if (name!=NULL) + size+= xkmSizeCountedString(name); + } + } + } + if (XkbKeyHasActions(xkb,i)) + size+= nSyms*SIZEOF(xkmActionDesc); + if (xkb->server->behaviors[i].type!=XkbKB_Default) + size+= SIZEOF(xkmBehaviorDesc); + if (xkb->server->vmodmap && (xkb->server->vmodmap[i]!=0)) + info->total_vmodmaps++; + } + } + size+= info->total_vmodmaps*SIZEOF(xkmVModMapDesc); + toc->type= XkmSymbolsIndex; + toc->format= MSBFirst; + toc->size= size+SIZEOF(xkmSectionInfo); + toc->offset= (*offset_inout); + (*offset_inout)+= toc->size; + return 1; +} + +static unsigned +#if NeedFunctionPrototypes +WriteXKMSymbols(FILE *file,XkbFileInfo *result,XkmInfo *info) +#else +WriteXKMSymbols(file,result,info) + FILE * file; + XkbFileInfo * result; + XkmInfo * info; +#endif +{ +Display * dpy; +XkbDescPtr xkb; +register int i,n; +xkmKeySymMapDesc wireMap; +char * name; +unsigned tmp,size= 0; + + xkb= result->xkb; + dpy= xkb->dpy; + if (xkb->names && (xkb->names->symbols!=None)) + name= XkbAtomGetString(dpy,xkb->names->symbols); + else name= NULL; + size+= xkmPutCountedString(file,name); + for (tmp=i=0;inames->groups[i]!=None) + tmp|= (1<min_key_code); + size+= xkmPutCARD8(file,xkb->max_key_code); + size+= xkmPutCARD8(file,tmp); + size+= xkmPutCARD8(file,info->total_vmodmaps); + for (i=0,n=1;inames->groups[i]); + } + for (i=xkb->min_key_code;i<=(int)xkb->max_key_code;i++) { + char *typeName[XkbNumKbdGroups]; + wireMap.width= XkbKeyGroupsWidth(xkb,i); + wireMap.num_groups= XkbKeyNumGroups(xkb,i); + if (xkb->map && xkb->map->modmap) + wireMap.modifier_map= xkb->map->modmap[i]; + else wireMap.modifier_map= 0; + wireMap.flags= 0; + bzero((char *)typeName,XkbNumKbdGroups*sizeof(char *)); + if (xkb->server) { + if (xkb->server->explicit[i]&XkbExplicitKeyTypesMask) { + register int g; + for (g=0;gserver->explicit[i]&(1<name); + if (typeName[g]!=NULL) + wireMap.flags|= (1<server->behaviors[i].type!=XkbKB_Default) + wireMap.flags|= XkmKeyHasBehavior; + if ((xkb->server->explicit[i]&XkbExplicitAutoRepeatMask)&& + (xkb->ctrls!=NULL)) { + if (xkb->ctrls->per_key_repeat[(i/8)]&(1<<(i%8))) + wireMap.flags|= XkmRepeatingKey; + else wireMap.flags|= XkmNonRepeatingKey; + } + } + tmp= fwrite(&wireMap,SIZEOF(xkmKeySymMapDesc),1,file); + size+= tmp*SIZEOF(xkmKeySymMapDesc); + if (xkb->server->explicit[i]&XkbExplicitKeyTypesMask) { + register int g; + for (g=0;g0) { + KeySym *sym; + sym= XkbKeySymsPtr(xkb,i); + for (n=XkbKeyNumSyms(xkb,i);n>0;n--,sym++) { + size+= xkmPutCARD32(file,(CARD32)*sym); + } + if (wireMap.flags&XkmKeyHasActions) { + XkbAction * act; + act= XkbKeyActionsPtr(xkb,i); + for (n=XkbKeyNumActions(xkb,i);n>0;n--,act++) { + tmp= fwrite(act,SIZEOF(xkmActionDesc),1,file); + size+= tmp*SIZEOF(xkmActionDesc); + } + } + } + if (wireMap.flags&XkmKeyHasBehavior) { + xkmBehaviorDesc b; + b.type= xkb->server->behaviors[i].type; + b.data= xkb->server->behaviors[i].data; + tmp= fwrite(&b,SIZEOF(xkmBehaviorDesc),1,file); + size+= tmp*SIZEOF(xkmBehaviorDesc); + } + } + if (info->total_vmodmaps>0) { + xkmVModMapDesc v; + for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) { + if (xkb->server->vmodmap[i]!=0) { + v.key= i; + v.vmods= xkb->server->vmodmap[i]; + tmp= fwrite(&v,SIZEOF(xkmVModMapDesc),1,file); + size+= tmp*SIZEOF(xkmVModMapDesc); + } + } + } + return size; +} + +/***====================================================================***/ + +static unsigned +#if NeedFunctionPrototypes +SizeXKMIndicators(XkbFileInfo *result,XkmInfo *info,xkmSectionInfo *toc, + int *offset_inout) +#else +SizeXKMIndicators(result,info,toc,offset_inout) + XkbFileInfo * result; + XkmInfo * info; + xkmSectionInfo * toc; + int * offset_inout; +#endif +{ +Display * dpy; +XkbDescPtr xkb; +unsigned size; +register unsigned i,nLEDs; + + xkb= result->xkb; + dpy= xkb->dpy; + if ((xkb==NULL)||(xkb->indicators==NULL)) { +/* _XkbLibError(_XkbErrMissingIndicators,"SizeXKMIndicators",0);*/ + return 0; + } + nLEDs=0; + size= 8; /* number of indicator maps/physical indicators */ + if (xkb->indicators!=NULL) { + for (i=0;iindicators->maps[i]; + if ((map->flags!=0)||(map->which_groups!=0)||(map->groups!=0)|| + (map->which_mods!=0)|| + (map->mods.real_mods!=0)||(map->mods.vmods!=0)|| + (map->ctrls!=0) || + (xkb->names && (xkb->names->indicators[i]!=None))) { + char *name; + if (xkb->names && xkb->names->indicators[i]!=None) { + name= XkbAtomGetString(dpy,xkb->names->indicators[i]); + } + else name= NULL; + size+= xkmSizeCountedString(name); + size+= SIZEOF(xkmIndicatorMapDesc); + nLEDs++; + } + } + } + info->num_leds= nLEDs; + toc->type= XkmIndicatorsIndex; + toc->format= MSBFirst; + toc->size= size+SIZEOF(xkmSectionInfo); + toc->offset= (*offset_inout); + (*offset_inout)+= toc->size; + return 1; +} + +static unsigned +#if NeedFunctionPrototypes +WriteXKMIndicators(FILE *file,XkbFileInfo *result,XkmInfo *info) +#else +WriteXKMIndicators(file,result,info) + FILE * file; + XkbFileInfo * result; + XkmInfo * info; +#endif +{ +Display * dpy; +XkbDescPtr xkb; +register unsigned i; +xkmIndicatorMapDesc wire; +unsigned tmp,size= 0; + + xkb= result->xkb; + dpy= xkb->dpy; + size+= xkmPutCARD8(file,info->num_leds); + size+= xkmPutPadding(file,3); + size+= xkmPutCARD32(file,xkb->indicators->phys_indicators); + if (xkb->indicators!=NULL) { + for (i=0;iindicators->maps[i]; + if ((map->flags!=0)||(map->which_groups!=0)||(map->groups!=0)|| + (map->which_mods!=0)|| + (map->mods.real_mods!=0)||(map->mods.vmods!=0)|| + (map->ctrls!=0) || + (xkb->names && (xkb->names->indicators[i]!=None))) { + char *name; + if (xkb->names && xkb->names->indicators[i]!=None) { + name= XkbAtomGetString(dpy,xkb->names->indicators[i]); + } + else name= NULL; + size+= xkmPutCountedString(file,name); + wire.indicator= i+1; + wire.flags= map->flags; + wire.which_mods= map->which_mods; + wire.real_mods= map->mods.real_mods; + wire.vmods= map->mods.vmods; + wire.which_groups= map->which_groups; + wire.groups= map->groups; + wire.ctrls= map->ctrls; + tmp= fwrite(&wire,SIZEOF(xkmIndicatorMapDesc),1,file); + size+= tmp*SIZEOF(xkmIndicatorMapDesc); + } + } + } + return size; +} + +/***====================================================================***/ + +static unsigned +#if NeedFunctionPrototypes +SizeXKMGeomDoodad(XkbFileInfo *result,XkbDoodadPtr doodad) +#else +SizeXKMGeomDoodad(result,doodad) + XkbFileInfo * result; + XkbDoodadPtr doodad; +#endif +{ +unsigned size; + + size= SIZEOF(xkmAnyDoodadDesc); + size+= xkmSizeCountedAtomString(result->xkb->dpy,doodad->any.name); + if (doodad->any.type==XkbTextDoodad) { + size+= xkmSizeCountedString(doodad->text.text); + size+= xkmSizeCountedString(doodad->text.font); + } + else if (doodad->any.type==XkbLogoDoodad) { + size+= xkmSizeCountedString(doodad->logo.logo_name); + } + return size; +} + +static unsigned +#if NeedFunctionPrototypes +SizeXKMGeomSection(XkbFileInfo *result,XkbSectionPtr section) +#else +SizeXKMGeomSection(result,section) + XkbFileInfo * result; + XkbSectionPtr section; +#endif +{ +register int i; +unsigned size; + + size= SIZEOF(xkmSectionDesc); + size+= xkmSizeCountedAtomString(result->xkb->dpy,section->name); + if (section->rows) { + XkbRowPtr row; + for (row=section->rows,i=0;inum_rows;i++,row++) { + size+= SIZEOF(xkmRowDesc); + size+= row->num_keys*SIZEOF(xkmKeyDesc); + } + } + if (section->doodads) { + XkbDoodadPtr doodad; + for (doodad=section->doodads,i=0;inum_doodads;i++,doodad++) { + size+= SizeXKMGeomDoodad(result,doodad); + } + } + if (section->overlays) { + XkbOverlayPtr ol; + for (ol=section->overlays,i=0;inum_overlays;i++,ol++) { + register int r; + XkbOverlayRowPtr row; + size+= xkmSizeCountedAtomString(result->xkb->dpy,ol->name); + size+= SIZEOF(xkmOverlayDesc); + for (r=0,row=ol->rows;rnum_rows;r++,row++) { + size+= SIZEOF(xkmOverlayRowDesc); + size+= row->num_keys*SIZEOF(xkmOverlayKeyDesc); + } + } + } + return size; +} + +static unsigned +#if NeedFunctionPrototypes +SizeXKMGeometry(XkbFileInfo *result,xkmSectionInfo *toc,int *offset_inout) +#else +SizeXKMGeometry(result,toc,offset_inout) + XkbFileInfo * result; + xkmSectionInfo * toc; + int * offset_inout; +#endif +{ +register int i; +Display * dpy; +XkbDescPtr xkb; +XkbGeometryPtr geom; +unsigned size; + + xkb= result->xkb; + dpy= xkb->dpy; + if ((!xkb)||(!xkb->geom)) + return 0; + geom= xkb->geom; + size= xkmSizeCountedAtomString(dpy,geom->name); + size+= SIZEOF(xkmGeometryDesc); + size+= xkmSizeCountedString(geom->label_font); + if (geom->properties) { + XkbPropertyPtr prop; + for (i=0,prop=geom->properties;inum_properties;i++,prop++) { + size+= xkmSizeCountedString(prop->name); + size+= xkmSizeCountedString(prop->value); + } + } + if (geom->colors) { + XkbColorPtr color; + for (i=0,color=geom->colors;inum_colors;i++,color++) { + size+= xkmSizeCountedString(color->spec); + } + } + if (geom->shapes) { + XkbShapePtr shape; + for (i=0,shape=geom->shapes;inum_shapes;i++,shape++) { + register int n; + register XkbOutlinePtr ol; + size+= xkmSizeCountedAtomString(dpy,shape->name); + size+= SIZEOF(xkmShapeDesc); + for (n=0,ol=shape->outlines;nnum_outlines;n++,ol++) { + size+= SIZEOF(xkmOutlineDesc); + size+= ol->num_points*SIZEOF(xkmPointDesc); + } + } + } + if (geom->sections) { + XkbSectionPtr section; + for (i=0,section=geom->sections;inum_sections;i++,section++) { + size+= SizeXKMGeomSection(result,section); + } + } + if (geom->doodads) { + XkbDoodadPtr doodad; + for (i=0,doodad=geom->doodads;inum_doodads;i++,doodad++) { + size+= SizeXKMGeomDoodad(result,doodad); + } + } + if (geom->key_aliases) { + size+= geom->num_key_aliases*(XkbKeyNameLength*2); + } + toc->type= XkmGeometryIndex; + toc->format= MSBFirst; + toc->size= size+SIZEOF(xkmSectionInfo); + toc->offset= (*offset_inout); + (*offset_inout)+= toc->size; + return 1; +} + +static unsigned +#if NeedFunctionPrototypes +WriteXKMGeomDoodad(FILE *file,XkbFileInfo *result,XkbDoodadPtr doodad) +#else +WriteXKMGeomDoodad(file,result,doodad) + FILE * file; + XkbFileInfo * result; + XkbDoodadPtr doodad; +#endif +{ +Display * dpy; +XkbDescPtr xkb; +xkmDoodadDesc doodadWire; +unsigned tmp,size= 0; + + xkb= result->xkb; + dpy= xkb->dpy; + bzero((char *)&doodadWire,sizeof(doodadWire)); + doodadWire.any.type= doodad->any.type; + doodadWire.any.priority= doodad->any.priority; + doodadWire.any.top= doodad->any.top; + doodadWire.any.left= doodad->any.left; + switch (doodad->any.type) { + case XkbOutlineDoodad: + case XkbSolidDoodad: + doodadWire.shape.angle= doodad->shape.angle; + doodadWire.shape.color_ndx= doodad->shape.color_ndx; + doodadWire.shape.shape_ndx= doodad->shape.shape_ndx; + break; + case XkbTextDoodad: + doodadWire.text.angle= doodad->text.angle; + doodadWire.text.width= doodad->text.width; + doodadWire.text.height= doodad->text.height; + doodadWire.text.color_ndx= doodad->text.color_ndx; + break; + case XkbIndicatorDoodad: + doodadWire.indicator.shape_ndx= doodad->indicator.shape_ndx; + doodadWire.indicator.on_color_ndx= doodad->indicator.on_color_ndx; + doodadWire.indicator.off_color_ndx= doodad->indicator.off_color_ndx; + break; + case XkbLogoDoodad: + doodadWire.logo.angle= doodad->logo.angle; + doodadWire.logo.color_ndx= doodad->logo.color_ndx; + doodadWire.logo.shape_ndx= doodad->logo.shape_ndx; + break; + default: + _XkbLibError(_XkbErrIllegalDoodad,"WriteXKMGeomDoodad", + doodad->any.type); + return 0; + } + size+= xkmPutCountedAtomString(dpy,file,doodad->any.name); + tmp= fwrite(&doodadWire,SIZEOF(xkmDoodadDesc),1,file); + size+= tmp*SIZEOF(xkmDoodadDesc); + if (doodad->any.type==XkbTextDoodad) { + size+= xkmPutCountedString(file,doodad->text.text); + size+= xkmPutCountedString(file,doodad->text.font); + } + else if (doodad->any.type==XkbLogoDoodad) { + size+= xkmPutCountedString(file,doodad->logo.logo_name); + } + return size; +} + +static unsigned +#if NeedFunctionPrototypes +WriteXKMGeomOverlay(FILE *file,XkbFileInfo *result,XkbOverlayPtr ol) +#else +WriteXKMGeomOverlay(file,result,ol) + FILE * file; + XkbFileInfo * result; + XkbOverlayPtr ol; +#endif +{ +register int r,k; +Display * dpy; +XkbDescPtr xkb; +XkbOverlayRowPtr row; +xkmOverlayDesc olWire; +xkmOverlayRowDesc rowWire; +xkmOverlayKeyDesc keyWire; +unsigned tmp,size= 0; + + xkb= result->xkb; + dpy= xkb->dpy; + bzero((char *)&olWire,sizeof(olWire)); + bzero((char *)&rowWire,sizeof(rowWire)); + bzero((char *)&keyWire,sizeof(keyWire)); + size+= xkmPutCountedAtomString(dpy,file,ol->name); + olWire.num_rows= ol->num_rows; + tmp= fwrite(&olWire,SIZEOF(xkmOverlayDesc),1,file); + size+= tmp*SIZEOF(xkmOverlayDesc); + for (r=0,row=ol->rows;rnum_rows;r++,row++) { + XkbOverlayKeyPtr key; + rowWire.row_under= row->row_under; + rowWire.num_keys= row->num_keys; + tmp= fwrite(&rowWire,SIZEOF(xkmOverlayRowDesc),1,file); + size+= tmp*SIZEOF(xkmOverlayRowDesc); + for (k=0,key=row->keys;knum_keys;k++,key++) { + memcpy(keyWire.over,key->over.name,XkbKeyNameLength); + memcpy(keyWire.under,key->under.name,XkbKeyNameLength); + tmp= fwrite(&keyWire,SIZEOF(xkmOverlayKeyDesc),1,file); + size+= tmp*SIZEOF(xkmOverlayKeyDesc); + } + } + return size; +} + +static unsigned +#if NeedFunctionPrototypes +WriteXKMGeomSection(FILE *file,XkbFileInfo *result,XkbSectionPtr section) +#else +WriteXKMGeomSection(file,result,section) + FILE * file; + XkbFileInfo * result; + XkbSectionPtr section; +#endif +{ +register int i; +Display * dpy; +XkbDescPtr xkb; +xkmSectionDesc sectionWire; +unsigned tmp,size= 0; + + xkb= result->xkb; + dpy= xkb->dpy; + size+= xkmPutCountedAtomString(dpy,file,section->name); + sectionWire.top= section->top; + sectionWire.left= section->left; + sectionWire.width= section->width; + sectionWire.height= section->height; + sectionWire.angle= section->angle; + sectionWire.priority= section->priority; + sectionWire.num_rows= section->num_rows; + sectionWire.num_doodads= section->num_doodads; + sectionWire.num_overlays= section->num_overlays; + tmp= fwrite(§ionWire,SIZEOF(xkmSectionDesc),1,file); + size+= tmp*SIZEOF(xkmSectionDesc); + if (section->rows) { + register unsigned k; + XkbRowPtr row; + xkmRowDesc rowWire; + XkbKeyPtr key; + xkmKeyDesc keyWire; + for (i=0,row=section->rows;inum_rows;i++,row++) { + rowWire.top= row->top; + rowWire.left= row->left; + rowWire.num_keys= row->num_keys; + rowWire.vertical= row->vertical; + tmp= fwrite(&rowWire,SIZEOF(xkmRowDesc),1,file); + size+= tmp*SIZEOF(xkmRowDesc); + for (k=0,key=row->keys;knum_keys;k++,key++) { + memcpy(keyWire.name,key->name.name,XkbKeyNameLength); + keyWire.gap= key->gap; + keyWire.shape_ndx= key->shape_ndx; + keyWire.color_ndx= key->color_ndx; + tmp= fwrite(&keyWire,SIZEOF(xkmKeyDesc),1,file); + size+= tmp*SIZEOF(xkmKeyDesc); + } + } + } + if (section->doodads) { + XkbDoodadPtr doodad; + for (i=0,doodad=section->doodads;inum_doodads;i++,doodad++) { + size+= WriteXKMGeomDoodad(file,result,doodad); + } + } + if (section->overlays) { + XkbOverlayPtr ol; + for (i=0,ol=section->overlays;inum_overlays;i++,ol++) { + size+= WriteXKMGeomOverlay(file,result,ol); + } + } + return size; +} + +static unsigned +#if NeedFunctionPrototypes +WriteXKMGeometry(FILE *file,XkbFileInfo *result) +#else +WriteXKMGeometry(file,result) + FILE * file; + XkbFileInfo * result; +#endif +{ +register int i; +Display * dpy; +XkbDescPtr xkb; +XkbGeometryPtr geom; +xkmGeometryDesc wire; +unsigned tmp,size= 0; + + xkb= result->xkb; + dpy= xkb->dpy; + if ((!xkb)||(!xkb->geom)) + return 0; + geom= xkb->geom; + wire.width_mm= geom->width_mm; + wire.height_mm= geom->height_mm; + wire.base_color_ndx= XkbGeomColorIndex(geom,geom->base_color); + wire.label_color_ndx= XkbGeomColorIndex(geom,geom->label_color); + wire.num_properties= geom->num_properties; + wire.num_colors= geom->num_colors; + wire.num_shapes= geom->num_shapes; + wire.num_sections= geom->num_sections; + wire.num_doodads= geom->num_doodads; + wire.num_key_aliases= geom->num_key_aliases; + size+= xkmPutCountedAtomString(dpy,file,geom->name); + tmp= fwrite(&wire,SIZEOF(xkmGeometryDesc),1,file); + size+= tmp*SIZEOF(xkmGeometryDesc); + size+= xkmPutCountedString(file,geom->label_font); + if (geom->properties) { + XkbPropertyPtr prop; + for (i=0,prop=geom->properties;inum_properties;i++,prop++) { + size+= xkmPutCountedString(file,prop->name); + size+= xkmPutCountedString(file,prop->value); + } + } + if (geom->colors) { + XkbColorPtr color; + for (i=0,color=geom->colors;inum_colors;i++,color++) { + size+= xkmPutCountedString(file,color->spec); + } + } + if (geom->shapes) { + XkbShapePtr shape; + xkmShapeDesc shapeWire; + + for (i=0,shape=geom->shapes;inum_shapes;i++,shape++) { + register int n; + XkbOutlinePtr ol; + xkmOutlineDesc olWire; + bzero((char *)&shapeWire,sizeof(xkmShapeDesc)); + size+= xkmPutCountedAtomString(dpy,file,shape->name); + shapeWire.num_outlines= shape->num_outlines; + if (shape->primary!=NULL) + shapeWire.primary_ndx= XkbOutlineIndex(shape,shape->primary); + else shapeWire.primary_ndx= XkbNoShape; + if (shape->approx!=NULL) + shapeWire.approx_ndx= XkbOutlineIndex(shape,shape->approx); + else shapeWire.approx_ndx= XkbNoShape; + tmp= fwrite(&shapeWire,SIZEOF(xkmShapeDesc),1,file); + size+= tmp*SIZEOF(xkmShapeDesc); + for (n=0,ol=shape->outlines;nnum_outlines;n++,ol++) { + register int p; + XkbPointPtr pt; + xkmPointDesc ptWire; + olWire.num_points= ol->num_points; + olWire.corner_radius= ol->corner_radius; + tmp= fwrite(&olWire,SIZEOF(xkmOutlineDesc),1,file); + size+= tmp*SIZEOF(xkmOutlineDesc); + for (p=0,pt=ol->points;pnum_points;p++,pt++) { + ptWire.x= pt->x; + ptWire.y= pt->y; + tmp= fwrite(&ptWire,SIZEOF(xkmPointDesc),1,file); + size+= tmp*SIZEOF(xkmPointDesc); + } + } + } + } + if (geom->sections) { + XkbSectionPtr section; + for (i=0,section=geom->sections;inum_sections;i++,section++) { + size+= WriteXKMGeomSection(file,result,section); + } + } + if (geom->doodads) { + XkbDoodadPtr doodad; + for (i=0,doodad=geom->doodads;inum_doodads;i++,doodad++) { + size+= WriteXKMGeomDoodad(file,result,doodad); + } + } + if (geom->key_aliases) { + tmp= fwrite(geom->key_aliases,2*XkbKeyNameLength,geom->num_key_aliases, + file); + size+= tmp*(2*XkbKeyNameLength); + } + return size; +} + +/***====================================================================***/ + +/*ARGSUSED*/ +static int +#if NeedFunctionPrototypes +GetXKMKeyNamesTOC( XkbFileInfo * result, + XkmInfo * info, + int max_toc, + xkmSectionInfo *toc_rtrn) +#else +GetXKMKeyNamesTOC(result,info,max_toc,toc_rtrn) + XkbFileInfo * result; + XkmInfo * info; + int max_toc; + xkmSectionInfo * toc_rtrn; +#endif +{ +int num_toc; +int total_size; + + total_size= num_toc=0; + if (SizeXKMKeycodes(result,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMIndicators(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + return num_toc; +} + +/*ARGSUSED*/ +static int +#if NeedFunctionPrototypes +GetXKMTypesTOC( XkbFileInfo * result, + XkmInfo * info, + int max_toc, + xkmSectionInfo *toc_rtrn) +#else +GetXKMTypesTOC(result,info,max_toc,toc_rtrn) + XkbFileInfo * result; + XkmInfo * info; + int max_toc; + xkmSectionInfo * toc_rtrn; +#endif +{ +int num_toc; +int total_size; + + total_size= num_toc=0; + if (SizeXKMVirtualMods(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMKeyTypes(result,&toc_rtrn[num_toc],&total_size)) + num_toc++; + return num_toc; +} + +/*ARGSUSED*/ +static int +#if NeedFunctionPrototypes +GetXKMCompatMapTOC( XkbFileInfo * result, + XkmInfo * info, + int max_toc, + xkmSectionInfo *toc_rtrn) +#else +GetXKMCompatMapTOC(result,info,max_toc,toc_rtrn) + XkbFileInfo * result; + XkmInfo * info; + int max_toc; + xkmSectionInfo * toc_rtrn; +#endif +{ +int num_toc; +int total_size; + + total_size= num_toc=0; + if (SizeXKMVirtualMods(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMCompatMap(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMIndicators(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + return num_toc; +} + +/*ARGSUSED*/ +static int +#if NeedFunctionPrototypes +GetXKMSemanticsTOC( XkbFileInfo * result, + XkmInfo * info, + int max_toc, + xkmSectionInfo *toc_rtrn) +#else +GetXKMSemanticsTOC(result,info,max_toc,toc_rtrn) + XkbFileInfo * result; + XkmInfo * info; + int max_toc; + xkmSectionInfo * toc_rtrn; +#endif +{ +int num_toc; +int total_size; + + total_size= num_toc=0; + if (SizeXKMVirtualMods(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMKeyTypes(result,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMCompatMap(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMIndicators(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + return num_toc; +} + +/*ARGSUSED*/ +static int +#if NeedFunctionPrototypes +GetXKMLayoutTOC( XkbFileInfo * result, + XkmInfo * info, + int max_toc, + xkmSectionInfo *toc_rtrn) +#else +GetXKMLayoutTOC(result,info,max_toc,toc_rtrn) + XkbFileInfo * result; + XkmInfo * info; + int max_toc; + xkmSectionInfo * toc_rtrn; +#endif +{ +int num_toc; +int total_size; + + total_size= num_toc=0; + if (SizeXKMVirtualMods(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMKeycodes(result,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMKeyTypes(result,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMSymbols(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMIndicators(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMGeometry(result,&toc_rtrn[num_toc],&total_size)) + num_toc++; + return num_toc; +} + +/*ARGSUSED*/ +static int +#if NeedFunctionPrototypes +GetXKMKeymapTOC( XkbFileInfo * result, + XkmInfo * info, + int max_toc, + xkmSectionInfo *toc_rtrn) +#else +GetXKMKeymapTOC(result,info,max_toc,toc_rtrn) + XkbFileInfo * result; + XkmInfo * info; + int max_toc; + xkmSectionInfo * toc_rtrn; +#endif +{ +int num_toc; +int total_size; + + total_size= num_toc=0; + if (SizeXKMVirtualMods(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMKeycodes(result,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMKeyTypes(result,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMCompatMap(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMSymbols(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMIndicators(result,info,&toc_rtrn[num_toc],&total_size)) + num_toc++; + if (SizeXKMGeometry(result,&toc_rtrn[num_toc],&total_size)) + num_toc++; + return num_toc; +} + +/*ARGSUSED*/ +static int +#if NeedFunctionPrototypes +GetXKMGeometryTOC( XkbFileInfo * result, + XkmInfo * info, + int max_toc, + xkmSectionInfo *toc_rtrn) +#else +GetXKMGeometryTOC(result,info,max_toc,toc_rtrn) + XkbFileInfo * result; + XkmInfo * info; + int max_toc; + xkmSectionInfo * toc_rtrn; +#endif +{ +int num_toc; +int total_size; + + total_size= num_toc=0; + if (SizeXKMGeometry(result,&toc_rtrn[num_toc],&total_size)) + num_toc++; + return num_toc; +} + +static Bool +#if NeedFunctionPrototypes +WriteXKMFile( FILE * file, + XkbFileInfo * result, + int num_toc, + xkmSectionInfo *toc, + XkmInfo * info) +#else +WriteXKMFile(file,result,num_toc,toc,info) + FILE * file; + XkbFileInfo * result; + int num_toc; + xkmSectionInfo * toc; + XkmInfo * info; +#endif +{ +register int i; +unsigned tmp,size,total= 0; + + for (i=0;itype) { + case XkmKeyNamesIndex: + getTOC= GetXKMKeyNamesTOC; + break; + case XkmTypesIndex: + getTOC= GetXKMTypesTOC; + break; + case XkmCompatMapIndex: + getTOC= GetXKMCompatMapTOC; + break; + case XkmSemanticsFile: + getTOC= GetXKMSemanticsTOC; + break; + case XkmLayoutFile: + getTOC= GetXKMLayoutTOC; + break; + case XkmKeymapFile: + getTOC= GetXKMKeymapTOC; + break; + case XkmGeometryFile: + case XkmGeometryIndex: + getTOC= GetXKMGeometryTOC; + break; + default: + _XkbLibError(_XkbErrIllegalContents, + XkbConfigText(result->type,XkbMessage),0); + return False; + } + xkb= result->xkb; + + bzero((char *)&info,sizeof(XkmInfo)); + size_toc= (*getTOC)(result,&info,MAX_TOC,toc); + if (size_toc<1) { + _XkbLibError(_XkbErrEmptyFile,"XkbWriteXKMFile",0); + return False; + } + if (out==NULL) { + _XkbLibError(_XkbErrFileCannotOpen,"XkbWriteXKMFile",0); + return False; + } + for (i=present=0;itype; + fileInfo.min_kc= xkb->min_key_code; + fileInfo.max_kc= xkb->max_key_code; + fileInfo.num_toc= size_toc; + fileInfo.present= present; + fileInfo.pad= 0; + fwrite(&fileInfo,SIZEOF(xkmFileInfo),1,out); + fwrite(toc,SIZEOF(xkmSectionInfo),size_toc,out); + ok= WriteXKMFile(out,result,size_toc,toc,&info); + return ok; +} diff --git a/src/xkmread.c b/src/xkmread.c new file mode 100644 index 0000000..7a4a2b4 --- /dev/null +++ b/src/xkmread.c @@ -0,0 +1,1481 @@ +/* $Xorg: xkmread.c,v 1.3 2000/08/17 19:46:44 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 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. + + ********************************************************/ + +#include + +#include +#include + +#ifndef XKB_IN_SERVER + +#ifndef X_NOT_STDC_ENV +#include +#endif +#include +#include + +#include + +#include +#include "XKMformat.h" +#include "XKBfileInt.h" + +#else + +#include "X.h" +#define NEED_EVENTS +#include "Xproto.h" +#include +#include "misc.h" +#include "inputstr.h" +#include "XKBstr.h" +#define XKBSRV_NEED_FILE_FUNCS +#include "XKBsrv.h" +#include "XKBgeom.h" + +Atom +#if NeedFunctionPrototypes +XkbInternAtom(Display *dpy,char *str,Bool only_if_exists) +#else +XkbInternAtom(dpy,str,only_if_exists) + Display * dpy; + char * str; + Bool only_if_exists; +#endif +{ + if (str==NULL) + return None; + return MakeAtom(str,strlen(str),!only_if_exists); +} + +#endif + +#ifndef SEEK_SET +#define SEEK_SET 0 +#endif + +char * +#if NeedFunctionPrototypes +_XkbDupString(char *str) +#else +_XkbDupString(str) + char *str; +#endif +{ +char *new; + + if (str==NULL) + return NULL; + new= (char *)_XkbCalloc(strlen(str)+1,sizeof(char)); + if (new) + strcpy(new,str); + return new; +} + +/***====================================================================***/ + +static XPointer +#if NeedFunctionPrototypes +XkmInsureSize(XPointer oldPtr,int oldCount,int *newCountRtrn,int elemSize) +#else +XkmInsureSize(oldPtr,oldCount,newCountRtrn,elemSize) + XPointer oldPtr; + int oldCount; + int * newCountRtrn; + int elemSize; +#endif +{ +int newCount= *newCountRtrn; + + if (oldPtr==NULL) { + if (newCount==0) + return NULL; + oldPtr= (XPointer)_XkbCalloc(newCount,elemSize); + } + else if (oldCount0) { + int tmp; + if (count>max_len) { + tmp= fread(str,1,max_len,file); + while (tmp=max_len) str[max_len-1]= '\0'; + else str[count]= '\0'; + count= XkbPaddedSize(nRead)-nRead; + if (count>0) + nRead+= XkmSkipPadding(file,count); + return nRead; +} + +/***====================================================================***/ + +static int +#if NeedFunctionPrototypes +ReadXkmVirtualMods(FILE *file,XkbFileInfo *result,XkbChangesPtr changes) +#else +ReadXkmVirtualMods(file,result,changes) + FILE * file; + XkbFileInfo * result; + XkbChangesPtr changes; +#endif +{ +register unsigned int i,bit; +unsigned int bound,named,tmp; +int nRead=0; +XkbDescPtr xkb; + + xkb= result->xkb; + if (XkbAllocServerMap(xkb,XkbVirtualModsMask,0)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"ReadXkmVirtualMods",0); + return -1; + } + bound= XkmGetCARD16(file,&nRead); + named= XkmGetCARD16(file,&nRead); + for (i=tmp=0,bit=1;iserver->vmods[i]= XkmGetCARD8(file,&nRead); + if (changes) + changes->map.vmods|= bit; + tmp++; + } + } + if ((i= XkbPaddedSize(tmp)-tmp)>0) + nRead+= XkmSkipPadding(file,i); + if (XkbAllocNames(xkb,XkbVirtualModNamesMask,0,0)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"ReadXkmVirtualMods",0); + return -1; + } + for (i=0,bit=1;inames->vmods[i]= XkbInternAtom(xkb->dpy,name,False); + if (changes) + changes->names.changed_vmods|= bit; + } + } + } + return nRead; +} + +/***====================================================================***/ + +static int +#if NeedFunctionPrototypes +ReadXkmKeycodes(FILE *file,XkbFileInfo *result,XkbChangesPtr changes) +#else +ReadXkmKeycodes(file,result,changes) + FILE * file; + XkbFileInfo * result; + XkbChangesPtr changes; +#endif +{ +register int i; +unsigned minKC,maxKC,nAl; +int nRead=0; +char name[100]; +XkbKeyNamePtr pN; +XkbDescPtr xkb; + + xkb= result->xkb; + name[0]= '\0'; + nRead+= XkmGetCountedString(file,name,100); + minKC= XkmGetCARD8(file,&nRead); + maxKC= XkmGetCARD8(file,&nRead); + if (xkb->min_key_code==0) { + xkb->min_key_code= minKC; + xkb->max_key_code= maxKC; + } + else { + if (minKCmin_key_code) + xkb->min_key_code= minKC; + if (maxKC>xkb->max_key_code) { + _XkbLibError(_XkbErrBadValue,"ReadXkmKeycodes",maxKC); + return -1; + } + } + nAl= XkmGetCARD8(file,&nRead); + nRead+= XkmSkipPadding(file,1); + +#define WANTED (XkbKeycodesNameMask|XkbKeyNamesMask|XkbKeyAliasesMask) + if (XkbAllocNames(xkb,WANTED,0,nAl)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"ReadXkmKeycodes",0); + return -1; + } + if (name[0]!='\0') { + xkb->names->keycodes= XkbInternAtom(xkb->dpy,name,False); + } + + for (pN=&xkb->names->keys[minKC],i=minKC;i<=(int)maxKC;i++,pN++) { + if (fread(pN,1,XkbKeyNameLength,file)!=XkbKeyNameLength) { + _XkbLibError(_XkbErrBadLength,"ReadXkmKeycodes",0); + return -1; + } + nRead+= XkbKeyNameLength; + } + if (nAl>0) { + XkbKeyAliasPtr pAl; + for (pAl= xkb->names->key_aliases,i=0;inames.changed|= XkbKeyAliasesMask; + } + if (changes) + changes->names.changed|= XkbKeyNamesMask; + return nRead; +} + +/***====================================================================***/ + +static int +#if NeedFunctionPrototypes +ReadXkmKeyTypes(FILE *file,XkbFileInfo *result,XkbChangesPtr changes) +#else +ReadXkmKeyTypes(file,result,changes) + FILE * file; + XkbFileInfo * result; + XkbChangesPtr changes; +#endif +{ +register unsigned i,n; +unsigned num_types; +int nRead=0; +int tmp; +XkbKeyTypePtr type; +xkmKeyTypeDesc wire; +XkbKTMapEntryPtr entry; +xkmKTMapEntryDesc wire_entry; +char buf[100]; +XkbDescPtr xkb; + + xkb= result->xkb; + if ((tmp= XkmGetCountedString(file,buf,100))<1) { + _XkbLibError(_XkbErrBadLength,"ReadXkmKeyTypes",0); + return -1; + } + nRead+= tmp; + if (buf[0]!='\0') { + if (XkbAllocNames(xkb,XkbTypesNameMask,0,0)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"ReadXkmKeyTypes",0); + return -1; + } + xkb->names->types= XkbInternAtom(xkb->dpy,buf,False); + } + num_types= XkmGetCARD16(file,&nRead); + nRead+= XkmSkipPadding(file,2); + if (num_types<1) + return nRead; + if (XkbAllocClientMap(xkb,XkbKeyTypesMask,num_types)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"ReadXkmKeyTypes",0); + return nRead; + } + xkb->map->num_types= num_types; + if (num_typesmap->types; + for (i=0;imap,type->map_count,&tmp,XkbKTMapEntryRec); + if ((wire.nMapEntries>0)&&(type->map==NULL)) { + _XkbLibError(_XkbErrBadValue,"ReadXkmKeyTypes",wire.nMapEntries); + return -1; + } + for (n=0,entry= type->map;nactive= (wire_entry.virtualMods==0); + entry->level= wire_entry.level; + entry->mods.mask= wire_entry.realMods; + entry->mods.real_mods= wire_entry.realMods; + entry->mods.vmods= wire_entry.virtualMods; + } + nRead+= XkmGetCountedString(file,buf,100); + if (((i==XkbOneLevelIndex)&&(strcmp(buf,"ONE_LEVEL")!=0))|| + ((i==XkbTwoLevelIndex)&&(strcmp(buf,"TWO_LEVEL")!=0))|| + ((i==XkbAlphabeticIndex)&&(strcmp(buf,"ALPHABETIC")!=0))|| + ((i==XkbKeypadIndex)&&(strcmp(buf,"KEYPAD")!=0))) { + _XkbLibError(_XkbErrBadTypeName,"ReadXkmKeyTypes",0); + return -1; + } + if (buf[0]!='\0') { + type->name= XkbInternAtom(xkb->dpy,buf,False); + } + else type->name= None; + + if (wire.preserve) { + xkmModsDesc p_entry; + XkbModsPtr pre; + XkmInsureTypedSize(type->preserve,type->map_count,&tmp, + XkbModsRec); + if (type->preserve==NULL) { + _XkbLibError(_XkbErrBadMatch,"ReadXkmKeycodes",0); + return -1; + } + for (n=0,pre=type->preserve;nmask= p_entry.realMods; + pre->real_mods= p_entry.realMods; + pre->vmods= p_entry.virtualMods; + } + } + if (wire.nLevelNames>0) { + int width= wire.numLevels; + if (wire.nLevelNames>(unsigned)width) { + _XkbLibError(_XkbErrBadMatch,"ReadXkmKeycodes",0); + return -1; + } + XkmInsureTypedSize(type->level_names,type->num_levels,&width,Atom); + if (type->level_names!=NULL) { + for (n=0;nlevel_names[n]= None; + else type->level_names[n]= XkbInternAtom(xkb->dpy,buf,0); + } + } + } + type->mods.mask= wire.realMods; + type->mods.real_mods= wire.realMods; + type->mods.vmods= wire.virtualMods; + type->num_levels= wire.numLevels; + type->map_count= wire.nMapEntries; + } + if (changes) { + changes->map.changed|= XkbKeyTypesMask; + changes->map.first_type= 0; + changes->map.num_types= xkb->map->num_types; + } + return nRead; +} + +/***====================================================================***/ + +static int +#if NeedFunctionPrototypes +ReadXkmCompatMap(FILE *file,XkbFileInfo *result,XkbChangesPtr changes) +#else +ReadXkmCompatMap(file,result,changes) + FILE * file; + XkbFileInfo * result; + XkbChangesPtr changes; +#endif +{ +register int i; +unsigned num_si,groups; +char name[100]; +XkbSymInterpretPtr interp; +xkmSymInterpretDesc wire; +unsigned tmp; +int nRead=0; +XkbDescPtr xkb; +XkbCompatMapPtr compat; + + xkb= result->xkb; + if ((tmp= XkmGetCountedString(file,name,100))<1) { + _XkbLibError(_XkbErrBadLength,"ReadXkmCompatMap",0); + return -1; + } + nRead+= tmp; + if (name[0]!='\0') { + if (XkbAllocNames(xkb,XkbCompatNameMask,0,0)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"ReadXkmCompatMap",0); + return -1; + } + xkb->names->compat= XkbInternAtom(xkb->dpy,name,False); + } + num_si= XkmGetCARD16(file,&nRead); + groups= XkmGetCARD8(file,&nRead); + nRead+= XkmSkipPadding(file,1); + if (XkbAllocCompatMap(xkb,XkbAllCompatMask,num_si)!=Success) + return -1; + compat= xkb->compat; + compat->num_si= num_si; + interp= compat->sym_interpret; + for (i=0;isym= wire.sym; + interp->mods= wire.mods; + interp->match= wire.match; + interp->virtual_mod= wire.virtualMod; + interp->flags= wire.flags; + interp->act.type= wire.actionType; + interp->act.data[0]= wire.actionData[0]; + interp->act.data[1]= wire.actionData[1]; + interp->act.data[2]= wire.actionData[2]; + interp->act.data[3]= wire.actionData[3]; + interp->act.data[4]= wire.actionData[4]; + interp->act.data[5]= wire.actionData[5]; + interp->act.data[6]= wire.actionData[6]; + } + if ((num_si>0)&&(changes)) { + changes->compat.first_si= 0; + changes->compat.num_si= num_si; + } + if (groups) { + register unsigned bit; + for (i=0,bit=1;icompat->groups[i].real_mods= md.realMods; + xkb->compat->groups[i].vmods= md.virtualMods; + if (md.virtualMods != 0) { + unsigned mask; + if (XkbVirtualModsToReal(xkb,md.virtualMods,&mask)) + xkb->compat->groups[i].mask= md.realMods|mask; + } + else xkb->compat->groups[i].mask= md.realMods; + } + } + if (changes) + changes->compat.changed_groups|= groups; + } + return nRead; +} + +static int +#if NeedFunctionPrototypes +ReadXkmIndicators(FILE *file,XkbFileInfo *result,XkbChangesPtr changes) +#else +ReadXkmIndicators(file,result,changes) + FILE * file; + XkbFileInfo * result; + XkbChangesPtr changes; +#endif +{ +register unsigned nLEDs; +xkmIndicatorMapDesc wire; +char buf[100]; +unsigned tmp; +int nRead=0; +XkbDescPtr xkb; + + xkb= result->xkb; + if ((xkb->indicators==NULL)&&(XkbAllocIndicatorMaps(xkb)!=Success)) { + _XkbLibError(_XkbErrBadAlloc,"indicator rec",0); + return -1; + } + if (XkbAllocNames(xkb,XkbIndicatorNamesMask,0,0)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"indicator names",0); + return -1; + } + nLEDs= XkmGetCARD8(file,&nRead); + nRead+= XkmSkipPadding(file,3); + xkb->indicators->phys_indicators= XkmGetCARD32(file,&nRead); + while (nLEDs-->0) { + Atom name; + XkbIndicatorMapPtr map; + + if ((tmp=XkmGetCountedString(file,buf,100))<1) { + _XkbLibError(_XkbErrBadLength,"ReadXkmIndicators",0); + return -1; + } + nRead+= tmp; + if (buf[0]!='\0') + name= XkbInternAtom(xkb->dpy,buf,False); + else name= None; + if ((tmp=fread(&wire,SIZEOF(xkmIndicatorMapDesc),1,file))<1) { + _XkbLibError(_XkbErrBadLength,"ReadXkmIndicators",0); + return -1; + } + nRead+= tmp*SIZEOF(xkmIndicatorMapDesc); + if (xkb->names) { + xkb->names->indicators[wire.indicator-1]= name; + if (changes) + changes->names.changed_indicators|= (1<<(wire.indicator-1)); + } + map= &xkb->indicators->maps[wire.indicator-1]; + map->flags= wire.flags; + map->which_groups= wire.which_groups; + map->groups= wire.groups; + map->which_mods= wire.which_mods; + map->mods.mask= wire.real_mods; + map->mods.real_mods= wire.real_mods; + map->mods.vmods= wire.vmods; + map->ctrls= wire.ctrls; + } + return nRead; +} + +static XkbKeyTypePtr +#if NeedFunctionPrototypes +FindTypeForKey(XkbDescPtr xkb,Atom name,unsigned width,KeySym *syms) +#else +FindTypeForKey(xkb,name,width,syms) + XkbDescPtr xkb; + Atom name; + unsigned width; + KeySym * syms; +#endif +{ + if ((!xkb)||(!xkb->map)) + return NULL; + if (name!=None) { + register unsigned i; + for (i=0;imap->num_types;i++) { + if (xkb->map->types[i].name==name) { +#ifdef DEBUG + if (xkb->map->types[i].num_levels!=width) + fprintf(stderr,"Group width mismatch between key and type\n"); +#endif + return &xkb->map->types[i]; + } + } + } + if ((width<2)||((syms!=NULL)&&(syms[1]==NoSymbol))) + return &xkb->map->types[XkbOneLevelIndex]; + if (syms!=NULL) { + if (XkbKSIsLower(syms[0])&&XkbKSIsUpper(syms[1])) + return &xkb->map->types[XkbAlphabeticIndex]; + else if (XkbKSIsKeypad(syms[0])||XkbKSIsKeypad(syms[1])) + return &xkb->map->types[XkbKeypadIndex]; + } + return &xkb->map->types[XkbTwoLevelIndex]; +} + +static int +#if NeedFunctionPrototypes +ReadXkmSymbols(FILE *file,XkbFileInfo *result) +#else +ReadXkmSymbols(file,result) + FILE * file; + XkbFileInfo * result; +#endif +{ +register int i,g,s,totalVModMaps; +xkmKeySymMapDesc wireMap; +char buf[100]; +unsigned minKC,maxKC,groupNames,tmp; +int nRead=0; +XkbDescPtr xkb; + + xkb= result->xkb; + if ((tmp=XkmGetCountedString(file,buf,100))<1) + return -1; + nRead+= tmp; + minKC= XkmGetCARD8(file,&nRead); + maxKC= XkmGetCARD8(file,&nRead); + groupNames= XkmGetCARD8(file,&nRead); + totalVModMaps= XkmGetCARD8(file,&nRead); + if (XkbAllocNames(xkb, + XkbSymbolsNameMask|XkbPhysSymbolsNameMask|XkbGroupNamesMask, + 0,0)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"physical names",0); + return -1; + } + if ((buf[0]!='\0')&&(xkb->names)) { + Atom name; + name= XkbInternAtom(xkb->dpy,buf,0); + xkb->names->symbols= name; + xkb->names->phys_symbols= name; + } + for (i=0,g=1;inames)) { + Atom name; + name= XkbInternAtom(xkb->dpy,buf,0); + xkb->names->groups[i]= name; + } + else xkb->names->groups[i]= None; + } + } + if (XkbAllocServerMap(xkb,XkbAllServerInfoMask,0)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"server map",0); + return -1; + } + if (XkbAllocClientMap(xkb,XkbAllClientInfoMask,0)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"client map",0); + return -1; + } + if (XkbAllocControls(xkb,XkbAllControlsMask)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"controls",0); + return -1; + } + if ((xkb->map==NULL)||(xkb->server==NULL)) + return -1; + if (xkb->min_key_code<8) xkb->min_key_code= minKC; + if (xkb->max_key_code<8) xkb->max_key_code= maxKC; + if ((minKC>=8)&&(minKCmin_key_code)) + xkb->min_key_code= minKC; + if ((maxKC>=8)&&(maxKC>xkb->max_key_code)) { + _XkbLibError(_XkbErrBadValue,"keys in symbol map",maxKC); + return -1; + } + for (i=minKC;i<=(int)maxKC;i++) { + Atom typeName[XkbNumKbdGroups]; + XkbKeyTypePtr type[XkbNumKbdGroups]; + if ((tmp=fread(&wireMap,SIZEOF(xkmKeySymMapDesc),1,file))<1) { + _XkbLibError(_XkbErrBadLength,"ReadXkmSymbols",0); + return -1; + } + nRead+= tmp*SIZEOF(xkmKeySymMapDesc); + bzero((char *)typeName,XkbNumKbdGroups*sizeof(Atom)); + bzero((char *)type,XkbNumKbdGroups*sizeof(XkbKeyTypePtr)); + if (wireMap.flags&XkmKeyHasTypes) { + register int g; + for (g=0;g0)) { + typeName[g]= XkbInternAtom(xkb->dpy,buf,1); + nRead+= tmp; + } + type[g]=FindTypeForKey(xkb,typeName[g],wireMap.width,NULL); + if (type[g]==NULL) { + _XkbLibError(_XkbErrMissingTypes,"ReadXkmSymbols",0); + return -1; + } + if (typeName[g]==type[g]->name) + xkb->server->explicit[i]|= (1<ctrls->per_key_repeat[i/8]|= (1<<(i%8)); + xkb->server->explicit[i]|= XkbExplicitAutoRepeatMask; + } + else if (wireMap.flags&XkmNonRepeatingKey) { + xkb->ctrls->per_key_repeat[i/8]&= ~(1<<(i%8)); + xkb->server->explicit[i]|= XkbExplicitAutoRepeatMask; + } + xkb->map->modmap[i]= wireMap.modifier_map; + if (wireMap.num_groups>0) { + KeySym *sym; + int nSyms; + + if (wireMap.num_groups>xkb->ctrls->num_groups) + xkb->ctrls->num_groups= wireMap.num_groups; + nSyms= wireMap.num_groups*wireMap.width; + sym= XkbResizeKeySyms(xkb,i,nSyms); + if (!sym) + return -1; + for (s=0;sserver->explicit[i]|= XkbExplicitInterpretMask; + } + } + for (g=0;gserver->explicit[i]&(1<map->key_sym_map[i].kt_index[g]= type[g]-(&xkb->map->types[0]); + } + xkb->map->key_sym_map[i].group_info= wireMap.num_groups; + xkb->map->key_sym_map[i].width= wireMap.width; + if (wireMap.flags&XkmKeyHasBehavior) { + xkmBehaviorDesc b; + tmp= fread(&b,SIZEOF(xkmBehaviorDesc),1,file); + nRead+= tmp*SIZEOF(xkmBehaviorDesc); + xkb->server->behaviors[i].type= b.type; + xkb->server->behaviors[i].data= b.data; + xkb->server->explicit[i]|= XkbExplicitBehaviorMask; + } + } + if (totalVModMaps>0) { + xkmVModMapDesc v; + for (i=0;i0) + xkb->server->vmodmap[v.key]= v.vmods; + } + } + return nRead; +} + +static int +#if NeedFunctionPrototypes +ReadXkmGeomDoodad( + FILE * file, + Display * dpy, + XkbGeometryPtr geom, + XkbSectionPtr section) +#else +ReadXkmGeomDoodad(file,dpy,geom,section) + FILE * file; + Display * dpy; + XkbGeometryPtr geom; + XkbSectionPtr section; +#endif +{ +XkbDoodadPtr doodad; +xkmDoodadDesc doodadWire; +char buf[100]; +unsigned tmp; +int nRead=0; + + nRead+= XkmGetCountedString(file,buf,100); + tmp= fread(&doodadWire,SIZEOF(xkmDoodadDesc),1,file); + nRead+= SIZEOF(xkmDoodadDesc)*tmp; + doodad= XkbAddGeomDoodad(geom,section,XkbInternAtom(dpy,buf,False)); + if (!doodad) + return nRead; + doodad->any.type= doodadWire.any.type; + doodad->any.priority= doodadWire.any.priority; + doodad->any.top= doodadWire.any.top; + doodad->any.left= doodadWire.any.left; + switch (doodadWire.any.type) { + case XkbOutlineDoodad: + case XkbSolidDoodad: + doodad->shape.angle= doodadWire.shape.angle; + doodad->shape.color_ndx= doodadWire.shape.color_ndx; + doodad->shape.shape_ndx= doodadWire.shape.shape_ndx; + break; + case XkbTextDoodad: + doodad->text.angle= doodadWire.text.angle; + doodad->text.width= doodadWire.text.width; + doodad->text.height= doodadWire.text.height; + doodad->text.color_ndx= doodadWire.text.color_ndx; + nRead+= XkmGetCountedString(file,buf,100); + doodad->text.text= _XkbDupString(buf); + nRead+= XkmGetCountedString(file,buf,100); + doodad->text.font= _XkbDupString(buf); + break; + case XkbIndicatorDoodad: + doodad->indicator.shape_ndx= doodadWire.indicator.shape_ndx; + doodad->indicator.on_color_ndx= doodadWire.indicator.on_color_ndx; + doodad->indicator.off_color_ndx= doodadWire.indicator.off_color_ndx; + break; + case XkbLogoDoodad: + doodad->logo.angle= doodadWire.logo.angle; + doodad->logo.color_ndx= doodadWire.logo.color_ndx; + doodad->logo.shape_ndx= doodadWire.logo.shape_ndx; + nRead+= XkmGetCountedString(file,buf,100); + doodad->logo.logo_name= _XkbDupString(buf); + break; + default: + /* report error? */ + return nRead; + } + return nRead; +} + +static int +#if NeedFunctionPrototypes +ReadXkmGeomOverlay( FILE * file, + Display * dpy, + XkbGeometryPtr geom, + XkbSectionPtr section) +#else +ReadXkmGeomOverlay(file,dpy,geom,section) + FILE * file; + Display * dpy; + XkbGeometryPtr geom; + XkbSectionPtr section; +#endif +{ +char buf[100]; +unsigned tmp; +int nRead=0; +XkbOverlayPtr ol; +XkbOverlayRowPtr row; +xkmOverlayDesc olWire; +xkmOverlayRowDesc rowWire; +register int r; + + nRead+= XkmGetCountedString(file,buf,100); + tmp= fread(&olWire,SIZEOF(xkmOverlayDesc),1,file); + nRead+= tmp*SIZEOF(xkmOverlayDesc); + ol= XkbAddGeomOverlay(section,XkbInternAtom(dpy,buf,False), + olWire.num_rows); + if (!ol) + return nRead; + for (r=0;rkeys[k].over.name,keyWire.over,XkbKeyNameLength); + memcpy(row->keys[k].under.name,keyWire.under,XkbKeyNameLength); + } + row->num_keys= rowWire.num_keys; + } + return nRead; +} + +static int +#if NeedFunctionPrototypes +ReadXkmGeomSection( FILE * file, + Display * dpy, + XkbGeometryPtr geom) +#else +ReadXkmGeomSection(file,dpy,geom) + FILE * file; + Display * dpy; + XkbGeometryPtr geom; +#endif +{ +register int i; +XkbSectionPtr section; +xkmSectionDesc sectionWire; +unsigned tmp; +int nRead= 0; +char buf[100]; +Atom nameAtom; + + nRead+= XkmGetCountedString(file,buf,100); + nameAtom= XkbInternAtom(dpy,buf,False); + tmp= fread(§ionWire,SIZEOF(xkmSectionDesc),1,file); + nRead+= SIZEOF(xkmSectionDesc)*tmp; + section= XkbAddGeomSection(geom,nameAtom,sectionWire.num_rows, + sectionWire.num_doodads, + sectionWire.num_overlays); + if (!section) { + _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeomSection",0); + return nRead; + } + section->top= sectionWire.top; + section->left= sectionWire.left; + section->width= sectionWire.width; + section->height= sectionWire.height; + section->angle= sectionWire.angle; + section->priority= sectionWire.priority; + if (sectionWire.num_rows>0) { + register int k; + XkbRowPtr row; + xkmRowDesc rowWire; + XkbKeyPtr key; + xkmKeyDesc keyWire; + + for (i=0;itop= rowWire.top; + row->left= rowWire.left; + row->vertical= rowWire.vertical; + for (k=0;kname.name,keyWire.name,XkbKeyNameLength); + key->gap= keyWire.gap; + key->shape_ndx= keyWire.shape_ndx; + key->color_ndx= keyWire.color_ndx; + } + } + } + if (sectionWire.num_doodads>0) { + for (i=0;i0) { + for (i=0;ixkb,&sizes)!=Success) { + _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0); + return nRead; + } + geom= result->xkb->geom; + geom->name= XkbInternAtom(result->xkb->dpy,buf,False); + geom->width_mm= wireGeom.width_mm; + geom->height_mm= wireGeom.height_mm; + nRead+= XkmGetCountedString(file,buf,100); + geom->label_font= _XkbDupString(buf); + if (wireGeom.num_properties>0) { + char val[1024]; + for (i=0;i0) { + for (i=0;ibase_color= &geom->colors[wireGeom.base_color_ndx]; + geom->label_color= &geom->colors[wireGeom.label_color_ndx]; + if (wireGeom.num_shapes>0) { + XkbShapePtr shape; + xkmShapeDesc shapeWire; + Atom nameAtom; + for (i=0;ixkb->dpy,buf,False); + tmp= fread(&shapeWire,SIZEOF(xkmShapeDesc),1,file); + nRead+= tmp*SIZEOF(xkmShapeDesc); + shape= XkbAddGeomShape(geom,nameAtom,shapeWire.num_outlines); + if (!shape) { + _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0); + return nRead; + } + for (n=0;nnum_points= olWire.num_points; + ol->corner_radius= olWire.corner_radius; + for (p=0;ppoints[p].x= ptWire.x; + ol->points[p].y= ptWire.y; + if (ptWire.xbounds.x1) shape->bounds.x1= ptWire.x; + if (ptWire.x>shape->bounds.x2) shape->bounds.x2= ptWire.x; + if (ptWire.ybounds.y1) shape->bounds.y1= ptWire.y; + if (ptWire.y>shape->bounds.y2) shape->bounds.y2= ptWire.y; + } + } + if (shapeWire.primary_ndx!=XkbNoShape) + shape->primary= &shape->outlines[shapeWire.primary_ndx]; + if (shapeWire.approx_ndx!=XkbNoShape) + shape->approx= &shape->outlines[shapeWire.approx_ndx]; + } + } + if (wireGeom.num_sections>0) { + for (i=0;ixkb->dpy,geom); + nRead+= tmp; + if (tmp==0) + return nRead; + } + } + if (wireGeom.num_doodads>0) { + for (i=0;ixkb->dpy,geom,NULL); + nRead+= tmp; + if (tmp==0) + return nRead; + } + } + if ((wireGeom.num_key_aliases>0)&&(geom->key_aliases)) { + int sz= XkbKeyNameLength*2; + int num= wireGeom.num_key_aliases; + if (fread(geom->key_aliases,sz,num,file)!=num) { + _XkbLibError(_XkbErrBadLength,"ReadXkmGeometry",0); + return -1; + } + nRead+= (num*sz); + geom->num_key_aliases= num; + } + return nRead; +} + +Bool +#if NeedFunctionPrototypes +XkmProbe(FILE *file) +#else +XkmProbe(file) + FILE * file; +#endif +{ +unsigned hdr,tmp; +int nRead=0; + + hdr= (('x'<<24)|('k'<<16)|('m'<<8)|XkmFileVersion); + tmp= XkmGetCARD32(file,&nRead); + if (tmp!=hdr) { + if ((tmp&(~0xff))==(hdr&(~0xff))) { + _XkbLibError(_XkbErrBadFileVersion,"XkmProbe",tmp&0xff); + } + return 0; + } + return 1; +} + +Bool +#if NeedFunctionPrototypes +XkmReadTOC(FILE *file,xkmFileInfo* file_info,int max_toc,xkmSectionInfo *toc) +#else +XkmReadTOC(file,file_info,max_toc,toc) + FILE * file; + xkmFileInfo * file_info; + int max_toc; + xkmSectionInfo * toc; +#endif +{ +unsigned hdr,tmp; +int nRead=0; +unsigned i,size_toc; + + hdr= (('x'<<24)|('k'<<16)|('m'<<8)|XkmFileVersion); + tmp= XkmGetCARD32(file,&nRead); + if (tmp!=hdr) { + if ((tmp&(~0xff))==(hdr&(~0xff))) { + _XkbLibError(_XkbErrBadFileVersion,"XkmReadTOC",tmp&0xff); + } + else { + _XkbLibError(_XkbErrBadFileType,"XkmReadTOC",tmp); + } + return 0; + } + fread(file_info,SIZEOF(xkmFileInfo),1,file); + size_toc= file_info->num_toc; + if (size_toc>max_toc) { +#ifdef DEBUG + fprintf(stderr,"Warning! Too many TOC entries; last %d ignored\n", + size_toc-max_toc); +#endif + size_toc= max_toc; + } + for (i=0;inum_toc;i++) { + if (toc[i].type==type) + return &toc[i]; + } + return NULL; +} + +Bool +#if NeedFunctionPrototypes +XkmReadFileSection( FILE * file, + xkmSectionInfo * toc, + XkbFileInfo * result, + unsigned * loaded_rtrn) +#else +XkmReadFileSection(file,toc,result,loaded_rtrn) + FILE * file; + xkmSectionInfo * toc; + XkbFileInfo * result; + unsigned * loaded_rtrn; +#endif +{ +xkmSectionInfo tmpTOC; +int nRead; + + if ((!result)||(!result->xkb)) { + _XkbLibError(_XkbErrBadMatch,"XkmReadFileSection",0); + return 0; + } + fseek(file,toc->offset,SEEK_SET); + fread(&tmpTOC,SIZEOF(xkmSectionInfo),1,file); + nRead= SIZEOF(xkmSectionInfo); + if ((tmpTOC.type!=toc->type)||(tmpTOC.format!=toc->format)|| + (tmpTOC.size!=toc->size)||(tmpTOC.offset!=toc->offset)) { + _XkbLibError(_XkbErrIllegalContents,"XkmReadFileSection",0); + return 0; + } + switch (tmpTOC.type) { + case XkmVirtualModsIndex: + nRead+= ReadXkmVirtualMods(file,result,NULL); + if ((loaded_rtrn)&&(nRead>=0)) + *loaded_rtrn|= XkmVirtualModsMask; + break; + case XkmTypesIndex: + nRead+= ReadXkmKeyTypes(file,result,NULL); + if ((loaded_rtrn)&&(nRead>=0)) + *loaded_rtrn|= XkmTypesMask; + break; + case XkmCompatMapIndex: + nRead+= ReadXkmCompatMap(file,result,NULL); + if ((loaded_rtrn)&&(nRead>=0)) + *loaded_rtrn|= XkmCompatMapMask; + break; + case XkmKeyNamesIndex: + nRead+= ReadXkmKeycodes(file,result,NULL); + if ((loaded_rtrn)&&(nRead>=0)) + *loaded_rtrn|= XkmKeyNamesMask; + break; + case XkmSymbolsIndex: + nRead+= ReadXkmSymbols(file,result); + if ((loaded_rtrn)&&(nRead>=0)) + *loaded_rtrn|= XkmSymbolsMask; + break; + case XkmIndicatorsIndex: + nRead+= ReadXkmIndicators(file,result,NULL); + if ((loaded_rtrn)&&(nRead>=0)) + *loaded_rtrn|= XkmIndicatorsMask; + break; + case XkmGeometryIndex: + nRead+= ReadXkmGeometry(file,result); + if ((loaded_rtrn)&&(nRead>=0)) + *loaded_rtrn|= XkmGeometryMask; + break; + default: + _XkbLibError(_XkbErrBadImplementation, + XkbConfigText(tmpTOC.type,XkbMessage),0); + nRead= 0; + break; + } + if (nRead!=tmpTOC.size) { + _XkbLibError(_XkbErrBadLength,XkbConfigText(tmpTOC.type,XkbMessage), + nRead-tmpTOC.size); + return 0; + } + return (nRead>=0); +} + +char * +#if NeedFunctionPrototypes +XkmReadFileSectionName(FILE *file,xkmSectionInfo *toc) +#else +XkmReadFileSectionName(file,toc) + FILE * file; + xkmSectionInfo * toc; +#endif +{ +xkmSectionInfo tmpTOC; +char name[100]; + + if ((!file)||(!toc)) + return 0; + switch (toc->type) { + case XkmVirtualModsIndex: + case XkmIndicatorsIndex: + break; + case XkmTypesIndex: + case XkmCompatMapIndex: + case XkmKeyNamesIndex: + case XkmSymbolsIndex: + case XkmGeometryIndex: + fseek(file,toc->offset,SEEK_SET); + fread(&tmpTOC,SIZEOF(xkmSectionInfo),1,file); + if ((tmpTOC.type!=toc->type)||(tmpTOC.format!=toc->format)|| + (tmpTOC.size!=toc->size)||(tmpTOC.offset!=toc->offset)) { + _XkbLibError(_XkbErrIllegalContents,"XkmReadFileSectionName",0); + return 0; + } + if (XkmGetCountedString(file,name,100)>0) + return _XkbDupString(name); + break; + default: + _XkbLibError(_XkbErrBadImplementation, + XkbConfigText(tmpTOC.type,XkbMessage),0); + break; + } + return NULL; +} + +/***====================================================================***/ + +#define MAX_TOC 16 +unsigned +#if NeedFunctionPrototypes +XkmReadFile(FILE *file,unsigned need,unsigned want,XkbFileInfo *result) +#else +XkmReadFile(file,need,want,result) + FILE * file; + unsigned need; + unsigned want; + XkbFileInfo * result; +#endif +{ +register unsigned i; +xkmSectionInfo toc[MAX_TOC],tmpTOC; +xkmFileInfo fileInfo; +unsigned tmp,nRead=0; +unsigned which= need|want; + + if (!XkmReadTOC(file,&fileInfo,MAX_TOC,toc)) + return which; + if ((fileInfo.present&need)!=need) { + _XkbLibError(_XkbErrIllegalContents,"XkmReadFile", + need&(~fileInfo.present)); + return which; + } + result->type= fileInfo.type; + if (result->xkb==NULL) + result->xkb= XkbAllocKeyboard(); + for (i=0;i0) { + nRead+= tmp; + which&= ~(1<defined|= (1<