mirror of
git://git.code.sf.net/p/cdesktopenv/code
synced 2025-03-09 15:50:02 +00:00
6180 lines
139 KiB
C
6180 lines
139 KiB
C
/*
|
||
* CDE - Common Desktop Environment
|
||
*
|
||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||
*
|
||
* These libraries and programs are free software; you can
|
||
* redistribute them and/or modify them under the terms of the GNU
|
||
* Lesser General Public License as published by the Free Software
|
||
* Foundation; either version 2 of the License, or (at your option)
|
||
* any later version.
|
||
*
|
||
* These libraries and programs are distributed in the hope that
|
||
* they will be useful, but WITHOUT ANY WARRANTY; without even the
|
||
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||
* PURPOSE. See the GNU Lesser General Public License for more
|
||
* details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with these libraries and programs; if not, write
|
||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||
* Floor, Boston, MA 02110-1301 USA
|
||
*/
|
||
/*
|
||
* (c) Copyright 1989, 1990, 1991, 1992, 1993, 1994 OPEN SOFTWARE FOUNDATION, INC.
|
||
* ALL RIGHTS RESERVED
|
||
*/
|
||
/*
|
||
* Motif Release 1.2.4
|
||
*/
|
||
/*
|
||
* (c) Copyright 1987, 1988, 1989, 1990, 1993, 1994 Hewlett-Packard Company
|
||
* (c) Copyright 1993, 1994 International Business Machines Corp.
|
||
* (c) Copyright 1993, 1994 Sun Microsystems, Inc.
|
||
* (c) Copyright 1993, 1994 Novell, Inc.
|
||
*/
|
||
/*
|
||
* (c) Copyright 1987, 1988 DIGITAL EQUIPMENT CORPORATION */
|
||
/*
|
||
* (c) Copyright 1988 MASSACHUSETTS INSTITUTE OF TECHNOLOGY */
|
||
|
||
/*
|
||
* Included Files:
|
||
*/
|
||
|
||
#include "WmGlobal.h"
|
||
#include "WmResNames.h"
|
||
#include <Dt/UserMsg.h>
|
||
#include <Dt/Connect.h>
|
||
#include <Tt/tt_c.h>
|
||
#include "WmParse.h"
|
||
#include "WmParseP.h"
|
||
#include "WmPanelP.h"
|
||
#include "WmResource.h"
|
||
|
||
#include <codelibs/shellutils.h> /* shellscan */
|
||
|
||
#include <Xm/VirtKeysP.h>
|
||
#include <Xm/XmPrivate.h> /* _XmVirtKeysLoadFileBindings,
|
||
* _XmVirtKeysLoadFallbackBindings */
|
||
|
||
|
||
#include <X11/cursorfont.h>
|
||
#include <X11/keysym.h>
|
||
#include <X11/Xatom.h>
|
||
#include <ctype.h>
|
||
|
||
#include <locale.h>
|
||
|
||
#include <stdlib.h>
|
||
|
||
#include <Xm/XmP.h> /* for XmeGetHomeDirName */
|
||
#include <signal.h>
|
||
|
||
/* maximum string lengths */
|
||
|
||
#define MAX_KEYSYM_STRLEN 100
|
||
#define MAX_EVENTTYPE_STRLEN 20
|
||
#define MAX_MODIFIER_STRLEN 20
|
||
#define MAX_CONTEXT_STRLEN 20
|
||
#define MAX_GROUP_STRLEN 20
|
||
|
||
#define min(a,b) ((a)>(b) ? (b) : (a))
|
||
|
||
#define MAXLINE (MAXWMPATH+1)
|
||
|
||
#define MBBSIZ 4096
|
||
|
||
#define PARSE_MENU_ITEMS(pSD, mSpec) ParseMenuItems(pSD)
|
||
|
||
/*
|
||
* include extern functions
|
||
*/
|
||
#include "WmResParse.h"
|
||
#include "WmWrkspace.h"
|
||
#include "WmError.h"
|
||
#include "WmFunction.h"
|
||
#include "WmImage.h"
|
||
#include "WmXSMP.h"
|
||
|
||
# include <errno.h>
|
||
# ifdef X_NOT_STDC_ENV
|
||
extern int errno;
|
||
# endif
|
||
# define HOME_DT_WMRC "/.dt/dtwmrc"
|
||
# define LANG_DT_WMRC "/dtwmrc"
|
||
# define SYS_DT_WMRC CDE_CONFIGURATION_TOP "/sys.dtwmrc"
|
||
|
||
/*
|
||
* Global Variables And Tables:
|
||
*/
|
||
static char cfileName[MAXWMPATH+1];
|
||
#ifndef NO_MESSAGE_CATALOG
|
||
char * pWarningStringFile;
|
||
char * pWarningStringLine;
|
||
#else
|
||
char pWarningStringFile[] = "%s: %s on line %d of configuration file %s\n";
|
||
char pWarningStringLine[] = "%s: %s on line %d of specification string\n";
|
||
#endif
|
||
#define cfileP (wmGD.pWmPB->pFile)
|
||
#define parseP (wmGD.pWmPB->pchNext)
|
||
#define line (wmGD.pWmPB->pchLine)
|
||
#define linec (wmGD.pWmPB->lineNumber)
|
||
|
||
|
||
typedef struct {
|
||
char *name;
|
||
unsigned int mask;
|
||
} MaskTableEntry;
|
||
|
||
static MaskTableEntry modifierStrings[] = {
|
||
|
||
{"none", None},
|
||
{"ctrl", ControlMask},
|
||
{"shift", ShiftMask},
|
||
{"alt", Mod1Mask},
|
||
{"meta", Mod1Mask},
|
||
{"lock", LockMask},
|
||
{"mod1", Mod1Mask},
|
||
{"mod2", Mod2Mask},
|
||
{"mod3", Mod3Mask},
|
||
{"mod4", Mod4Mask},
|
||
{"mod5", Mod5Mask},
|
||
{NULL, 0},
|
||
};
|
||
|
||
#define ALT_INDEX 3
|
||
#define META_INDEX 4
|
||
|
||
typedef struct {
|
||
char *event;
|
||
unsigned int eventType;
|
||
Boolean (*parseProc)();
|
||
unsigned int closure;
|
||
Boolean fClick;
|
||
} EventTableEntry;
|
||
|
||
static String GetNetworkFileName (char *pchFile);
|
||
FILE *FopenConfigFile (void);
|
||
void SaveMenuAccelerators (WmScreenData *pSD, MenuSpec *newMenuSpec);
|
||
static void ParseMenuSet (WmScreenData *pSD, unsigned char *lineP);
|
||
MenuItem *ParseMwmMenuStr (WmScreenData *pSD, unsigned char *menuStr);
|
||
static MenuItem *ParseMenuItems (WmScreenData *pSD);
|
||
static Boolean ParseWmLabel (WmScreenData *pSD, MenuItem *menuItem,
|
||
unsigned char *string);
|
||
static void ParseWmMnemonic (unsigned char **linePP, MenuItem *menuItem);
|
||
static Boolean ParseWmAccelerator (unsigned char **linePP, MenuItem *menuItem);
|
||
int ParseWmFunction (unsigned char **linePP, unsigned int res_spec,
|
||
WmFunction *pWmFunction);
|
||
static Boolean ParseWmFuncNoArg (unsigned char **linePP, WmFunction wmFunction,
|
||
String *pArgs);
|
||
void FreeMenuItem (MenuItem *menuItem);
|
||
static Boolean ParseWmFuncGrpArg (unsigned char **linePP,
|
||
WmFunction wmFunction, GroupArg *pGroup);
|
||
static Boolean ParseWmFuncNbrArg (unsigned char **linePP,
|
||
WmFunction wmFunction,
|
||
unsigned long *pNumber);
|
||
void ParseButtonStr (WmScreenData *pSD, unsigned char *buttonStr);
|
||
static void ParseButtonSet (WmScreenData *pSD, unsigned char *lineP);
|
||
static Boolean ParseContext (unsigned char **linePP, Context *context,
|
||
Context *subContext);
|
||
void
|
||
ParseKeyStr (WmScreenData *pSD, unsigned char *keyStr);
|
||
static void ParseKeySet (WmScreenData *pSD, unsigned char *lineP);
|
||
Boolean ParseBtnEvent (unsigned char **linePP,
|
||
unsigned int *eventType,
|
||
unsigned int *button,
|
||
unsigned int *state,
|
||
Boolean *fClick);
|
||
Boolean ParseKeyEvent (unsigned char **linePP, unsigned int *eventType,
|
||
KeyCode *keyCode, unsigned int *state);
|
||
static Boolean ParseEvent (unsigned char **linePP, EventTableEntry *table,
|
||
unsigned int *eventType, unsigned int *detail,
|
||
unsigned int *state, Boolean *fClick);
|
||
static Boolean ParseModifiers(unsigned char **linePP, unsigned int *state);
|
||
static Boolean LookupModifier (unsigned char *name, unsigned int *valueP);
|
||
static Boolean ParseEventType (unsigned char **linePP, EventTableEntry *table,
|
||
unsigned int *eventType, Cardinal *ix);
|
||
static Boolean ParseImmed (unsigned char **linePP, unsigned int closure,
|
||
unsigned int *detail);
|
||
static Boolean ParseKeySym (unsigned char **linePP, unsigned int closure,
|
||
unsigned int *detail);
|
||
static unsigned int StrToNum(unsigned char *str);
|
||
static unsigned int StrToHex(unsigned char *str);
|
||
static unsigned int StrToOct(unsigned char *str);
|
||
void ScanAlphanumeric (unsigned char **linePP);
|
||
void ScanWhitespace(unsigned char **linePP);
|
||
void ToLower (char *string);
|
||
void
|
||
PWarning (char *message);
|
||
static void ProcessAccelText (unsigned char *startP, unsigned char *endP,
|
||
unsigned char *destP);
|
||
void ProcessCommandLine (int argc, char *argv[]);
|
||
static void ParseScreensArgument (int argc, char *argv[], int *pArgnum,
|
||
unsigned char *lineP);
|
||
void ProcessMotifBindings (void);
|
||
static void ParseIncludeSet (WmScreenData *pSD, unsigned char *lineP);
|
||
static void ConfigStackInit (char *pchFileName);
|
||
static FILE *ConfigStackPush (unsigned char *pchFileName);
|
||
static void ConfigStackPop (void);
|
||
Boolean ParseWmFuncActionArg (unsigned char **linePP,
|
||
WmFunction wmFunction, String *pArgs);
|
||
static void PreprocessConfigFile (void);
|
||
|
||
static EventTableEntry buttonEvents[] = {
|
||
|
||
{"btn1down", ButtonPress, ParseImmed, SELECT_BUTTON, FALSE},
|
||
{"btn1up", ButtonRelease, ParseImmed, SELECT_BUTTON, FALSE},
|
||
{"btn1click", ButtonRelease, ParseImmed, SELECT_BUTTON, TRUE},
|
||
{"btn1click2", ButtonPress, ParseImmed, SELECT_BUTTON, TRUE},
|
||
{"btn2down", ButtonPress, ParseImmed, DMANIP_BUTTON, FALSE},
|
||
{"btn2up", ButtonRelease, ParseImmed, DMANIP_BUTTON, FALSE},
|
||
{"btn2click", ButtonRelease, ParseImmed, DMANIP_BUTTON, TRUE},
|
||
{"btn2click2", ButtonPress, ParseImmed, DMANIP_BUTTON, TRUE},
|
||
{"btn3down", ButtonPress, ParseImmed, BMENU_BUTTON, FALSE},
|
||
{"btn3up", ButtonRelease, ParseImmed, BMENU_BUTTON, FALSE},
|
||
{"btn3click", ButtonRelease, ParseImmed, BMENU_BUTTON, TRUE},
|
||
{"btn3click2", ButtonPress, ParseImmed, BMENU_BUTTON, TRUE},
|
||
{"btn4down", ButtonPress, ParseImmed, Button4, FALSE},
|
||
{"btn4up", ButtonRelease, ParseImmed, Button4, FALSE},
|
||
{"btn4click", ButtonRelease, ParseImmed, Button4, TRUE},
|
||
{"btn4click2", ButtonPress, ParseImmed, Button4, TRUE},
|
||
{"btn5down", ButtonPress, ParseImmed, Button5, FALSE},
|
||
{"btn5up", ButtonRelease, ParseImmed, Button5, FALSE},
|
||
{"btn5click", ButtonRelease, ParseImmed, Button5, TRUE},
|
||
{"btn5click2", ButtonPress, ParseImmed, Button5, TRUE},
|
||
{ NULL, 0, (Boolean(*)())NULL, 0, FALSE}
|
||
};
|
||
|
||
|
||
static EventTableEntry keyEvents[] = {
|
||
|
||
{"key", KeyPress, ParseKeySym, 0, FALSE},
|
||
{ NULL, 0, (Boolean(*)())NULL, 0, FALSE}
|
||
};
|
||
|
||
typedef struct _ConfigFileStackEntry {
|
||
char *fileName;
|
||
char *tempName;
|
||
char *cppName;
|
||
char *wmgdConfigFile;
|
||
long offset;
|
||
DtWmpParseBuf *pWmPB;
|
||
struct _ConfigFileStackEntry *pIncluder;
|
||
|
||
} ConfigFileStackEntry;
|
||
|
||
static ConfigFileStackEntry *pConfigStack = NULL;
|
||
static ConfigFileStackEntry *pConfigStackTop = NULL;
|
||
|
||
|
||
unsigned int buttonModifierMasks[] = {
|
||
0,
|
||
SELECT_BUTTON_MASK,
|
||
DMANIP_BUTTON_MASK,
|
||
BMENU_BUTTON_MASK,
|
||
Button4Mask,
|
||
Button5Mask
|
||
};
|
||
|
||
/*
|
||
* FUNCTION PARSER TABLE (function names must be in alphabetic order)
|
||
*/
|
||
|
||
typedef struct {
|
||
char * funcName;
|
||
Context greyedContext;
|
||
unsigned int resource;
|
||
long mgtMask;
|
||
WmFunction wmFunction;
|
||
Boolean (*parseProc)();
|
||
} FunctionTableEntry;
|
||
|
||
|
||
/*
|
||
* NOTE: New functions MUST be added in ALPHABETICAL order. A binary search
|
||
* is used to find the correct function name.
|
||
*/
|
||
|
||
FunctionTableEntry functionTable[] = {
|
||
{"f.action", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Action,
|
||
ParseWmFuncActionArg},
|
||
{"f.beep", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Beep,
|
||
ParseWmFuncNoArg},
|
||
{"f.circle_down", F_SUBCONTEXT_IB_IICON|F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Circle_Down,
|
||
ParseWmFuncGrpArg},
|
||
{"f.circle_up", F_SUBCONTEXT_IB_IICON|F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Circle_Up,
|
||
ParseWmFuncGrpArg},
|
||
{"f.create_workspace", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_CreateWorkspace,
|
||
ParseWmFuncNoArg},
|
||
{"f.delete_workspace", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_DeleteWorkspace,
|
||
ParseWmFuncNoArg},
|
||
{"f.exec", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Exec,
|
||
ParseWmFuncStrArg},
|
||
{"f.focus_color", F_SUBCONTEXT_IB_IICON|F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Focus_Color,
|
||
ParseWmFuncNoArg},
|
||
{"f.focus_key", F_SUBCONTEXT_IB_IICON|F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Focus_Key,
|
||
ParseWmFuncNoArg},
|
||
{"f.goto_workspace", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Goto_Workspace,
|
||
ParseWmFuncStrArg},
|
||
{"f.help", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Help,
|
||
ParseWmFuncStrArg}, /* [helpvolume && helptopic] */
|
||
{"f.help_mode", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Help_Mode,
|
||
ParseWmFuncNoArg}, /* for now */
|
||
{"f.kill", F_CONTEXT_ROOT,
|
||
CRS_ANY,
|
||
MWM_FUNC_CLOSE,
|
||
F_Kill,
|
||
ParseWmFuncNoArg},
|
||
{"f.lower", F_SUBCONTEXT_IB_IICON|F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Lower,
|
||
ParseWmFuncMaybeStrArg},
|
||
{"f.marquee_selection",
|
||
F_CONTEXT_WINDOW|F_CONTEXT_ICON|F_SUBCONTEXT_IB_IICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Marquee_Selection,
|
||
ParseWmFuncNoArg},
|
||
{"f.maximize", F_CONTEXT_ROOT|F_CONTEXT_MAXIMIZE|
|
||
F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
MWM_FUNC_MAXIMIZE,
|
||
F_Maximize,
|
||
ParseWmFuncNoArg},
|
||
{"f.menu", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Menu,
|
||
ParseWmFuncStrArg},
|
||
{"f.minimize", F_CONTEXT_ICON|F_CONTEXT_ROOT|F_SUBCONTEXT_IB_IICON,
|
||
CRS_ANY,
|
||
MWM_FUNC_MINIMIZE,
|
||
F_Minimize,
|
||
ParseWmFuncNoArg},
|
||
{"f.move", F_CONTEXT_ROOT,
|
||
CRS_ANY,
|
||
MWM_FUNC_MOVE,
|
||
F_Move,
|
||
ParseWmFuncNoArg},
|
||
{"f.next_cmap", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Next_Cmap,
|
||
ParseWmFuncNoArg},
|
||
{"f.next_key", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Next_Key,
|
||
ParseWmFuncGrpArg},
|
||
{"f.next_workspace", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Next_Workspace,
|
||
ParseWmFuncNoArg},
|
||
{"f.nop", F_CONTEXT_ROOT|F_CONTEXT_ICON|F_CONTEXT_WINDOW|
|
||
F_SUBCONTEXT_IB_WICON | F_SUBCONTEXT_IB_IICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Nop,
|
||
ParseWmFuncNoArg},
|
||
{"f.normalize", F_CONTEXT_ROOT|F_CONTEXT_NORMAL|F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Normalize,
|
||
ParseWmFuncNoArg},
|
||
{"f.normalize_and_raise",
|
||
F_CONTEXT_ROOT|F_CONTEXT_NORMAL,
|
||
CRS_ANY,
|
||
0,
|
||
F_Normalize_And_Raise,
|
||
ParseWmFuncMaybeStrArg},
|
||
{"f.occupy_all", F_CONTEXT_ICONBOX|F_CONTEXT_ROOT,
|
||
CRS_ANY,
|
||
DtWM_FUNC_OCCUPY_WS,
|
||
F_AddToAllWorkspaces,
|
||
ParseWmFuncNoArg},
|
||
{"f.pack_icons", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Pack_Icons,
|
||
ParseWmFuncNoArg},
|
||
{"f.pass_keys", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Pass_Key,
|
||
ParseWmFuncNoArg},
|
||
{"f.post_wmenu", 0,
|
||
CRS_BUTTON|CRS_KEY,
|
||
0,
|
||
F_Post_SMenu,
|
||
ParseWmFuncNoArg},
|
||
{"f.prev_cmap", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Prev_Cmap,
|
||
ParseWmFuncNoArg},
|
||
{"f.prev_key", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Prev_Key,
|
||
ParseWmFuncGrpArg},
|
||
{"f.prev_workspace", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Prev_Workspace,
|
||
ParseWmFuncNoArg},
|
||
{"f.quit_mwm", F_CONTEXT_ICON|F_CONTEXT_WINDOW,
|
||
CRS_ANY,
|
||
0,
|
||
F_Quit_Mwm,
|
||
ParseWmFuncNoArg},
|
||
{"f.raise", F_SUBCONTEXT_IB_IICON|F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Raise,
|
||
ParseWmFuncMaybeStrArg},
|
||
{"f.raise_lower", F_CONTEXT_ROOT |
|
||
F_SUBCONTEXT_IB_IICON|F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Raise_Lower,
|
||
ParseWmFuncNoArg},
|
||
{"f.refresh", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Refresh,
|
||
ParseWmFuncNoArg},
|
||
{"f.refresh_win", F_CONTEXT_ICON|F_CONTEXT_ROOT,
|
||
CRS_ANY,
|
||
0,
|
||
F_Refresh_Win,
|
||
ParseWmFuncNoArg},
|
||
{"f.remove", F_CONTEXT_ROOT,
|
||
CRS_ANY,
|
||
DtWM_FUNC_OCCUPY_WS,
|
||
F_Remove,
|
||
ParseWmFuncNoArg},
|
||
{"f.resize", F_CONTEXT_ICON|F_CONTEXT_ROOT|
|
||
F_SUBCONTEXT_IB_IICON|F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
MWM_FUNC_RESIZE,
|
||
F_Resize,
|
||
ParseWmFuncNoArg},
|
||
{"f.restart", F_CONTEXT_ICON|F_CONTEXT_WINDOW,
|
||
CRS_ANY,
|
||
0,
|
||
F_Restart,
|
||
ParseWmFuncStrArg},
|
||
{"f.restore", F_CONTEXT_ROOT|F_CONTEXT_NORMAL|F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
0,
|
||
F_Restore,
|
||
ParseWmFuncNoArg},
|
||
{"f.restore_and_raise",
|
||
F_CONTEXT_ROOT|F_CONTEXT_NORMAL,
|
||
CRS_ANY,
|
||
0,
|
||
F_Restore_And_Raise,
|
||
ParseWmFuncNoArg},
|
||
{"f.screen", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Screen,
|
||
ParseWmFuncStrArg},
|
||
{"f.send_msg", F_CONTEXT_ROOT,
|
||
CRS_ANY,
|
||
0,
|
||
F_Send_Msg,
|
||
ParseWmFuncNbrArg},
|
||
{"f.separator", 0,
|
||
CRS_MENU,
|
||
0,
|
||
F_Separator,
|
||
ParseWmFuncNoArg},
|
||
{"f.set_behavior", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Set_Behavior,
|
||
ParseWmFuncNoArg},
|
||
{"f.set_context", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Set_Context,
|
||
ParseWmFuncNbrArg},
|
||
{"f.title", 0,
|
||
CRS_MENU,
|
||
0,
|
||
F_Title,
|
||
ParseWmFuncNoArg},
|
||
{"f.toggle_frontpanel", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Toggle_Front_Panel,
|
||
ParseWmFuncNoArg},
|
||
|
||
{"f.version", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_Version,
|
||
ParseWmFuncNoArg},
|
||
|
||
#ifdef OLD
|
||
{"f.workspace_presence",F_CONTEXT_ICON|F_CONTEXT_ROOT|F_CONTEXT_ICONBOX|
|
||
F_SUBCONTEXT_IB_IICON|F_SUBCONTEXT_IB_WICON,
|
||
#endif /* OLD */
|
||
{"f.workspace_presence", F_CONTEXT_ROOT|F_CONTEXT_ICONBOX|
|
||
F_SUBCONTEXT_IB_WICON,
|
||
CRS_ANY,
|
||
DtWM_FUNC_OCCUPY_WS,
|
||
F_Workspace_Presence,
|
||
ParseWmFuncNoArg},
|
||
#if defined(DEBUG)
|
||
{"f.zz_debug", 0,
|
||
CRS_ANY,
|
||
0,
|
||
F_ZZ_Debug,
|
||
ParseWmFuncStrArg},
|
||
#endif /* DEBUG */
|
||
};
|
||
|
||
/*
|
||
* NOTE: New functions MUST be added in ALPHABETICAL order. A binary search
|
||
* is used to find the correct function name.
|
||
*/
|
||
|
||
#define WMFUNCTIONTABLESIZE (sizeof(functionTable)/sizeof(functionTable[0]))
|
||
|
||
/*
|
||
* Be sure to update these define, whenever adding/deleting a function.
|
||
*/
|
||
int F_ACTION_INDEX;
|
||
int F_EXEC_INDEX;
|
||
int F_NOP_INDEX;
|
||
|
||
/******************************<->*************************************
|
||
*
|
||
* void GetFunctionTableValues (int *execIndex, int *nopIndex,
|
||
* int *actionIndex)
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This routine dynamically computes the size of the functionTable[],
|
||
* and the indices for key functions, such as f.exec, f.action, and
|
||
* f.nop
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* We are setting the values of F_EXEC_INDEX, F_ACTION_INDEX,
|
||
* and F_NOP_INDEX on a global level. The addresses
|
||
* for same are passed in.
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* This routine calls smaller routines for efficiency sake.
|
||
*
|
||
******************************<->***********************************/
|
||
void
|
||
GetFunctionTableValues (int *execIndex, int *nopIndex,
|
||
int *actionIndex)
|
||
{
|
||
|
||
GetExecIndex (WMFUNCTIONTABLESIZE, execIndex);
|
||
|
||
GetActionIndex (WMFUNCTIONTABLESIZE, actionIndex);
|
||
|
||
GetNopIndex (WMFUNCTIONTABLESIZE, nopIndex);
|
||
|
||
} /* END OF FUNCTION GetFunctionTableValues */
|
||
|
||
|
||
|
||
/******************************<->*************************************
|
||
*
|
||
|
||
*
|
||
* Description:
|
||
* -----------
|
||
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
******************************<->***********************************/
|
||
|
||
void
|
||
GetExecIndex (int tableSize, int *execIndex)
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < (tableSize); i++)
|
||
{
|
||
if (!(strcmp ("f.exec", functionTable[i].funcName)))
|
||
{
|
||
*execIndex = i;
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
*execIndex = 0;
|
||
}
|
||
}
|
||
} /* END OF FUNCTION GetExecIndex */
|
||
|
||
|
||
/******************************<->*************************************
|
||
*
|
||
|
||
*
|
||
* Description:
|
||
* -----------
|
||
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
******************************<->***********************************/
|
||
|
||
|
||
void
|
||
GetActionIndex (int tableSize, int *actionIndex)
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < (tableSize); i++)
|
||
{
|
||
if (!(strcmp ("f.action", functionTable[i].funcName)))
|
||
{
|
||
*actionIndex = i;
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
*actionIndex = 0;
|
||
}
|
||
}
|
||
} /* END OF FUNCTION GetActionIndex */
|
||
|
||
|
||
|
||
/******************************<->*************************************
|
||
*
|
||
|
||
*
|
||
* Description:
|
||
* -----------
|
||
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
******************************<->***********************************/
|
||
void
|
||
GetNopIndex (int tableSize, int *nopIndex)
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < (tableSize); i++)
|
||
{
|
||
if (!(strcmp ("f.nop", functionTable[i].funcName)))
|
||
{
|
||
*nopIndex = i;
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
*nopIndex = 0;
|
||
}
|
||
}
|
||
} /* END OF FUNCTION GetNopIndex */
|
||
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* void
|
||
* WmDtGetHelpArgs ()
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Get Help Args
|
||
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
void
|
||
WmDtGetHelpArgs(char *args,
|
||
unsigned char* volume,
|
||
unsigned char* topic,
|
||
int *argsCount)
|
||
{
|
||
unsigned char *string;
|
||
unsigned char *lineP;
|
||
|
||
cfileP = NULL;
|
||
linec = 0;
|
||
parseP = (unsigned char*) args;
|
||
|
||
if(GetNextLine () != NULL)
|
||
{
|
||
*argsCount = 0;
|
||
lineP = line;
|
||
if ((string = GetSmartSMString (&lineP)) != NULL)
|
||
{
|
||
*argsCount = *argsCount + 1;
|
||
strcpy ((char*)topic, (char*)string);
|
||
}
|
||
|
||
if ((string = GetSmartSMString (&lineP)) != NULL)
|
||
{
|
||
*argsCount = *argsCount + 1;
|
||
strcpy ((char*)volume, (char *)string);
|
||
}
|
||
}
|
||
|
||
} /* END OF FUNCTION WmDtGetHelpArgs */
|
||
|
||
|
||
|
||
|
||
|
||
/******************************<->*************************************
|
||
*
|
||
* void
|
||
* ParseDtSessionHints (pSD, property)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function parses a DtSessionHints string and returns a list of
|
||
* DtSessionItems array. The string should have the syntax:
|
||
*
|
||
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* line = (global) line buffer
|
||
* pSD->rootWindow = default root window of display
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* Return =
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
void
|
||
ParseDtSessionHints (WmScreenData *pSD, unsigned char *property)
|
||
{
|
||
|
||
cfileP = NULL;
|
||
linec = 0;
|
||
parseP = property;
|
||
|
||
ParseSessionItems (pSD);
|
||
|
||
} /* END OF FUNCTION ParseDtSessionHints */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* FindDtSessionMatch(commandArgc, commandArgv, pCD, pSD, pWorkSpaceList,
|
||
* clientMachine)
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Try to find a match for this client in the session hints.
|
||
* Set up client-session data.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* commandArgc - argument count
|
||
* commandArgv - WM_COMMAND argument vector
|
||
* pCD - pointer to client data
|
||
* pSD - pointer to screen data
|
||
* pWorkspaceList - pointer to a list of workspaces (to be returned)
|
||
* clientMachine - string for -host option in session hints
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* *pCD - client data (may be modified)
|
||
* FindDtSessionMatch - returns True if a match for this client
|
||
* was found in the session hints.
|
||
* *pWorkspaceList - list of workspaces this client should be put
|
||
* into. (needs to be freed)
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* Various pieces of client state (in pCD) are reset when a match
|
||
* is found.
|
||
*
|
||
* The caller must free *pWorkspaceList when done.
|
||
*
|
||
*************************************<->***********************************/
|
||
Boolean FindDtSessionMatch(int commandArgc, char **commandArgv,
|
||
ClientData *pCD, WmScreenData *pSD,
|
||
char **pWorkSpaceList, char *clientMachine)
|
||
|
||
{
|
||
int count;
|
||
int relCount;
|
||
int argNum;
|
||
SessionGeom *sessionGeom;
|
||
|
||
|
||
for (count = 0; count < pSD->totalSessionItems; count++)
|
||
{
|
||
if (!pSD->pDtSessionItems[count].processed &&
|
||
pSD->pDtSessionItems[count].commandArgc == commandArgc)
|
||
{
|
||
if ((clientMachine) &&
|
||
(pSD->pDtSessionItems[count].clientMachine) &&
|
||
(strcmp(clientMachine,
|
||
pSD->pDtSessionItems[count].clientMachine)))
|
||
{
|
||
/*
|
||
* This item has clientMachine string but the
|
||
* clientMachine does not match.
|
||
*/
|
||
continue;
|
||
}
|
||
for (argNum = 0; argNum < commandArgc ; argNum++)
|
||
{
|
||
if(strcmp(commandArgv[argNum],
|
||
pSD->pDtSessionItems[count].commandArgv[argNum]))
|
||
|
||
{
|
||
/*
|
||
* One mismatch and we quit looking at this item.
|
||
* Decrement argNum so a mismatch on the last item
|
||
* will not look like a match below when comparing
|
||
* argNum == commandArgc
|
||
*/
|
||
argNum--;
|
||
break;
|
||
}
|
||
}
|
||
if (argNum == commandArgc)
|
||
{
|
||
/*
|
||
* Made it through all strings so this is a match
|
||
*/
|
||
|
||
pSD->pDtSessionItems[count].processed = True;
|
||
pSD->remainingSessionItems --;
|
||
pCD->clientFlags |= SM_LAUNCHED;
|
||
|
||
/*
|
||
* Free strings malloc'd for commandArgv for this item
|
||
*/
|
||
|
||
for (relCount = 0; relCount < commandArgc; relCount++)
|
||
{
|
||
XtFree(pSD->pDtSessionItems[count].commandArgv[relCount]);
|
||
}
|
||
XtFree((char *)pSD->pDtSessionItems[count].commandArgv);
|
||
|
||
if(pSD->pDtSessionItems[count].clientState)
|
||
{
|
||
pCD->clientState =
|
||
pSD->pDtSessionItems[count].clientState;
|
||
pCD->clientFlags |= SM_CLIENT_STATE;
|
||
}
|
||
|
||
if(pSD->pDtSessionItems[count].sessionGeom)
|
||
{
|
||
sessionGeom = pSD->pDtSessionItems[count].sessionGeom;
|
||
if (sessionGeom->flags & XValue)
|
||
{
|
||
pCD->clientX = sessionGeom->clientX;
|
||
pCD->clientFlags |= SM_X;
|
||
}
|
||
if (sessionGeom->flags & YValue)
|
||
{
|
||
pCD->clientY = sessionGeom->clientY;
|
||
pCD->clientFlags |= SM_Y;
|
||
}
|
||
if (sessionGeom->flags & WidthValue)
|
||
{
|
||
pCD->clientWidth = sessionGeom->clientWidth;
|
||
pCD->clientFlags |= SM_WIDTH;
|
||
}
|
||
if (sessionGeom->flags & HeightValue)
|
||
{
|
||
pCD->clientHeight = sessionGeom->clientHeight;
|
||
pCD->clientFlags |= SM_HEIGHT;
|
||
}
|
||
|
||
/*
|
||
* Free SessionGeom malloc'd space for this item
|
||
*/
|
||
|
||
XtFree((char *)pSD->pDtSessionItems[count].sessionGeom);
|
||
}
|
||
|
||
if(pSD->pDtSessionItems[count].clientMachine)
|
||
{
|
||
/*
|
||
* Free clientMachine malloc'd space for this item
|
||
*/
|
||
|
||
XtFree((char *)
|
||
pSD->pDtSessionItems[count].clientMachine);
|
||
pSD->pDtSessionItems[count].clientMachine = NULL;
|
||
}
|
||
|
||
|
||
if(pSD->pDtSessionItems[count].workspaces)
|
||
{
|
||
/*
|
||
* The caller is responsible for freeing this
|
||
* data.
|
||
*/
|
||
*pWorkSpaceList = pSD->pDtSessionItems[count].workspaces;
|
||
}
|
||
|
||
|
||
if(pSD->remainingSessionItems == 0)
|
||
{
|
||
/*
|
||
* Free the whole pSD->pDtSessionHints structure
|
||
*/
|
||
XtFree((char *)pSD->pDtSessionItems);
|
||
}
|
||
|
||
return (True);
|
||
}
|
||
|
||
} /* not processed and argc's are the same */
|
||
|
||
} /* for */
|
||
|
||
return (False);
|
||
|
||
} /* END OF FUNCTION FindDtSessionMatch */
|
||
|
||
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* void
|
||
* ParseSessionItems (pSD)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parse session items
|
||
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pSD = pointer to screen data
|
||
* cfileP = (global) file pointer to NULL
|
||
* line = (global) line buffer
|
||
* linec = (global) line count
|
||
* parseP = (global) parse string pointer if cfileP == NULL
|
||
* pSD->rootWindow = default root window of display
|
||
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linec = (global) line count incremented
|
||
* parseP = (global) parse string pointer if cfileP == NULL
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
void
|
||
ParseSessionItems (WmScreenData *pSD)
|
||
{
|
||
unsigned char *string;
|
||
unsigned char *lineP;
|
||
int count;
|
||
|
||
|
||
/*
|
||
* Parse property string
|
||
*/
|
||
|
||
|
||
|
||
if(GetNextLine () != NULL)
|
||
{
|
||
pSD->totalSessionItems = atoi((char *)line);
|
||
pSD->remainingSessionItems = pSD->totalSessionItems;
|
||
}
|
||
|
||
|
||
if((pSD->totalSessionItems < 1) ||
|
||
!GetSessionHintsInfo(pSD, pSD->totalSessionItems))
|
||
{
|
||
/*
|
||
* No items or couldn't allocate space
|
||
*/
|
||
return;
|
||
}
|
||
|
||
count = 0;
|
||
|
||
while ((count < pSD->totalSessionItems) && (GetNextLine () != NULL))
|
||
{
|
||
|
||
lineP = line;
|
||
while ((string = GetSmartSMString (&lineP)) != NULL)
|
||
{
|
||
if (!strcmp((char *)string, "-geometry"))
|
||
{
|
||
/*
|
||
* Parse geometry if it is present
|
||
*/
|
||
string = GetSmartSMString(&lineP);
|
||
ParseSessionGeometry (pSD, count, string);
|
||
}
|
||
|
||
else if (!strcmp((char *)string, "-state"))
|
||
{
|
||
/*
|
||
* Parse the state if it is present
|
||
*/
|
||
string = GetSmartSMString(&lineP);
|
||
ParseSessionClientState (pSD, count, string);
|
||
}
|
||
|
||
else if (!strcmp((char *)string, "-workspaces"))
|
||
{
|
||
/*
|
||
* Parse the workspaces string if it is present
|
||
*/
|
||
string = GetSmartSMString(&lineP);
|
||
ParseSessionWorkspaces (pSD, count, string);
|
||
}
|
||
|
||
else if (!strcmp((char *)string, "-cmd"))
|
||
{
|
||
/*
|
||
* Parse the command string if it is present
|
||
*/
|
||
string = GetSmartSMString(&lineP);
|
||
ParseSessionCommand (pSD, count, &string);
|
||
}
|
||
|
||
else if (!strcmp((char *)string, "-host"))
|
||
{
|
||
/*
|
||
* Parse the host string if it is present
|
||
*/
|
||
string = GetSmartSMString(&lineP);
|
||
ParseSessionHost (pSD, count, string);
|
||
}
|
||
|
||
} /* while GetSmartSMString */
|
||
|
||
count++;
|
||
|
||
} /* while GetNextLine */
|
||
|
||
|
||
|
||
} /* END OF FUNCTION ParseSessionItems */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseSessionClientState (pSD, count, string);
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Inputs:
|
||
* ------
|
||
* Outputs:
|
||
* -------
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
void ParseSessionClientState (WmScreenData *pSD, int count,
|
||
unsigned char *string)
|
||
|
||
|
||
|
||
{
|
||
|
||
if(!strcmp((char *)string, "NormalState"))
|
||
{
|
||
pSD->pDtSessionItems[count].clientState = NORMAL_STATE;
|
||
}
|
||
else if(!strcmp((char *)string, "IconicState"))
|
||
{
|
||
pSD->pDtSessionItems[count].clientState = MINIMIZED_STATE;
|
||
}
|
||
|
||
|
||
} /* END OF FUNCTION ParseSessionClientState */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseSessionGeometry (pSD, count, string)
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Inputs:
|
||
* ------
|
||
* Outputs:
|
||
* -------
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
void ParseSessionGeometry (WmScreenData *pSD, int count,
|
||
unsigned char *string)
|
||
|
||
{
|
||
SessionGeom *pTmpSessionGeom;
|
||
int mask /* = 0 */;
|
||
int X, Y, width, height;
|
||
X = Y = width = height = 0;
|
||
|
||
/*
|
||
* XParseGeometry
|
||
*/
|
||
|
||
mask = XParseGeometry((char *)string, &X, &Y, (unsigned int *)&width,
|
||
(unsigned int *)&height);
|
||
if (mask)
|
||
{
|
||
/*
|
||
* Allocate space for the geometry structure
|
||
*/
|
||
|
||
if ((pTmpSessionGeom =
|
||
(SessionGeom *)XtMalloc (sizeof (SessionGeom))) == NULL)
|
||
{
|
||
Warning (((char *)GETMESSAGE(60, 1, "Insufficient memory for session geometry item")));
|
||
return;
|
||
|
||
}
|
||
|
||
pTmpSessionGeom->flags = mask;
|
||
pTmpSessionGeom->clientX = X;
|
||
pTmpSessionGeom->clientY = Y;
|
||
pTmpSessionGeom->clientWidth = width;
|
||
pTmpSessionGeom->clientHeight = height;
|
||
|
||
pSD->pDtSessionItems[count].sessionGeom = pTmpSessionGeom;
|
||
}
|
||
|
||
} /* END OF FUNCTION ParseSessionGeometry */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* void
|
||
* ParseSessionWorkspaces (pSD, count, string)
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Inputs:
|
||
* ------
|
||
* Outputs:
|
||
* -------
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
void ParseSessionWorkspaces (WmScreenData *pSD, int count,
|
||
unsigned char *string)
|
||
|
||
{
|
||
|
||
/*
|
||
* Allocate space for the workspaces string
|
||
*/
|
||
|
||
if ((pSD->pDtSessionItems[count].workspaces =
|
||
(String)XtMalloc ((unsigned int) (strlen((char *)string) + 1))) == NULL)
|
||
{
|
||
Warning (((char *)GETMESSAGE(60, 2, "Insufficient memory for workspaces list in session item")));
|
||
return;
|
||
|
||
}
|
||
|
||
strcpy(pSD->pDtSessionItems[count].workspaces, (char *)string);
|
||
|
||
} /* END OF FUNCTION ParseSessionWorkspaces */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* void
|
||
* ParseSessionCommand (pSD, count, string)
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Inputs:
|
||
* ------
|
||
* Outputs:
|
||
* -------
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
void ParseSessionCommand (WmScreenData *pSD, int count,
|
||
unsigned char **commandString)
|
||
{
|
||
#define ARG_AMT 100
|
||
int xindex;
|
||
unsigned char **argv;
|
||
int argc = 0;
|
||
int iSizeArgv;
|
||
|
||
unsigned char *string;
|
||
|
||
argv = (unsigned char **) XtMalloc (ARG_AMT * sizeof(char *));
|
||
iSizeArgv = ARG_AMT;
|
||
|
||
while ((string = GetSmartSMString (commandString)) != NULL)
|
||
{
|
||
/*
|
||
* Get pointers to strings in command line and count them
|
||
*/
|
||
argv[argc] = string;
|
||
argc ++;
|
||
|
||
if (argc >= iSizeArgv)
|
||
{
|
||
iSizeArgv += ARG_AMT;
|
||
argv = (unsigned char **)
|
||
XtRealloc ((char *)argv, (iSizeArgv * sizeof(char *)));
|
||
}
|
||
}
|
||
if ((pSD->pDtSessionItems[count].commandArgv =
|
||
(char **)XtMalloc ((argc) * sizeof(char * ))) == NULL)
|
||
{
|
||
/*
|
||
* Allocate space for saved argv
|
||
*/
|
||
|
||
Warning (((char *)GETMESSAGE(60, 3, "Insufficient memory for commandArgv array")));
|
||
}
|
||
else
|
||
{
|
||
pSD->pDtSessionItems[count].commandArgc = argc;
|
||
for (xindex = 0; xindex < argc ; xindex++)
|
||
{
|
||
if ((pSD->pDtSessionItems[count].commandArgv[xindex] =
|
||
(String) XtMalloc
|
||
((unsigned int) (strlen((char *)argv[xindex]) + 1))) == NULL)
|
||
{
|
||
/*
|
||
* Allocate space for the next command segment.
|
||
*/
|
||
Warning (((char *)GETMESSAGE(60, 4, "Insufficient memory for commandArgv item")));
|
||
}
|
||
else
|
||
{
|
||
strcpy(pSD->pDtSessionItems[count].commandArgv[xindex],
|
||
(char *)argv[xindex]);
|
||
}
|
||
}
|
||
}
|
||
|
||
XtFree ((char *) argv);
|
||
|
||
} /* END OF FUNCTION ParseSessionCommand */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* void
|
||
* ParseSessionHost (pSD, count, string)
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Inputs:
|
||
* ------
|
||
* Outputs:
|
||
* -------
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
void ParseSessionHost (WmScreenData *pSD, int count,
|
||
unsigned char *string)
|
||
|
||
{
|
||
|
||
/*
|
||
* Allocate space for the workspaces string
|
||
*/
|
||
|
||
if ((pSD->pDtSessionItems[count].clientMachine =
|
||
(String)XtMalloc ((unsigned int) (strlen((char *)string) + 1))) ==
|
||
NULL)
|
||
{
|
||
Warning (((char *)GETMESSAGE(60, 38,
|
||
"Insufficient memory for host name in session item")));
|
||
return;
|
||
}
|
||
|
||
strcpy(pSD->pDtSessionItems[count].clientMachine, (char *)string);
|
||
|
||
} /* END OF FUNCTION ParseSessionHost */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* GetSessionHintsInfo (pSD, numItems)
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Inputs:
|
||
* ------
|
||
* Outputs:
|
||
* -------
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
Boolean GetSessionHintsInfo (WmScreenData *pSD, long numItems)
|
||
|
||
{
|
||
|
||
if ((pSD->pDtSessionItems =
|
||
(DtSessionItem *)XtMalloc (numItems * sizeof (DtSessionItem)))
|
||
== NULL)
|
||
{
|
||
Warning (((char *)GETMESSAGE(60, 5, "Insufficient memory for Dt Session Hints")));
|
||
return(False);
|
||
}
|
||
|
||
memset ((char *)pSD->pDtSessionItems, 0,
|
||
numItems * sizeof (DtSessionItem));
|
||
|
||
return(True);
|
||
|
||
|
||
} /* END OF FUNCTION GetSessionHintsInfo */
|
||
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* PeekAhead (currentChar, currentLev)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Returns a new level value if this is a new nesting level of quoted string
|
||
* Otherwise it returns a zero
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* currentChar = current position in the string
|
||
* currentLev = current level of nesting
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* Returns either a new level of nesting or zero if the character is copied in
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
unsigned int PeekAhead(unsigned char *currentChar,
|
||
unsigned int currentLev)
|
||
|
||
|
||
{
|
||
Boolean done = False;
|
||
unsigned int tmpLev = 1;
|
||
unsigned int chlen;
|
||
|
||
while (((chlen = mblen ((char *)currentChar, MB_CUR_MAX)) > 0) &&
|
||
(chlen == 1) && ((*currentChar == '"') || (*currentChar == '\\'))
|
||
&& (done == False))
|
||
{
|
||
currentChar++;
|
||
|
||
if(((chlen = mblen ((char *)currentChar, MB_CUR_MAX)) > 0) && (chlen == 1) &&
|
||
((*currentChar == '"') || (*currentChar == '\\')))
|
||
{
|
||
tmpLev++;
|
||
if(*currentChar == '"')
|
||
{
|
||
done = True;
|
||
}
|
||
else
|
||
{
|
||
currentChar++;
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Figure out if this is truly a new level of nesting - else ignore it
|
||
* This section probably could do some error checking and return -1
|
||
* If so, change type of routine from unsigned int to int
|
||
*/
|
||
if(done == True)
|
||
{
|
||
return(tmpLev);
|
||
}
|
||
else
|
||
{
|
||
return(0);
|
||
}
|
||
} /* END OF FUNCTION PeekAhead */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* SyncModifierStrings (fileName)
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function updates modifierStrings table so that Mwm uses the correct
|
||
* modifier to keysym mapping. Specifically, fix up the Alt and Meta bindings.
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* fileName
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* fileName
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
void SyncModifierStrings(void)
|
||
{
|
||
XModifierKeymap *map;
|
||
int i, j, k = 0;
|
||
|
||
map = XGetModifierMapping (DISPLAY);
|
||
|
||
for (i = 0; i < 8; i++)
|
||
{
|
||
for (j = 0; j < map->max_keypermod; j++)
|
||
{
|
||
if (map->modifiermap[k])
|
||
{
|
||
KeySym ks = XKeycodeToKeysym(DISPLAY, map->modifiermap[k], 0);
|
||
char *nm = XKeysymToString(ks);
|
||
|
||
/* Compare, ignoring the trailing '_L' or '_R' in keysym */
|
||
if (nm && !strncmp("Alt", nm, 3))
|
||
{
|
||
modifierStrings[ALT_INDEX].mask = (1<<i);
|
||
}
|
||
else if (nm && !strncmp("Meta", nm, 4))
|
||
{
|
||
modifierStrings[META_INDEX].mask = (1<<i);
|
||
}
|
||
}
|
||
k++;
|
||
}
|
||
}
|
||
|
||
XFreeModifiermap(map);
|
||
}
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ProcessWmFile ()
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function reads the mwm resource description file and processes the
|
||
* resources that are described.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* wmGD.bitmapDirectory = bitmapDirectory resource value
|
||
* pSD->buttonBindings = buttonBindings resource value
|
||
* wmGD.configFile = configuration file resource value
|
||
* pSD->keyBindings = keyBindings resource value
|
||
* wmGD.rootWindow = default root window of display
|
||
* HOME = environment variable for home directory
|
||
* functionTable = window manager function parse table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* wmGD.buttonSpecs = list of button binding specifications
|
||
* wmGD.keySpecs = list of key binding specification
|
||
* wmGD.menuSpecs = list of menu specifications
|
||
* *wmGD.acceleratorMenuSpecs = initialized array of (MenuSpec *)
|
||
* wmGD.acceleratorMenuCount = 0
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* If there are more than MAXLINE characters on a line the excess characters
|
||
* are truncated.
|
||
*
|
||
*************************************<->***********************************/
|
||
#define MENU_SPEC "menu"
|
||
#define BUTTON_SPEC "buttons"
|
||
#define KEY_SPEC "keys"
|
||
#define FRONT_PANEL_SPEC DTWM_FP_PANEL_OLD
|
||
#define DROP_EFFECTS_SPEC DTWM_FP_DROP_EFFECTS
|
||
#define PANEL_SPEC DTWM_FP_PANEL
|
||
#define BOX_SPEC DTWM_FP_BOX
|
||
#define CONTROL_SPEC DTWM_FP_CONTROL
|
||
#define INCLUDE_SPEC DTWM_FP_INCLUDE
|
||
#define ANIMATION_SPEC DTWM_FP_ANIMATION
|
||
#define SWITCH_SPEC DTWM_FP_SWITCH
|
||
|
||
void ProcessWmFile (WmScreenData *pSD, Boolean bNested)
|
||
|
||
{
|
||
unsigned char *lineP;
|
||
unsigned char *string;
|
||
unsigned int n;
|
||
MenuSpec *menuSpec;
|
||
|
||
if (!bNested)
|
||
{
|
||
|
||
/*
|
||
* Initialize global data values that are set based on data in
|
||
* the mwm resource description file.
|
||
*/
|
||
|
||
pSD->buttonSpecs = NULL;
|
||
pSD->keySpecs = NULL;
|
||
pSD->menuSpecs = NULL;
|
||
|
||
/**** hhhhhhhhhhhh ******/
|
||
GetFunctionTableValues (&F_EXEC_INDEX, &F_NOP_INDEX, &F_ACTION_INDEX);
|
||
/*
|
||
* Find and parse the default system menu string, if it exists.
|
||
*/
|
||
|
||
cfileP = NULL;
|
||
linec = 0;
|
||
if (((parseP = (unsigned char *) builtinSystemMenu) != NULL) &&
|
||
(GetNextLine () != NULL))
|
||
{
|
||
lineP = line;
|
||
ParseMenuSet (pSD, lineP);
|
||
}
|
||
|
||
linec = 0;
|
||
if (((parseP = (unsigned char *) builtinRootMenu) != NULL) &&
|
||
(GetNextLine () != NULL))
|
||
{
|
||
lineP = line;
|
||
ParseMenuSet (pSD, lineP);
|
||
}
|
||
if (wmGD.useFrontPanel && !wmGD.dtSD &&
|
||
(XDefaultScreen (wmGD.display) == pSD->screen))
|
||
{
|
||
wmGD.dtSD = pSD; /* only one per display */
|
||
}
|
||
|
||
/*
|
||
* Find and associate a stream with the window manager resource
|
||
* description file.
|
||
*/
|
||
|
||
if ((cfileP = FopenConfigFile ()) == NULL)
|
||
{
|
||
if (!wmGD.useStandardBehavior)
|
||
Warning (((char *)GETMESSAGE(60, 6, "Cannot open configuration file")));
|
||
return;
|
||
}
|
||
|
||
} /* end if (!bNested) */
|
||
/*
|
||
* Parse the information in the configuration file.
|
||
* If there are more than MAXLINE characters on a line the excess are
|
||
* truncated.
|
||
*/
|
||
|
||
linec = 0;
|
||
while ((GetNextLine () != NULL)) /* not EOF nor read error */
|
||
{
|
||
lineP = line;
|
||
if ((*line == '!') || (string = GetString (&lineP)) == NULL)
|
||
/* empty or comment line */
|
||
{
|
||
continue;
|
||
}
|
||
|
||
ToLower ((char *)string);
|
||
if (!strcmp ((char *)string, MENU_SPEC))
|
||
{
|
||
ParseMenuSet (pSD, lineP);
|
||
}
|
||
else if (!strcmp ((char *) string, BUTTON_SPEC))
|
||
{
|
||
ParseButtonSet (pSD, lineP);
|
||
}
|
||
else if (!strcmp ((char *) string, KEY_SPEC))
|
||
{
|
||
ParseKeySet (pSD, lineP);
|
||
}
|
||
else if (!strcmp ((char *)string, INCLUDE_SPEC))
|
||
{
|
||
ParseIncludeSet (pSD, lineP);
|
||
}
|
||
}
|
||
|
||
fclose (cfileP);
|
||
|
||
/*
|
||
* Create and initialize the pSD->acceleratorMenuSpecs array.
|
||
* This assumes we create pointers to MenuSpecs within ProcessWmFile().
|
||
* Set pSD->acceleratorMenuCount to 0.
|
||
*/
|
||
|
||
/* count the number of menu specifications */
|
||
n = 0;
|
||
menuSpec = pSD->menuSpecs;
|
||
while (menuSpec)
|
||
{
|
||
n++;
|
||
menuSpec = menuSpec->nextMenuSpec;
|
||
}
|
||
|
||
/* allocate the array and initialize to zeros */
|
||
pSD->acceleratorMenuSpecs = NULL;
|
||
if (n)
|
||
{
|
||
pSD->acceleratorMenuSpecs =
|
||
(MenuSpec **) XtCalloc (n, sizeof (MenuSpec *));
|
||
if (pSD->acceleratorMenuSpecs == NULL)
|
||
{
|
||
Warning (((char *)GETMESSAGE(60, 7, "Insufficient memory for menu accelerators")));
|
||
}
|
||
}
|
||
pSD->acceleratorMenuCount = 0;
|
||
} /* END OF FUNCTION ProcessWmFile */
|
||
|
||
/**** This function stolen from Xt/Intrinsic.c ****/
|
||
/* The implementation of this routine is operating system dependent */
|
||
|
||
static char *ExtractLocaleName(String lang)
|
||
{
|
||
|
||
#ifdef hpux /* hpux-specific parsing of the locale string */
|
||
#define MAXLOCALE 64 /* buffer size of locale name */
|
||
|
||
char *start;
|
||
char *end;
|
||
int len;
|
||
static char buf[MAXLOCALE];
|
||
|
||
/* If lang has a substring ":<category>;", extract <category>
|
||
* from the first such occurrence as the locale name.
|
||
*/
|
||
|
||
start = lang;
|
||
if (start = strchr (lang, ':')) {
|
||
start++;
|
||
if (end = strchr (start, ';')) {
|
||
len = end - start;
|
||
strncpy(buf, start, len);
|
||
*(buf + len) = '\0';
|
||
lang = buf;
|
||
}
|
||
}
|
||
#endif /* hpux */
|
||
|
||
return lang;
|
||
}
|
||
|
||
#define RC_CONFIG_SUBDIR "/config/"
|
||
#define RC_DEFAULT_CONFIG_SUBDIR "/config/C"
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* FopenConfigFile ()
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function searches for, opens, and associates a stream with the mwm
|
||
* resource description file,
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* wmGD.configFile = configuration file resource value.
|
||
* HOME = environment variable for home directory
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* Return = If successful, a pointer to the FILE structure associated with
|
||
* the configuration file. Otherwise, NULL.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
FILE *FopenConfigFile (void)
|
||
{
|
||
|
||
char *LANG, *LANGp;
|
||
FILE *fileP;
|
||
|
||
char *homeDir = XmeGetHomeDirName();
|
||
Boolean stackPushed;
|
||
|
||
/*
|
||
* Get the LANG environment variable
|
||
* make copy since another call to getenv will blast the value.
|
||
*/
|
||
LANGp = setlocale(LC_CTYPE, NULL);
|
||
|
||
/*
|
||
* setlocale not guaranteed to return $LANG -- extract
|
||
* something usable.
|
||
*/
|
||
LANGp = ExtractLocaleName (LANGp);
|
||
|
||
if ((LANGp == NULL) || (strlen(LANGp) == 0))
|
||
{
|
||
LANG = NULL;
|
||
}
|
||
else
|
||
{
|
||
if ((LANG = (char *) XtMalloc(strlen(LANGp) +1)) == NULL)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 41, "Insufficient memory to get LANG environment variable.")));
|
||
return(NULL);
|
||
}
|
||
|
||
strcpy(LANG, LANGp);
|
||
}
|
||
|
||
|
||
/*
|
||
* To get a name for the file first look at the value of the configFile
|
||
* resource. Interpret "~/.." as relative to the user's home directory.
|
||
* Use the LANG variable if set and .mwmrc is in $HOME/$LANG/.mwmrc
|
||
*/
|
||
|
||
if (pConfigStackTop && pConfigStackTop->tempName)
|
||
{
|
||
fileP = fopen (pConfigStackTop->tempName, "r");
|
||
return (fileP);
|
||
}
|
||
stackPushed = (pConfigStackTop && (pConfigStackTop != pConfigStack));
|
||
fileP = NULL;
|
||
cfileName[0] = '\0';
|
||
|
||
if ((wmGD.configFile != NULL) && (wmGD.configFile[0] != '\0'))
|
||
/* pointer to nonNULL string */
|
||
{
|
||
if ((wmGD.configFile[0] == '~') && (wmGD.configFile[1] == '/'))
|
||
/* handle "~/..." */
|
||
{
|
||
strcpy (cfileName, homeDir);
|
||
if (LANG != NULL)
|
||
{
|
||
strncat(cfileName, "/", MAXWMPATH-strlen(cfileName));
|
||
strncat(cfileName, LANG, MAXWMPATH-strlen(cfileName));
|
||
}
|
||
strncat(cfileName, &(wmGD.configFile[1]), MAXWMPATH-strlen(cfileName));
|
||
if ((fileP = fopen (cfileName, "r")) != NULL)
|
||
{
|
||
if (LANG != NULL) {
|
||
XtFree(LANG);
|
||
LANG = NULL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* Just try $HOME/.mwmrc
|
||
*/
|
||
strcpy (cfileName, homeDir);
|
||
strncat(cfileName, &(wmGD.configFile[1]),
|
||
MAXWMPATH-strlen(cfileName));
|
||
if ((fileP = fopen (cfileName, "r")) != NULL)
|
||
{
|
||
if (LANG != NULL) {
|
||
XtFree(LANG);
|
||
LANG = NULL;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
else
|
||
/* relative to current directory or absolute */
|
||
{
|
||
char *pch;
|
||
|
||
pch = (char *) GetNetworkFileName (wmGD.configFile);
|
||
|
||
if ((fileP = fopen (pch, "r")) != NULL)
|
||
{
|
||
strncpy (cfileName, pch, MAXWMPATH);
|
||
}
|
||
XtFree (pch);
|
||
|
||
if ((fileP == NULL) && !stackPushed)
|
||
{
|
||
if ((fileP = fopen (wmGD.configFile, "r")) != NULL)
|
||
{
|
||
if (LANG != NULL) {
|
||
XtFree(LANG);
|
||
LANG = NULL;
|
||
}
|
||
return(fileP);
|
||
}
|
||
}
|
||
else if ((fileP == NULL) && stackPushed)
|
||
{
|
||
strcpy (cfileName, wmGD.configFile);
|
||
}
|
||
}
|
||
}
|
||
|
||
if ((fileP == NULL) && !stackPushed)
|
||
{
|
||
|
||
/*
|
||
* The configFile resource didn't do it for us.
|
||
* First try HOME_MWMRC, then try SYS_MWMRC .
|
||
*/
|
||
|
||
#define HOME_MWMRC "/.mwmrc"
|
||
#define SLASH_MWMRC "/system.mwmrc"
|
||
|
||
strcpy (cfileName, homeDir);
|
||
|
||
if (MwmBehavior)
|
||
{
|
||
/*
|
||
*
|
||
* Looking for $HOME/$LANG/.mwmrc
|
||
* --or--if $LANG is NULL
|
||
* Looking for $HOME/.mwmrc
|
||
*
|
||
*/
|
||
if (LANG != NULL)
|
||
{
|
||
strncat(cfileName, "/", MAXWMPATH-strlen(cfileName));
|
||
strncat(cfileName, LANG, MAXWMPATH-strlen(cfileName));
|
||
}
|
||
strncat(cfileName, HOME_MWMRC, MAXWMPATH - strlen(cfileName));
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
*
|
||
* Looking for $HOME/.dt/$LANG/dtwmrc
|
||
*
|
||
* --or--if $LANG is NULL--
|
||
*
|
||
* Looking for $HOME/.dt/dtwmrc
|
||
*
|
||
*/
|
||
strncat(cfileName, "/.dt/", MAXWMPATH-strlen(cfileName));
|
||
|
||
if (LANG != NULL)
|
||
{
|
||
strncat(cfileName, LANG, MAXWMPATH-strlen(cfileName));
|
||
}
|
||
strncat(cfileName, LANG_DT_WMRC, MAXWMPATH - strlen(cfileName));
|
||
}
|
||
if ((fileP = fopen (cfileName, "r")) != NULL)
|
||
{
|
||
if (LANG != NULL) {
|
||
XtFree(LANG);
|
||
LANG = NULL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* Just try $HOME/.mwmrc
|
||
*/
|
||
strcpy (cfileName, homeDir);
|
||
if (MwmBehavior)
|
||
{
|
||
/*
|
||
* Just try $HOME/.mwmrc
|
||
*/
|
||
strncat(cfileName, HOME_MWMRC, MAXWMPATH - strlen(cfileName));
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* Just try $HOME/.dt/dtwmrc
|
||
*/
|
||
strncat(cfileName, HOME_DT_WMRC, MAXWMPATH - strlen(cfileName));
|
||
}
|
||
if ((fileP = fopen (cfileName, "r")) != NULL)
|
||
{
|
||
if (LANG != NULL) {
|
||
XtFree(LANG);
|
||
LANG = NULL;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#define DTLIBDIR CDE_INSTALLATION_TOP
|
||
#define DTADMINDIR CDE_CONFIGURATION_TOP
|
||
#define SLASH_DT_WMRC "/sys.dtwmrc"
|
||
|
||
if ((fileP == NULL) && !stackPushed)
|
||
{
|
||
/*
|
||
* No home-based config file. Try the admin directory.
|
||
*/
|
||
strcpy(cfileName, DTADMINDIR);
|
||
strncat(cfileName, RC_CONFIG_SUBDIR, MAXWMPATH-strlen(cfileName));
|
||
strncat(cfileName, LANG, MAXWMPATH-strlen(cfileName));
|
||
strncat(cfileName, SLASH_DT_WMRC, MAXWMPATH - strlen(cfileName));
|
||
|
||
if (((fileP = fopen (cfileName, "r")) == NULL) && LANG && *LANG)
|
||
{
|
||
/* Try it with no LANG */
|
||
strcpy(cfileName, DTADMINDIR);
|
||
strncat(cfileName, RC_CONFIG_SUBDIR, MAXWMPATH-strlen(cfileName));
|
||
strncat(cfileName, SLASH_DT_WMRC, MAXWMPATH - strlen(cfileName));
|
||
}
|
||
|
||
if ((fileP = fopen (cfileName, "r")) != NULL)
|
||
{
|
||
XtFree(LANG);
|
||
LANG = NULL;
|
||
}
|
||
}
|
||
|
||
if ((fileP == NULL) && !stackPushed)
|
||
{
|
||
|
||
#ifndef LIBDIR
|
||
#define LIBDIR "/usr/lib/X11"
|
||
#endif
|
||
if (LANG != NULL)
|
||
{
|
||
if (MwmBehavior)
|
||
{
|
||
strcpy(cfileName, LIBDIR);
|
||
strncat(cfileName, "/", MAXWMPATH-strlen(cfileName));
|
||
strncat(cfileName, LANG, MAXWMPATH-strlen(cfileName));
|
||
strncat(cfileName, SLASH_MWMRC, MAXWMPATH - strlen(cfileName));
|
||
}
|
||
else
|
||
{
|
||
strcpy(cfileName, DTLIBDIR);
|
||
strncat(cfileName, RC_CONFIG_SUBDIR, MAXWMPATH-strlen(cfileName));
|
||
strncat(cfileName, LANG, MAXWMPATH-strlen(cfileName));
|
||
strncat(cfileName, SLASH_DT_WMRC, MAXWMPATH - strlen(cfileName));
|
||
}
|
||
if ((fileP = fopen (cfileName, "r")) != NULL)
|
||
{
|
||
XtFree(LANG);
|
||
LANG = NULL;
|
||
}
|
||
}
|
||
|
||
if ((fileP == NULL) && !stackPushed)
|
||
{
|
||
if (MwmBehavior)
|
||
{
|
||
strcpy(cfileName, LIBDIR);
|
||
strncat(cfileName, SLASH_MWMRC, MAXWMPATH - strlen(cfileName));
|
||
fileP = fopen (cfileName, "r");
|
||
}
|
||
else
|
||
{
|
||
strcpy(cfileName, DTLIBDIR);
|
||
strncat(cfileName, RC_DEFAULT_CONFIG_SUBDIR,
|
||
MAXWMPATH - strlen(cfileName));
|
||
strncat(cfileName, SLASH_DT_WMRC, MAXWMPATH - strlen(cfileName));
|
||
fileP = fopen (cfileName, "r");
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!fileP)
|
||
{
|
||
char *pch;
|
||
|
||
/*
|
||
* handle "<host>:<path>" form of file name
|
||
*/
|
||
pch = (char *) GetNetworkFileName (cfileName);
|
||
if ((fileP = fopen (cfileName, "r")) != NULL)
|
||
{
|
||
strncpy (cfileName, pch, MAXWMPATH);
|
||
XtFree (pch);
|
||
}
|
||
|
||
/*
|
||
* Either not "<host>:<path>" form or there was a
|
||
* problem up above. This is the last attempt to
|
||
* open something.
|
||
*/
|
||
if (!fileP)
|
||
{
|
||
fileP = fopen (cfileName, "r");
|
||
}
|
||
}
|
||
|
||
if (!pConfigStack)
|
||
{
|
||
ConfigStackInit (cfileName);
|
||
}
|
||
|
||
if (wmGD.cppCommand && *wmGD.cppCommand)
|
||
{
|
||
/*
|
||
* Run the file through the C-preprocessor
|
||
*/
|
||
PreprocessConfigFile ();
|
||
if (pConfigStackTop && pConfigStackTop->cppName)
|
||
{
|
||
if(fileP) {
|
||
fclose(fileP);
|
||
}
|
||
/* open the result */
|
||
fileP = fopen (pConfigStackTop->cppName, "r");
|
||
}
|
||
}
|
||
|
||
if (LANG != NULL)
|
||
{
|
||
XtFree(LANG);
|
||
LANG = NULL;
|
||
}
|
||
return (fileP);
|
||
|
||
} /* END OF FUNCTION FopenConfigFile */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* SaveMenuAccelerators (pSD, newMenuSpec)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function saves the MenuSpec pointer in pSD->acceleratorMenuSpecs.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* newMenuSpec = pointer to MenuSpec to be saved.
|
||
* pSD->acceleratorMenuSpecs =
|
||
* pSD->acceleratorMenuCount =
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* pSD->acceleratorMenuSpecs = possibly updated
|
||
* pSD->acceleratorMenuCount = possibly updated
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* We assume only MenuSpecs created within ProcessWmFile() are to be saved.
|
||
* Otherwise, we may cause override the limits of pSD->acceleratorMenuSpecs.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
void SaveMenuAccelerators (WmScreenData *pSD, MenuSpec *newMenuSpec)
|
||
{
|
||
MenuSpec **pMenuSpec;
|
||
|
||
pMenuSpec = pSD->acceleratorMenuSpecs;
|
||
|
||
if (pMenuSpec == NULL)
|
||
return;
|
||
|
||
while ((*pMenuSpec != NULL) && (*pMenuSpec != newMenuSpec))
|
||
{
|
||
pMenuSpec++;
|
||
}
|
||
|
||
if (*pMenuSpec == NULL)
|
||
{
|
||
*pMenuSpec = newMenuSpec;
|
||
pSD->acceleratorMenuCount++;
|
||
}
|
||
|
||
} /* END OF FUNCTION SaveMenuAccelerators */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseMenuSet (pSD, lineP)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Menu pane specification found. Parse the following syntax:
|
||
*
|
||
* v
|
||
* Menu menu_pane_name
|
||
* {
|
||
* label [mnemonic] [accelerator] function
|
||
* label [mnemonic] [accelerator] function
|
||
* ...
|
||
* label [mnemonic] [accelerator] function
|
||
* }
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* cfileP = (global) file pointer to fopened configuration file or NULL
|
||
* lineP = pointer to menu name in line buffer
|
||
* line = (global) line buffer
|
||
* linec = (global) line count
|
||
* parseP = (global) parse string pointer if cfileP == NULL
|
||
* pSD->rootWindow = default root window of display
|
||
* wmGD.bitmapDirectory = bitmapDirectory resource value
|
||
* HOME = environment variable for home directory
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linec = (global) line count incremented
|
||
* parseP = (global) parse string pointer if cfileP == NULL
|
||
* pSD->menuSpecs = list of menu specifications
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* Skips unnamed menu specifications.
|
||
* This means custom menu specifications can be distinguished by NULL name.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void ParseMenuSet (WmScreenData *pSD, unsigned char *lineP)
|
||
{
|
||
unsigned char *string;
|
||
MenuSpec *menuSpec;
|
||
|
||
/*
|
||
* If menu name is NULL then skip this pane specification.
|
||
*/
|
||
|
||
if ((string = GetString (&lineP)) == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* Allocate space for the menu specification structure.
|
||
*/
|
||
|
||
if ((menuSpec = (MenuSpec *)XtMalloc (sizeof (MenuSpec))) == NULL)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 9, "Insufficient memory for menu")));
|
||
return;
|
||
}
|
||
menuSpec->currentContext = 0;
|
||
menuSpec->menuWidget = NULL;
|
||
menuSpec->whichButton = SELECT_BUTTON; /* Button1 selection default */
|
||
menuSpec->menuItems = NULL;
|
||
menuSpec->accelContext = 0;
|
||
menuSpec->accelKeySpecs = NULL;
|
||
menuSpec->nextMenuSpec = NULL;
|
||
|
||
/*
|
||
* Allocate and fill space for the menu name.
|
||
*/
|
||
|
||
if ((menuSpec->name =
|
||
(String)XtMalloc ((unsigned int) (strlen ((char *)string) + 1)))
|
||
== NULL)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 10, "Insufficient memory for menu")));
|
||
XtFree ((char *)menuSpec);
|
||
return;
|
||
}
|
||
strcpy (menuSpec->name, (char *)string);
|
||
|
||
/*
|
||
* Add the empty structure to the head of the menu specification list.
|
||
*/
|
||
|
||
menuSpec->nextMenuSpec = pSD->menuSpecs;
|
||
pSD->menuSpecs = menuSpec;
|
||
|
||
/*
|
||
* Require leading '{' on the next line.
|
||
*/
|
||
|
||
while ((GetNextLine () != NULL)) /* not EOF nor read error */
|
||
{
|
||
lineP = line;
|
||
ScanWhitespace(&lineP);
|
||
|
||
if ((lineP == NULL) || (*line == '!') || (*lineP == '\0') || (*lineP == '#'))
|
||
/* ignore empty or comment line */
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (*lineP == '{')
|
||
/* found '{' */
|
||
{
|
||
break;
|
||
}
|
||
|
||
/* not a '{' */
|
||
PWarning (((char *)GETMESSAGE(60, 11, "Expected '{' after menu name")));
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* Found leading "{" or EOF.
|
||
* Parse menu item specifications until "}" or EOF found.
|
||
*/
|
||
|
||
menuSpec->menuItems = PARSE_MENU_ITEMS (pSD, menuSpec);
|
||
|
||
} /* END OF FUNCTION ParseMenuSet */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* MenuItem *
|
||
* ParseMwmMenuStr (pSD, menuStr)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function parses a WMW_MENU string and returns a list of
|
||
* MenuItems structures. The string should have the syntax:
|
||
*
|
||
* label [mnemonic] [accelerator] function
|
||
* label [mnemonic] [accelerator] function
|
||
* ...
|
||
* label [mnemonic] [accelerator] function
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* line = (global) line buffer
|
||
* pSD->rootWindow = default root window of display
|
||
* wmGD.bitmapDirectory = bitmapDirectory resource value
|
||
* HOME = environment variable for home directory
|
||
* functionTable = window manager function parse table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* Return = list of MenuItem structures or NULL
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
MenuItem *ParseMwmMenuStr (WmScreenData *pSD, unsigned char *menuStr)
|
||
{
|
||
|
||
cfileP = NULL;
|
||
linec = 0;
|
||
parseP = menuStr;
|
||
|
||
return (PARSE_MENU_ITEMS (pSD, NULL));
|
||
|
||
} /* END OF FUNCTION ParseMwmMenuStr */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* static MenuItem *
|
||
* ParseMenuItems (pSD, menuSpec)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parse menu item specifications:
|
||
*
|
||
* label [mnemonic] [accelerator] function
|
||
* label [mnemonic] [accelerator] function
|
||
* ...
|
||
* label [mnemonic] [accelerator] function
|
||
* [}]
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pSD = pointer to screen data
|
||
* cfileP = (global) file pointer to fopened configuration file or NULL
|
||
* line = (global) line buffer
|
||
* linec = (global) line count
|
||
* parseP = (global) parse string pointer if cfileP == NULL
|
||
* pSD->rootWindow = default root window of display
|
||
* wmGD.bitmapDirectory = bitmapDirectory resource value
|
||
* HOME = environment variable for home directory
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linec = (global) line count incremented
|
||
* parseP = (global) parse string pointer if cfileP == NULL
|
||
* Return = list of MenuItem structures or NULL
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static MenuItem *ParseMenuItems (WmScreenData *pSD)
|
||
{
|
||
unsigned char *string;
|
||
unsigned char *lineP;
|
||
MenuItem *firstMenuItem;
|
||
MenuItem *lastMenuItem;
|
||
MenuItem *menuItem;
|
||
int ix;
|
||
|
||
/*
|
||
* Parse "label [mnemonic] [accelerator] function" or
|
||
* "<client command>[.<client command>]*"
|
||
* lines until "}" or EOF found.
|
||
*/
|
||
|
||
firstMenuItem = lastMenuItem = NULL;
|
||
while ((GetNextLine () != NULL))
|
||
{
|
||
lineP = line;
|
||
if ((*line == '!') || (*line == '#') || (string = GetString (&lineP)) == NULL)
|
||
/* ignore empty or comment lines */
|
||
{
|
||
continue;
|
||
}
|
||
if (*string == '}') /* finished with menu set. */
|
||
{
|
||
break;
|
||
}
|
||
|
||
/*
|
||
* Allocate space for the menu item structure.
|
||
*/
|
||
|
||
if ((menuItem = (MenuItem *)XtMalloc (sizeof (MenuItem))) == NULL)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 12, "Insufficient memory for menu item")));
|
||
continue;
|
||
}
|
||
menuItem->nextMenuItem = NULL;
|
||
menuItem->wmFunction = (WmFunction)NULL;
|
||
menuItem->wmFuncArgs = NULL;
|
||
|
||
{
|
||
/*
|
||
* Parse the menu item label.
|
||
*/
|
||
if (!ParseWmLabel (pSD, menuItem, string))
|
||
{
|
||
XtFree ((char *)menuItem);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Parse any menu function mnemonic.
|
||
*/
|
||
|
||
ParseWmMnemonic (&lineP, menuItem);
|
||
|
||
/*
|
||
* Parse any menu function accelerator.
|
||
*/
|
||
|
||
if (!ParseWmAccelerator (&lineP, menuItem))
|
||
{
|
||
XtFree ((char *)menuItem);
|
||
continue;
|
||
}
|
||
/*
|
||
* Parse the menu function name if this is not a client
|
||
* command. If it is a client command, then the wmFunction
|
||
* field should already be set, as well as the ix variable,
|
||
* but we do want to search for a menu item name that occupies
|
||
* the same place as the function does for normal menu items.
|
||
*/
|
||
ix = ParseWmFunction (&lineP, CRS_MENU, &menuItem->wmFunction);
|
||
|
||
/*
|
||
* Determine context sensitivity and applicability mask.
|
||
*/
|
||
|
||
menuItem->greyedContext = functionTable[ix].greyedContext;
|
||
menuItem->mgtMask = functionTable[ix].mgtMask;
|
||
if ((menuItem->wmFunction == F_Toggle_Front_Panel) &&
|
||
((wmGD.useFrontPanel == False) ||
|
||
(wmGD.dtSD != pSD)))
|
||
{
|
||
/*
|
||
* disallow this function if there's no front
|
||
* panel on this screen.
|
||
*/
|
||
menuItem->greyedContext |= (F_CONTEXT_ALL |
|
||
F_SUBCONTEXT_IB_WICON |
|
||
F_SUBCONTEXT_IB_IICON);
|
||
}
|
||
|
||
/*
|
||
* Apply the function argument parser.
|
||
*/
|
||
if (!(*(functionTable [ix].parseProc))
|
||
(&lineP, menuItem->wmFunction, &menuItem->wmFuncArgs))
|
||
{
|
||
FreeMenuItem (menuItem);
|
||
continue; /* skip this menu item */
|
||
}
|
||
|
||
/*
|
||
* Add this item to the menu specification.
|
||
*/
|
||
|
||
if (lastMenuItem != NULL) /* not first */
|
||
{
|
||
lastMenuItem->nextMenuItem = menuItem;
|
||
}
|
||
else
|
||
{
|
||
firstMenuItem = menuItem;
|
||
}
|
||
lastMenuItem = menuItem;
|
||
}
|
||
|
||
return (firstMenuItem);
|
||
|
||
} /* END OF FUNCTION ParseMenuItems */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseWmLabel (pSD, menuItem, string)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parse a menu label string.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pSD = pointer to screen data
|
||
* menuItem = pointer to MenuItem structure
|
||
* string = label string
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* menuItem->label
|
||
* menuItem->labelType
|
||
* menuItem->labelBitmapCache
|
||
* Return = boolean, FALSE iff insufficient memory
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* We have two label types: XmSTRING and XmPIXMAP
|
||
* We allocate and fill the label field with string and set the type to
|
||
* XmSTRING. If string = "@<bitmap_file>", and <bitmap_file> contains a
|
||
* with which to build a label image we save the bitmap in the MenuItem
|
||
* structure and set the type to XmPIXMAP.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseWmLabel (WmScreenData *pSD, MenuItem *menuItem,
|
||
unsigned char *string)
|
||
{
|
||
|
||
/*
|
||
* Allocate the label field and copy string.
|
||
*/
|
||
|
||
if ((menuItem->label = (String)
|
||
XtMalloc ((unsigned int)(strlen ((char *)string) + 1))) == NULL)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 13, "Insufficient memory for menu item")));
|
||
return (FALSE);
|
||
}
|
||
|
||
strcpy (menuItem->label, (char *)string);
|
||
menuItem->labelType = XmSTRING;
|
||
|
||
if (*string == '@')
|
||
/*
|
||
* Here: string = "@<bitmap file>"
|
||
* Try to find the label bitmap in the bitmap cache or read the label
|
||
* bitmap file.
|
||
*/
|
||
{
|
||
string++; /* skip "@" */
|
||
if ((menuItem->labelBitmapIndex = GetBitmapIndex (pSD,
|
||
(char *)string, True)) >= 0)
|
||
{
|
||
menuItem->labelType = XmPIXMAP;
|
||
}
|
||
}
|
||
return (TRUE);
|
||
|
||
} /* END OF FUNCTION ParseWmLabel */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseWmMnemonic (linePP, menuItem)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parse an optional menu function mnemonic.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* menuItem = pointer to MenuItem structure
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* menuItem->mnemonic = valid mnemonic character or NULL.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void ParseWmMnemonic (unsigned char **linePP, MenuItem *menuItem)
|
||
{
|
||
unsigned char *lineP = *linePP;
|
||
unsigned char *mnemonic;
|
||
|
||
/*
|
||
* Skip leading white space.
|
||
*/
|
||
ScanWhitespace (&lineP);
|
||
menuItem->mnemonic = (KeySym)NULL;
|
||
|
||
if (*lineP == '_')
|
||
/*
|
||
* We have a mnemonic specification.
|
||
* Get the next string (we only use the first character).
|
||
* If no string exists, the labelType is not XmSTRING, or does not contain
|
||
* the first character, then skip the string and return.
|
||
* Otherwise, accept the first character as a mnemonic.
|
||
*/
|
||
{
|
||
KeySym ks;
|
||
lineP++;
|
||
mnemonic = GetString(&lineP);
|
||
|
||
if (menuItem->labelType == XmSTRING &&
|
||
mnemonic != NULL &&
|
||
(ks = XStringToKeysym((char *)mnemonic)) != NoSymbol &&
|
||
strchr(menuItem->label, (char)(ks & 0xff)) != NULL)
|
||
{
|
||
menuItem->mnemonic = ks;
|
||
}
|
||
else
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 14, "Invalid mnemonic specification")));
|
||
}
|
||
}
|
||
|
||
*linePP = lineP; /* consume any string */
|
||
|
||
} /* END OF FUNCTION ParseWmMnemonic */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseWmAccelerator (linePP, menuItem)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parse an optional menu function accelerator.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* menuItem = pointer to MenuItem structure
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* menuItem->accelText = pointer to an accelerator string or NULL.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseWmAccelerator (unsigned char **linePP, MenuItem *menuItem)
|
||
{
|
||
unsigned char *lineP;
|
||
String string;
|
||
unsigned int eventType;
|
||
unsigned int state;
|
||
KeyCode keycode;
|
||
Boolean status;
|
||
|
||
menuItem->accelState = 0;
|
||
menuItem->accelKeyCode = 0;
|
||
menuItem->accelText = NULL;
|
||
status = TRUE;
|
||
|
||
/*
|
||
* If linePP contains NULL, then abort.
|
||
*/
|
||
if (*linePP == (unsigned char *) NULL) return(FALSE);
|
||
|
||
/*
|
||
* Skip leading white space.
|
||
*/
|
||
ScanWhitespace (linePP);
|
||
lineP = *linePP;
|
||
|
||
/*
|
||
* If the second character is not ".", and an accelerator specification
|
||
* exists, then process and save the specification string.
|
||
*/
|
||
|
||
if ((*lineP != '\0') && /* something follows */
|
||
(*lineP != '!') && /* skip if we have the ! WmFunction */
|
||
(*lineP != 'f') &&
|
||
(*(lineP+1) != '.')) /* skip if we have f.xxx WmFunction */
|
||
{
|
||
if (ParseKeyEvent(&lineP, &eventType, &keycode, &state))
|
||
{
|
||
if ((string = (String) XtMalloc
|
||
((unsigned int) (lineP - *linePP + 1))) == NULL)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 15, "Insufficient memory for accelerator specification")));
|
||
status = FALSE;
|
||
}
|
||
else
|
||
/*
|
||
* Save the accelerator state and keycode.
|
||
* Process and save the accelerator text.
|
||
*/
|
||
{
|
||
ProcessAccelText (*linePP, lineP, (unsigned char *) string);
|
||
menuItem->accelState = state;
|
||
menuItem->accelKeyCode = keycode;
|
||
menuItem->accelText = string;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 16, "Invalid accelerator specification")));
|
||
status = FALSE;
|
||
}
|
||
|
||
*linePP = lineP; /* consume the specification */
|
||
}
|
||
|
||
return (status);
|
||
|
||
} /* END OF FUNCTION ParseWmAccelerator */
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* int
|
||
* ParseWmFunction (linePP, res_spec, pWmFunction)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parse a button, key, or menu function name and return its function table
|
||
* index.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* res_spec = resource specification type (key, button, or menu).
|
||
* pWmFunction = pointer to window manager function destination.
|
||
* functionTable = window manager function parse table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* pWmFunction = pointer to parsed window manager function.
|
||
* Return = function table index of parsed function.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* Uses F_Nop if the function name or resource type is invalid.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
int ParseWmFunction (unsigned char **linePP, unsigned int res_spec,
|
||
WmFunction *pWmFunction)
|
||
{
|
||
unsigned char *lineP = *linePP;
|
||
unsigned char *string;
|
||
int low, mid, high, cmp;
|
||
|
||
/*
|
||
* Skip leading white space.
|
||
*/
|
||
ScanWhitespace (&lineP);
|
||
|
||
/*
|
||
* Have function string (may be NULL or a comment).
|
||
* Handle the special case of '!'
|
||
*/
|
||
|
||
if (*lineP == '!')
|
||
{
|
||
*linePP = ++lineP;
|
||
*pWmFunction = F_Exec;
|
||
return (F_EXEC_INDEX);
|
||
}
|
||
|
||
/*
|
||
* Identify the function corresponding to the specified name.
|
||
* Try binary search of the window manager function parse table.
|
||
* Assume f.nop if the function and resource type cannot be matched.
|
||
* This handles NULL and comment strings, bad function names, and functions
|
||
* in inappropriate resource sets.
|
||
*/
|
||
string = GetString (&lineP);
|
||
*linePP = lineP;
|
||
|
||
if (string != NULL)
|
||
{
|
||
ToLower ((char *)string);
|
||
low = 0;
|
||
high = WMFUNCTIONTABLESIZE - 1;
|
||
|
||
while (low <= high)
|
||
{
|
||
mid = (low + high)/2;
|
||
cmp = strcmp (functionTable[mid].funcName, (char *)string);
|
||
|
||
if (!cmp)
|
||
/*
|
||
* Function name match
|
||
* Require proper resource type for the function.
|
||
*/
|
||
{
|
||
if (res_spec & functionTable[mid].resource)
|
||
{
|
||
*pWmFunction = functionTable[mid].wmFunction;
|
||
return (mid);
|
||
}
|
||
|
||
/* invalid resource: use F_Nop */
|
||
break;
|
||
}
|
||
|
||
/*
|
||
* Function name mismatch
|
||
*/
|
||
if (cmp > 0)
|
||
{
|
||
high = mid - 1;
|
||
}
|
||
else
|
||
{
|
||
low = mid + 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Not found: assume f.nop
|
||
*/
|
||
*pWmFunction = F_Nop;
|
||
return (F_NOP_INDEX);
|
||
|
||
} /* END OF FUNCTION ParseWmFunction */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseWmFuncMaybeStrArg (linePP, wmFunction, pArgs)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parses a window manager function with a null or string argument.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* wmFunction = function (not used).
|
||
* pArgs = pointer to argument destination.
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* pArgs = pointer to parsed argument string.
|
||
* Return = FALSE iff insufficient memory
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* Only used to parse arguments for F_Lower, F_Raise, and F_Raise_Lower.
|
||
* If it is used for any other function, be sure to change FreeMenuItem ()
|
||
* accordingly.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
Boolean ParseWmFuncMaybeStrArg (unsigned char **linePP,
|
||
WmFunction wmFunction, String *pArgs)
|
||
{
|
||
unsigned char *string = *linePP;
|
||
unsigned int len;
|
||
|
||
ScanWhitespace (&string);
|
||
/*
|
||
if (*lineP == '-')
|
||
{
|
||
*linePP = ++lineP;
|
||
return (ParseWmFuncStrArg (linePP, wmFunction, pArgs));
|
||
}
|
||
*/
|
||
#if 0
|
||
else if (*lineP == '"' && *(lineP+1) == '-')
|
||
{
|
||
/* kill off '-' */
|
||
strcpy ((char *) (lineP+1), (char *) (lineP+2));
|
||
return (ParseWmFuncStrArg (linePP, wmFunction, pArgs));
|
||
}
|
||
#endif
|
||
if ((len = strlen ((char *)string)) != 0)
|
||
{
|
||
if ((*pArgs = (String)XtMalloc (len + 1)) == NULL)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 17, "Insufficient memory")));
|
||
return (FALSE);
|
||
}
|
||
strcpy (*pArgs, (char *)string);
|
||
return (TRUE);
|
||
}
|
||
else
|
||
/* Do ParseWmFuncNoArg () */
|
||
{
|
||
*pArgs = NULL;
|
||
return (TRUE);
|
||
}
|
||
|
||
} /* END OF FUNCTION ParseWmFuncMaybeStrArg */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseWmFuncNoArg (linePP, wmFunction, pArgs)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parses a window manager function null argument.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* wmFunction = function (not used).
|
||
* pArgs = pointer to argument destination.
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = unchanged
|
||
* pArgs = NULL
|
||
* Return = TRUE
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseWmFuncNoArg (unsigned char **linePP, WmFunction wmFunction,
|
||
String *pArgs)
|
||
{
|
||
|
||
*pArgs = NULL;
|
||
return (TRUE);
|
||
|
||
} /* END OF FUNCTION ParseWmFuncNoArg */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseWmFuncStrArg (linePP, wmFunction, pArgs)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parses a window manager function string argument.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* wmFunction = function for which the argument string is intended.
|
||
* pArgs = pointer to argument string destination.
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* pArgs = pointer to parsed argument string.
|
||
* Return = FALSE iff insufficient memory
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* Insures that an argument for F_Exec() ends in '&' .
|
||
* Only used to parse arguments for F_Exec, F_Menu, F_Lower, F_Raise,
|
||
* F_Raise_Lower, and F_Screen. If it is used for any other function, be
|
||
* sure to change FreeMenuItem () accordingly.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
Boolean ParseWmFuncStrArg (unsigned char **linePP,
|
||
WmFunction wmFunction, String *pArgs)
|
||
{
|
||
unsigned char *string;
|
||
unsigned int len;
|
||
char *p;
|
||
wchar_t last;
|
||
char delim;
|
||
wchar_t wdelim;
|
||
int lastlen;
|
||
|
||
if ((string = GetString (linePP)) != NULL)
|
||
/* nonNULL string argument */
|
||
{
|
||
len = strlen ((char *)string);
|
||
if ((*pArgs = (String)XtMalloc (len + 2)) == NULL)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 17, "Insufficient memory")));
|
||
return (FALSE);
|
||
}
|
||
strcpy (*pArgs, (char *)string);
|
||
|
||
/*
|
||
* Insure that an argument for F_Exec ends in '&' .
|
||
*/
|
||
|
||
if (wmFunction == F_Exec)
|
||
{
|
||
lastlen = 0;
|
||
p = *pArgs;
|
||
while (*p &&
|
||
((len = mblen(p, MB_CUR_MAX)) > 0))
|
||
{
|
||
mbtowc(&last, p, MB_CUR_MAX);
|
||
lastlen = len;
|
||
p += len;
|
||
}
|
||
delim = '&';
|
||
mbtowc(&wdelim, &delim, MB_CUR_MAX);
|
||
if (lastlen == 1 && last != wdelim)
|
||
{
|
||
*p++ = '&';
|
||
*p = '\0';
|
||
}
|
||
}
|
||
}
|
||
else
|
||
/* NULL string argument */
|
||
{
|
||
*pArgs = NULL;
|
||
}
|
||
|
||
return (TRUE);
|
||
|
||
} /* END OF FUNCTION ParseWmFuncStrArg */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* FreeMenuItem (menuItem)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This procedure destroys a MenuItem structure.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* menuItem = to be destroyed.
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* None.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* Assumes that ParseWmFuncStrArg () has parsed a menu item's function
|
||
* argument only for F_Exec, F_Menu, F_Lower, F_Raise, F_Raise_Lower, and
|
||
* F_Screen. If it is used for other functions, be sure to include them here!
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
void FreeMenuItem (MenuItem *menuItem)
|
||
{
|
||
if (menuItem->label != NULL)
|
||
{
|
||
XtFree ((char *)menuItem->label);
|
||
}
|
||
|
||
if (menuItem->accelText != NULL)
|
||
{
|
||
XtFree ((char *)menuItem->accelText);
|
||
}
|
||
|
||
/*
|
||
* If menuItem->wmFuncArgs is nonNULL, we assume that it is a string that
|
||
* was malloc'ed in ParseWmFuncStrArg () and we free it now.
|
||
*/
|
||
if ((menuItem->wmFuncArgs != NULL) &&
|
||
((menuItem->wmFunction == F_Exec) ||
|
||
(menuItem->wmFunction == F_Menu) ||
|
||
(menuItem->wmFunction == F_Lower) ||
|
||
(menuItem->wmFunction == F_Raise) ||
|
||
(menuItem->wmFunction == F_Raise_Lower) ||
|
||
(menuItem->wmFunction == F_Screen)))
|
||
{
|
||
XtFree ((char *)menuItem->wmFuncArgs);
|
||
}
|
||
|
||
XtFree ((char *)menuItem);
|
||
|
||
} /* END OF FUNCTION FreeMenuItem */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseWmFuncGrpArg (linePP, wmFunction, pGroup)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parses a window manager function group argument.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* wmFunction = function for which the group argument is intended.
|
||
* pGroup = pointer to group argument destination.
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* pGroup = pointer to parsed group argument.
|
||
* Return = FALSE iff invalid group argument.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* The only valid nonNULL arguments are "icon", "window", and "transient".
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseWmFuncGrpArg (unsigned char **linePP,
|
||
WmFunction wmFunction, GroupArg *pGroup)
|
||
{
|
||
unsigned char *lineP = *linePP;
|
||
unsigned char *startP;
|
||
unsigned char grpStr[MAX_GROUP_STRLEN+1];
|
||
int len;
|
||
|
||
|
||
/*
|
||
* Parse groups while each is followed by "|".
|
||
*/
|
||
|
||
*pGroup = 0;
|
||
while (1)
|
||
{
|
||
/*
|
||
* Skip whitespace and find next group string.
|
||
*/
|
||
|
||
ScanWhitespace (&lineP);
|
||
startP = lineP;
|
||
ScanAlphanumeric (&lineP);
|
||
if (startP == lineP)
|
||
/* Group missing => use default or complain */
|
||
{
|
||
if (*pGroup)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 18, "Missing group specification")));
|
||
return (FALSE);
|
||
}
|
||
else
|
||
{
|
||
*pGroup = F_GROUP_DEFAULT;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Found a group string; compare it with valid groups.
|
||
*/
|
||
|
||
len = min (lineP - startP, MAX_GROUP_STRLEN);
|
||
(void) strncpy ((char *)grpStr, (char *)startP, len);
|
||
grpStr[len] = '\0';
|
||
ToLower ((char *)grpStr);
|
||
|
||
if (!strcmp ("icon", (char *)grpStr))
|
||
{
|
||
*pGroup |= F_GROUP_ICON;
|
||
}
|
||
else if (!strcmp ("window", (char *)grpStr))
|
||
{
|
||
*pGroup |= F_GROUP_WINDOW;
|
||
}
|
||
else if (!strcmp ("transient", (char *)grpStr))
|
||
{
|
||
*pGroup |= F_GROUP_TRANSIENT;
|
||
}
|
||
else
|
||
/* Unknown group name */
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 19, "Invalid group specification")));
|
||
return (FALSE);
|
||
}
|
||
|
||
/*
|
||
* Continue processing until the line is exhausted.
|
||
* Skip any '|' .
|
||
*/
|
||
|
||
ScanWhitespace (&lineP);
|
||
|
||
if (lineP == NULL || *lineP == '\0')
|
||
{
|
||
break;
|
||
}
|
||
else if (*lineP == '|')
|
||
{
|
||
lineP++;
|
||
}
|
||
}
|
||
|
||
*linePP = lineP;
|
||
return (TRUE);
|
||
|
||
} /* END OF FUNCTION ParseWmFuncGrpArg */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseWmFuncNbrArg (linePP, wmFunction, pNumber)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parses a window manager function number argument.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* wmFunction = function
|
||
* pNumber = pointer to number argument destination.
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* pNumber = pointer to parsed number argument.
|
||
* Return = FALSE iff invalid number argument.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseWmFuncNbrArg (unsigned char **linePP,
|
||
WmFunction wmFunction,
|
||
unsigned long *pNumber)
|
||
{
|
||
int val;
|
||
|
||
val = StrToNum (GetString (linePP));
|
||
if (val == -1)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 20, "Invalid number specification")));
|
||
*pNumber = 0;
|
||
return (FALSE);
|
||
}
|
||
|
||
*pNumber = val;
|
||
return (TRUE);
|
||
|
||
} /* END OF FUNCTION ParseWmFuncNbrArg */
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseButtonStr ()
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function parses a button set specification string:
|
||
*
|
||
* bindings_name
|
||
* {
|
||
* button context function
|
||
* button context function
|
||
* ...
|
||
* button context function
|
||
* }
|
||
*
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pSD->buttonBindings = buttonBindings resource value
|
||
* functionTable = window manager function parse table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* pSD->buttonSpecs = list of button binding specifications.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* The button set specification name must match pSD->buttonBindings.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
void ParseButtonStr (WmScreenData *pSD, unsigned char *buttonStr)
|
||
{
|
||
unsigned char *lineP;
|
||
|
||
cfileP = NULL;
|
||
linec = 0;
|
||
if (((parseP = buttonStr) != NULL) && (GetNextLine () != NULL))
|
||
{
|
||
lineP = line;
|
||
ParseButtonSet (pSD, lineP);
|
||
}
|
||
|
||
} /* END OF FUNCTION ParseButtonStr */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseButtonSet (pSD, lineP)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Button set specification found. Parse the following syntax:
|
||
*
|
||
* v
|
||
* Buttons bindings_name
|
||
* {
|
||
* button context function
|
||
* button context function
|
||
* ...
|
||
* button context function
|
||
* }
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* cfileP = (global) file pointer to fopened configuration file or NULL
|
||
* line = (global) line buffer
|
||
* lineP = pointer to current character in line buffer
|
||
* pSD->buttonBindings = buttonBindings resource value
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* lineP = pointer to current character in line buffer
|
||
* pSD->buttonSpecs = list of button binding specifications.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* Skips unnamed button binding set and sets with names that don't match
|
||
* the buttonBindings resource.
|
||
* Skips bad button binding specifications.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void ParseButtonSet (WmScreenData *pSD, unsigned char *lineP)
|
||
{
|
||
unsigned char *string;
|
||
ButtonSpec *buttonSpec;
|
||
ButtonSpec *lastButtonSpec;
|
||
int ix;
|
||
|
||
/*
|
||
* Parse the button set bindings from the configuration file.
|
||
* If either the button set name or buttonBindings resource is NULL or
|
||
* they don't match, then skip this button specification.
|
||
*/
|
||
|
||
if (((string = GetString (&lineP)) == NULL) ||
|
||
(pSD->buttonBindings == NULL) ||
|
||
strcmp ((char *)string, pSD->buttonBindings))
|
||
{
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* Require leading '{' on the next line.
|
||
*/
|
||
while ((GetNextLine () != NULL)) /* not EOF nor read error */
|
||
{
|
||
lineP = line;
|
||
ScanWhitespace(&lineP);
|
||
|
||
if ((lineP == NULL) || (*line == '!') || (*lineP == '\0') || (*lineP == '#'))
|
||
/* ignore empty or comment line */
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (*lineP == '{')
|
||
/* found '{' */
|
||
{
|
||
break;
|
||
}
|
||
|
||
/* not a '{' */
|
||
PWarning (((char *)GETMESSAGE(60, 21, "Expected '{' after button set name")));
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* Found leading "{" or EOF.
|
||
* Prepare to accumulate button bindings by finding the end of
|
||
* the button specification list.
|
||
* lastButtonSpec will be NULL only if no prior bindings exist.
|
||
*/
|
||
|
||
lastButtonSpec = pSD->buttonSpecs;
|
||
if (lastButtonSpec != NULL)
|
||
{
|
||
while (lastButtonSpec->nextButtonSpec != NULL)
|
||
{
|
||
lastButtonSpec = (lastButtonSpec->nextButtonSpec);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Parse "button context function" until "}" or EOF found.
|
||
* Skips bad button binding specifications.
|
||
*/
|
||
|
||
while ((GetNextLine () != NULL)) /* not EOF nor read error */
|
||
{
|
||
lineP = line;
|
||
ScanWhitespace(&lineP);
|
||
if ((lineP == NULL) || (*line == '!') || (*lineP == '\0') || (*lineP == '#'))
|
||
/* ignore empty or comment lines */
|
||
{
|
||
continue;
|
||
}
|
||
if (*lineP == '}') /* finished with button set */
|
||
{
|
||
break;
|
||
}
|
||
|
||
/*
|
||
* Allocate space for the button binding specification.
|
||
*/
|
||
if ((buttonSpec = (ButtonSpec *)XtMalloc (sizeof (ButtonSpec))) == NULL)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 22, "Insufficient memory for button specification")));
|
||
continue;
|
||
}
|
||
buttonSpec->wmFunction = (WmFunction)NULL;
|
||
buttonSpec->wmFuncArgs = NULL;
|
||
buttonSpec->nextButtonSpec = NULL;
|
||
|
||
/*
|
||
* Parse the button specification "button".
|
||
*/
|
||
lineP = line;
|
||
if (!ParseBtnEvent(&lineP,
|
||
&buttonSpec->eventType,
|
||
&buttonSpec->button,
|
||
&buttonSpec->state,
|
||
&buttonSpec->click))
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 23, "Invalid button specification")));
|
||
XtFree ((char *)buttonSpec);
|
||
continue; /* skip this button specification */
|
||
}
|
||
|
||
|
||
/*
|
||
* Parse the button context.
|
||
*/
|
||
if (!ParseContext(&lineP, &buttonSpec->context,
|
||
&buttonSpec->subContext))
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 24, "Invalid button context")));
|
||
XtFree ((char *)buttonSpec);
|
||
continue; /* skip this button specification */
|
||
}
|
||
|
||
/*
|
||
* Parse the button function and any arguments.
|
||
*/
|
||
|
||
ix = ParseWmFunction (&lineP, CRS_BUTTON, &buttonSpec->wmFunction);
|
||
|
||
/*
|
||
* remove any subContexts that don't apply to this function
|
||
*/
|
||
|
||
if ((functionTable[ix].greyedContext & F_SUBCONTEXT_IB_IICON) &&
|
||
(buttonSpec->subContext & F_SUBCONTEXT_IB_IICON))
|
||
{
|
||
buttonSpec->subContext &= ~F_SUBCONTEXT_IB_IICON;
|
||
}
|
||
|
||
if ((functionTable[ix].greyedContext & F_SUBCONTEXT_IB_WICON) &&
|
||
(buttonSpec->subContext & F_SUBCONTEXT_IB_WICON))
|
||
{
|
||
buttonSpec->subContext &= ~F_SUBCONTEXT_IB_WICON;
|
||
}
|
||
|
||
/*
|
||
* Map Button3 menus to BMenu virtual button
|
||
*/
|
||
if (buttonSpec->button == Button3 &&
|
||
(buttonSpec->wmFunction == F_Menu ||
|
||
buttonSpec->wmFunction == F_Post_SMenu)) {
|
||
|
||
buttonSpec->button = wmGD.bMenuButton;
|
||
}
|
||
|
||
/*
|
||
* Apply the function argument parser.
|
||
*/
|
||
if (!(*(functionTable [ix].parseProc))
|
||
(&lineP, buttonSpec->wmFunction, &buttonSpec->wmFuncArgs))
|
||
{
|
||
XtFree ((char *)buttonSpec);
|
||
continue; /* skip this button specification */
|
||
}
|
||
|
||
/*
|
||
* Add the button specification to the button specification list.
|
||
*/
|
||
if (lastButtonSpec != NULL)
|
||
/* a prior specification exists */
|
||
{
|
||
lastButtonSpec->nextButtonSpec = buttonSpec;
|
||
}
|
||
else
|
||
{
|
||
pSD->buttonSpecs = buttonSpec;
|
||
}
|
||
lastButtonSpec = buttonSpec;
|
||
}
|
||
|
||
} /* END OF FUNCTION ParseButtonSet */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseContext (linePP, context, subContext)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parses a general context string.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* context = context field value
|
||
* subContext = subContext field value
|
||
* Return = (Boolean) true iff valid context string
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseContext (unsigned char **linePP, Context *context,
|
||
Context *subContext)
|
||
{
|
||
unsigned char *lineP = *linePP;
|
||
unsigned char *startP;
|
||
unsigned char ctxStr[MAX_CONTEXT_STRLEN+1];
|
||
int len;
|
||
|
||
/*
|
||
* Parse contexts while each is followed by "|".
|
||
*/
|
||
|
||
*context = 0;
|
||
*subContext = 0;
|
||
while (1) {
|
||
|
||
/*
|
||
* Skip whitespace and find next context string.
|
||
*/
|
||
ScanWhitespace (&lineP);
|
||
startP = lineP;
|
||
ScanAlphanumeric (&lineP);
|
||
if (startP == lineP)
|
||
/* ERROR: Context missing */
|
||
{
|
||
return (FALSE);
|
||
}
|
||
|
||
/*
|
||
* Found nonNULL string; compare it with valid contexts.
|
||
*/
|
||
|
||
len = min(lineP - startP, MAX_CONTEXT_STRLEN);
|
||
(void) strncpy ((char *)ctxStr, (char *)startP, len);
|
||
ctxStr[len] = '\0';
|
||
ToLower ((char *)ctxStr);
|
||
|
||
if (!strcmp ("root", (char *)ctxStr))
|
||
{
|
||
*context |= F_CONTEXT_ROOT;
|
||
*subContext |= F_SUBCONTEXT_R_ALL;
|
||
}
|
||
else if (!strcmp ("icon", (char *)ctxStr))
|
||
{
|
||
*context |= (F_CONTEXT_ICON |
|
||
F_CONTEXT_ICONBOX |
|
||
F_SUBCONTEXT_IB_IICON |
|
||
F_SUBCONTEXT_IB_WICON );
|
||
*subContext |= (F_SUBCONTEXT_I_ALL |
|
||
F_SUBCONTEXT_IB_IICON |
|
||
F_SUBCONTEXT_IB_WICON );
|
||
}
|
||
else if (!strcmp ("window", (char *)ctxStr))
|
||
{
|
||
*context |= F_CONTEXT_WINDOW;
|
||
*subContext |= F_SUBCONTEXT_W_ALL;
|
||
}
|
||
else if (!strcmp ("frame", (char *)ctxStr))
|
||
{
|
||
*context |= F_CONTEXT_WINDOW;
|
||
*subContext |= F_SUBCONTEXT_W_FRAME;
|
||
}
|
||
else if (!strcmp ("title", (char *)ctxStr))
|
||
{
|
||
*context |= F_CONTEXT_WINDOW;
|
||
*subContext |= F_SUBCONTEXT_W_TITLE;
|
||
}
|
||
else if (!strcmp ("border", (char *)ctxStr))
|
||
{
|
||
*context |= F_CONTEXT_WINDOW;
|
||
*subContext |= F_SUBCONTEXT_W_BORDER;
|
||
}
|
||
else if (!strcmp ("app", (char *)ctxStr))
|
||
{
|
||
*context |= F_CONTEXT_WINDOW;
|
||
*subContext |= F_SUBCONTEXT_W_APP;
|
||
}
|
||
else if (!strcmp ("ifkey", (char *)ctxStr))
|
||
{
|
||
*context |= F_CONTEXT_IFKEY;
|
||
}
|
||
else
|
||
/* Unknown context name */
|
||
{
|
||
return (FALSE);
|
||
}
|
||
|
||
/* continue only if followed by '|' */
|
||
ScanWhitespace (&lineP);
|
||
if (*lineP != '|')
|
||
{
|
||
break;
|
||
}
|
||
lineP++;
|
||
}
|
||
|
||
*linePP = lineP;
|
||
return (TRUE);
|
||
|
||
} /* END OF FUNCTION ParseContext */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseKeyStr ()
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function parses a key set specification string:
|
||
*
|
||
* bindings_name
|
||
* {
|
||
* key context function
|
||
* key context function
|
||
* ...
|
||
* key context function
|
||
* }
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pSD->keyBindings = keyBindings resource value
|
||
* functionTable = window manager function parse table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* pSD->keySpecs = list of key binding specification
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* The key set specification name must match pSD->keyBindings.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
void
|
||
ParseKeyStr (WmScreenData *pSD, unsigned char *keyStr)
|
||
{
|
||
unsigned char *lineP;
|
||
|
||
cfileP = NULL;
|
||
linec = 0;
|
||
if (((parseP = keyStr) != NULL) && (GetNextLine () != NULL))
|
||
{
|
||
lineP = line;
|
||
ParseKeySet (pSD, lineP);
|
||
}
|
||
|
||
} /* END OF FUNCTION ParseKeyStr */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseKeySet (pSD, lineP)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Key set specification found. Parse the following syntax:
|
||
*
|
||
* v
|
||
* Keys bindings_name
|
||
* {
|
||
* key context function
|
||
* key context function
|
||
* ...
|
||
* key context function
|
||
* }
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* cfileP = (global) file pointer to fopened configuration file or NULL
|
||
* line = (global) line buffer
|
||
* lineP = pointer to current character in line buffer
|
||
* pSD->keyBindings = keyBindings resource value
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* lineP = pointer to current character in line buffer
|
||
* pSD->keySpecs = list of key binding specifications.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* Skips unnamed key binding set and sets with names that don't match the
|
||
* keyBindings resource.
|
||
* Skips bad key binding specifications.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void ParseKeySet (WmScreenData *pSD, unsigned char *lineP)
|
||
{
|
||
unsigned char *string;
|
||
KeySpec *keySpec;
|
||
KeySpec *lastKeySpec;
|
||
unsigned int eventType;
|
||
int ix;
|
||
Boolean bBadKey;
|
||
|
||
/*
|
||
* Parse the key set bindings from the configuration file.
|
||
* If either the key set name or keyBindings resource is NULL or they
|
||
* don't match then skip this key specification.
|
||
*/
|
||
|
||
if (((string = GetString (&lineP)) == NULL) ||
|
||
(pSD->keyBindings == NULL) ||
|
||
strcmp ((char *)string, pSD->keyBindings))
|
||
{
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* Require leading '{' on next line.
|
||
*/
|
||
while ((GetNextLine () != NULL)) /* not EOF nor read error */
|
||
{
|
||
lineP = line;
|
||
ScanWhitespace(&lineP);
|
||
|
||
if ((lineP == NULL) || (*line == '!') || (*lineP == '\0') || (*lineP == '#'))
|
||
/* ignore empty or comment line */
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (*lineP == '{')
|
||
/* found '{' */
|
||
{
|
||
break;
|
||
}
|
||
|
||
/* not a '{' */
|
||
PWarning (((char *)GETMESSAGE(60, 25, "Expected '{' after key set name")));
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* Found leading "{" or EOF.
|
||
* Prepare to accumulate key bindings by finding the end of
|
||
* the key specification list.
|
||
* lastKeySpec will be NULL only if no prior bindings exist.
|
||
*/
|
||
|
||
lastKeySpec = pSD->keySpecs;
|
||
if (lastKeySpec != NULL)
|
||
{
|
||
while (lastKeySpec->nextKeySpec != NULL)
|
||
{
|
||
lastKeySpec = (lastKeySpec->nextKeySpec);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Parse "key context function" until "}" or EOF found.
|
||
* Skip bad key bindings.
|
||
*/
|
||
|
||
while ((GetNextLine () != NULL)) /* not EOF nor read error */
|
||
{
|
||
lineP = line;
|
||
ScanWhitespace (&lineP);
|
||
if ((lineP == NULL) || (*line == '!') || (*lineP == '\0') || (*lineP == '#'))
|
||
/* ignore empty or comment lines */
|
||
{
|
||
continue;
|
||
}
|
||
if (*lineP == '}') /* finished with key set */
|
||
{
|
||
break;
|
||
}
|
||
|
||
/*
|
||
* Allocate space for the key specification.
|
||
*/
|
||
if ((keySpec = (KeySpec *)XtMalloc (sizeof (KeySpec))) == NULL)
|
||
{
|
||
PWarning (((char *)GETMESSAGE(60, 26, "Insufficient memory for key specification")));
|
||
continue;
|
||
}
|
||
|
||
keySpec->wmFunction = (WmFunction)NULL;
|
||
keySpec->wmFuncArgs = NULL;
|
||
keySpec->nextKeySpec = NULL;
|
||
|
||
/*
|
||
* Parse the key specification.
|
||
*/
|
||
bBadKey = False;
|
||
if (!ParseKeyEvent(&lineP,
|
||
&eventType,
|
||
&keySpec->keycode,
|
||
&keySpec->state))
|
||
{
|
||
bBadKey = True;
|
||
}
|
||
|
||
/*
|
||
* Parse the key context.
|
||
* Here lineP points to the candidate context string.
|
||
*/
|
||
|
||
if (!ParseContext(&lineP, &keySpec->context,
|
||
&keySpec->subContext))
|
||
{
|
||
if (bBadKey)
|
||
PWarning (((char *)GETMESSAGE(60, 27, "Invalid key specification")));
|
||
PWarning (((char *)GETMESSAGE(60, 28, "Invalid key context")));
|
||
XtFree ((char *)keySpec);
|
||
continue; /* skip this key specification */
|
||
}
|
||
if (bBadKey)
|
||
{
|
||
/*
|
||
* Don't print an error message if this is a "hardware
|
||
* available" binding.
|
||
*/
|
||
if (!(keySpec->context & F_CONTEXT_IFKEY))
|
||
PWarning (((char *)GETMESSAGE(60, 27, "Invalid key specification")));
|
||
XtFree ((char *)keySpec);
|
||
continue; /* skip this key specification */
|
||
}
|
||
|
||
/*
|
||
* This flag is only used for parsing, clear it so the
|
||
* rest of the program doesn't see it.
|
||
*/
|
||
keySpec->context &= ~F_CONTEXT_IFKEY;
|
||
|
||
|
||
/*
|
||
* Parse the key function and any arguments.
|
||
*/
|
||
|
||
ix = ParseWmFunction (&lineP, CRS_KEY, &keySpec->wmFunction);
|
||
|
||
/*
|
||
* remove any subContexts that don't apply to this function
|
||
*/
|
||
if ((functionTable[ix].greyedContext & F_SUBCONTEXT_IB_IICON) &&
|
||
(keySpec->subContext & F_SUBCONTEXT_IB_IICON))
|
||
{
|
||
keySpec->subContext &= ~F_SUBCONTEXT_IB_IICON;
|
||
}
|
||
|
||
if ((functionTable[ix].greyedContext & F_SUBCONTEXT_IB_WICON) &&
|
||
(keySpec->subContext & F_SUBCONTEXT_IB_WICON))
|
||
{
|
||
keySpec->subContext &= ~F_SUBCONTEXT_IB_WICON;
|
||
}
|
||
|
||
/*
|
||
* Apply the function argument parser.
|
||
*/
|
||
if (!(*(functionTable [ix].parseProc))
|
||
(&lineP, keySpec->wmFunction, &keySpec->wmFuncArgs))
|
||
{
|
||
XtFree ((char *)keySpec);
|
||
continue; /* skip this key specification */
|
||
}
|
||
|
||
/*
|
||
* Add the key specification to the key specification list.
|
||
*/
|
||
if (lastKeySpec != NULL)
|
||
/* a prior specification exists */
|
||
{
|
||
lastKeySpec->nextKeySpec = keySpec;
|
||
}
|
||
else
|
||
{
|
||
pSD->keySpecs = keySpec;
|
||
}
|
||
lastKeySpec = keySpec;
|
||
}
|
||
|
||
} /* END OF FUNCTION ParseKeySet */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseBtnEvent (linePP, eventType, button, state, fClick)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parse a button event specification.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer
|
||
* buttonEvents = (global) button event parse table
|
||
* modifierStrings = (global) modifier string/mask table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* eventType = type of event
|
||
* button = parsed button number
|
||
* state = composite modifier mask
|
||
* fClick = is click?
|
||
*
|
||
* Return = (Boolean) true iff valid button event specification
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
Boolean ParseBtnEvent (unsigned char **linePP,
|
||
unsigned int *eventType,
|
||
unsigned int *button,
|
||
unsigned int *state,
|
||
Boolean *fClick)
|
||
{
|
||
if (!ParseEvent (linePP, buttonEvents, eventType, button, state, fClick))
|
||
{
|
||
return (FALSE);
|
||
}
|
||
|
||
/*
|
||
* The following is a fix for an X11 deficiency in regards to
|
||
* modifiers in grabs.
|
||
*/
|
||
if (*eventType == ButtonRelease)
|
||
{
|
||
/* the button that is going up will always be in the modifiers... */
|
||
*state |= buttonModifierMasks[*button];
|
||
}
|
||
|
||
return (TRUE);
|
||
|
||
} /* END OF FUNCTION ParseBtnEvent */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseKeyEvent (linePP, eventType, keyCode, state)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parse a key event specification.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer
|
||
* keyEvents = (global) key event parse table
|
||
* modifierStrings = (global) modifier string/mask table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* eventType = type of event
|
||
* keyCode = parsed KeyCode
|
||
* state = composite modifier mask
|
||
*
|
||
* Return = (Boolean) true iff valid key event specification
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
Boolean ParseKeyEvent (unsigned char **linePP, unsigned int *eventType,
|
||
KeyCode *keyCode, unsigned int *state)
|
||
|
||
|
||
{
|
||
Boolean fClick;
|
||
unsigned int keySym = 0;
|
||
|
||
if (!ParseEvent (linePP, keyEvents, eventType, &keySym, state, &fClick))
|
||
{
|
||
return (FALSE);
|
||
}
|
||
|
||
/*
|
||
* Here keySym is a KeySym. Convert it to a KeyCode.
|
||
* KeyCode will be set to 0 if keySym is not defined for any KeyCode
|
||
* (e.g. 0x001).
|
||
*/
|
||
|
||
*keyCode = XKeysymToKeycode(DISPLAY, (KeySym) keySym);
|
||
|
||
if (*keyCode == 0)
|
||
{
|
||
if (keySym == XK_F9)
|
||
{
|
||
keySym = XK_KP_F1;
|
||
}
|
||
else if (keySym == XK_F10)
|
||
{
|
||
keySym = XK_KP_F2;
|
||
}
|
||
else if (keySym == XK_F11)
|
||
{
|
||
keySym = XK_KP_F3;
|
||
}
|
||
else if (keySym == XK_F12)
|
||
{
|
||
keySym = XK_KP_F4;
|
||
}
|
||
*keyCode = XKeysymToKeycode(DISPLAY, (KeySym) keySym);
|
||
}
|
||
|
||
return (*keyCode != 0);
|
||
|
||
} /* END OF FUNCTION ParseKeyEvent */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseEvent (linePP, table, eventType, detail, state, fClick)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parse an event specification.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* table = event parse table
|
||
* modifierStrings = (global) modifier string/mask table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* eventType = type of event
|
||
* detail = dependent upon parse table detail procedure and closure
|
||
* state = composite modifier mask
|
||
* fClick = click flag
|
||
*
|
||
* Return = (Boolean) true iff valid event specification
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseEvent (unsigned char **linePP, EventTableEntry *table,
|
||
unsigned int *eventType, unsigned int *detail,
|
||
unsigned int *state, Boolean *fClick)
|
||
{
|
||
unsigned char *lineP = *linePP;
|
||
Cardinal ix;
|
||
Boolean status;
|
||
|
||
/* Parse the modifiers */
|
||
if (!ParseModifiers (&lineP, state) || *lineP != '<')
|
||
{
|
||
return (FALSE);
|
||
}
|
||
lineP++; /* skip '<' */
|
||
|
||
/* Parse the event type */
|
||
if (!ParseEventType (&lineP, table, eventType, &ix) || *lineP != '>')
|
||
{
|
||
return (FALSE);
|
||
}
|
||
lineP++; /* skip '>' */
|
||
|
||
/*
|
||
* Compute detail and fClick.
|
||
* Status will be False for a invalid KeySym name.
|
||
*/
|
||
status = (*(table[ix].parseProc))(&lineP, table[ix].closure, detail);
|
||
*fClick = table[ix].fClick;
|
||
|
||
if (status)
|
||
{
|
||
*linePP = lineP;
|
||
}
|
||
return (status);
|
||
|
||
} /* END OF FUNCTION ParseEvent */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseModifiers(linePP, state)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parses a modifier specification.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* modifierStrings = (global) modifier string/mask table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* state = composite modifier mask
|
||
* Return = (Boolean) true iff valid modifier name
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* If successful, will be followed by NULL or '<'.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseModifiers(unsigned char **linePP, unsigned int *state)
|
||
{
|
||
unsigned char *lineP = *linePP;
|
||
unsigned char *startP;
|
||
unsigned char modStr[MAX_MODIFIER_STRLEN+1];
|
||
Boolean fNot;
|
||
unsigned int maskBit;
|
||
int len;
|
||
|
||
*state = 0;
|
||
|
||
/*
|
||
* Parse modifiers until the event specifier is encountered.
|
||
*/
|
||
|
||
ScanWhitespace (&lineP);
|
||
while ((*lineP != '\0') && (*lineP != '<'))
|
||
{
|
||
if (*lineP == '~')
|
||
{
|
||
fNot = TRUE;
|
||
lineP++;
|
||
}
|
||
else
|
||
{
|
||
fNot = FALSE;
|
||
}
|
||
|
||
startP = lineP;
|
||
ScanAlphanumeric (&lineP);
|
||
if (startP == lineP)
|
||
/* ERROR: Modifier or '<' missing */
|
||
{
|
||
return (FALSE);
|
||
}
|
||
len = min(lineP - startP, MAX_MODIFIER_STRLEN);
|
||
(void) strncpy ((char *)modStr, (char *)startP, len);
|
||
modStr[len] = '\0';
|
||
|
||
if (!LookupModifier (modStr, &maskBit))
|
||
/* Unknown modifier name */
|
||
{
|
||
return (FALSE);
|
||
}
|
||
|
||
if (fNot)
|
||
{
|
||
*state &= ~maskBit;
|
||
}
|
||
else
|
||
{
|
||
*state |= maskBit;
|
||
}
|
||
ScanWhitespace(&lineP);
|
||
}
|
||
|
||
*linePP = lineP;
|
||
return (TRUE); /* must have '<' or NULL following */
|
||
|
||
} /* END OF FUNCTION ParseModifiers */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* LookupModifier (name, valueP)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Return the modifier mask for the provided modifier name.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* name = modifier string
|
||
* modifierStrings = modifier string/mask table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* valueP = modifier mask
|
||
* Return = (Boolean) true iff valid modifier name
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean LookupModifier (unsigned char *name, unsigned int *valueP)
|
||
{
|
||
int i;
|
||
|
||
if (name != NULL)
|
||
{
|
||
ToLower ((char *)name);
|
||
for (i=0; modifierStrings[i].name != NULL; i++)
|
||
{
|
||
if (!strcmp (modifierStrings[i].name, (char *)name))
|
||
{
|
||
*valueP = modifierStrings[i].mask;
|
||
return (TRUE);
|
||
}
|
||
}
|
||
}
|
||
|
||
return (FALSE);
|
||
|
||
} /* END OF FUNCTION LookupModifier */
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseEventType(linePP, table, eventType, ix)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parses the event type string.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* table = event parse table
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* eventType = type of event
|
||
* ix = table index for matched event
|
||
*
|
||
* Return = (Boolean) true iff valid event
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseEventType (unsigned char **linePP, EventTableEntry *table,
|
||
unsigned int *eventType, Cardinal *ix)
|
||
{
|
||
unsigned char *lineP = *linePP;
|
||
unsigned char *startP = *linePP;
|
||
unsigned char eventTypeStr[MAX_EVENTTYPE_STRLEN+1];
|
||
int len;
|
||
|
||
/* Parse out the event string */
|
||
ScanAlphanumeric (&lineP);
|
||
|
||
/*
|
||
* Attempt to match the parsed event against our supported event set.
|
||
*/
|
||
|
||
if (startP != lineP)
|
||
{
|
||
len = min (lineP - startP, MAX_EVENTTYPE_STRLEN);
|
||
(void) strncpy ((char *)eventTypeStr, (char *)startP, len);
|
||
eventTypeStr[len] = '\0';
|
||
ToLower ((char *)eventTypeStr);
|
||
|
||
for (len = 0; table[len].event != NULL; len++)
|
||
if (!strcmp (table[len].event, (char *)eventTypeStr))
|
||
{
|
||
*ix = len;
|
||
*eventType = table[*ix].eventType;
|
||
*linePP = lineP;
|
||
return (TRUE);
|
||
}
|
||
}
|
||
|
||
/* Unknown event specified */
|
||
return (FALSE);
|
||
|
||
} /* END OF FUNCTION ParseEventType */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseImmed (linePP, closure, detail)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Button event detail procedure.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = not used
|
||
* closure = table entry
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* detail = pointer to closure
|
||
*
|
||
* Return = TRUE
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseImmed (unsigned char **linePP, unsigned int closure,
|
||
unsigned int *detail)
|
||
{
|
||
*detail = closure;
|
||
return (TRUE);
|
||
|
||
} /* END OF FUNCTION ParseImmed */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseKeySym (linePP, closure, detail)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Key event detail procedure. Parses a KeySym string.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer
|
||
*
|
||
* closure = not used.
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer
|
||
* detail = pointer to parsed KeySym
|
||
*
|
||
* Return = (Boolean) true iff valid KeySym string
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static Boolean ParseKeySym (unsigned char **linePP, unsigned int closure,
|
||
unsigned int *detail)
|
||
{
|
||
unsigned char *lineP = *linePP;
|
||
unsigned char *startP;
|
||
char keySymName[MAX_KEYSYM_STRLEN+1];
|
||
int len;
|
||
int chlen;
|
||
|
||
ScanWhitespace (&lineP);
|
||
startP = lineP;
|
||
|
||
while (*lineP &&
|
||
((chlen = mblen ((char *)lineP, MB_CUR_MAX)) > 0) &&
|
||
((chlen > 1) ||
|
||
(!isspace (*lineP) && *lineP != ',' && *lineP != ':')))
|
||
{
|
||
/* Skip next character */
|
||
lineP += chlen;
|
||
}
|
||
|
||
len = min (lineP - startP, MAX_KEYSYM_STRLEN);
|
||
(void) strncpy (keySymName, (char *)startP, len);
|
||
keySymName[len] = '\0';
|
||
|
||
if ((*detail = XStringToKeysym(keySymName)) == NoSymbol &&
|
||
(mblen (keySymName, MB_CUR_MAX) == 1))
|
||
{
|
||
if (!isdigit (keySymName[0]) ||
|
||
((*detail = StrToNum ((unsigned char *)&keySymName[0])) == -1))
|
||
{
|
||
*detail = NoSymbol;
|
||
return (FALSE);
|
||
}
|
||
}
|
||
*linePP = lineP;
|
||
return (TRUE);
|
||
|
||
} /* END OF FUNCTION ParseKeySym */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* StrToNum(str)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Converts a string to an unsigned hexadecimal, decimal, or octal integer.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* str = character string
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* Return = unsigned integer
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static unsigned int StrToNum(unsigned char *str)
|
||
{
|
||
unsigned char c;
|
||
unsigned int val = 0;
|
||
|
||
if (*str == '0')
|
||
{
|
||
str++;
|
||
if (*str == 'x' || *str == 'X')
|
||
{
|
||
return (StrToHex(++str));
|
||
}
|
||
return (StrToOct(str));
|
||
}
|
||
|
||
while ((c = *str) != '\0')
|
||
{
|
||
if ('0' <= c && c <= '9')
|
||
{
|
||
val = val*10+c-'0';
|
||
}
|
||
else
|
||
{
|
||
return (-1);
|
||
}
|
||
str++;
|
||
}
|
||
|
||
return (val);
|
||
|
||
} /* END OF FUNCTION StrToNum */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static unsigned int StrToHex(unsigned char *str)
|
||
{
|
||
unsigned char c;
|
||
unsigned int val = 0;
|
||
|
||
while ((c = *str) != '\0')
|
||
{
|
||
if ('0' <= c && c <= '9')
|
||
{
|
||
val = val*16+c-'0';
|
||
}
|
||
else if ('a' <= c && c <= 'f')
|
||
{
|
||
val = val*16+c-'a'+10;
|
||
}
|
||
else if ('A' <= c && c <= 'F')
|
||
{
|
||
val = val*16+c-'A'+10;
|
||
}
|
||
else
|
||
{
|
||
return (-1);
|
||
}
|
||
str++;
|
||
}
|
||
|
||
return (val);
|
||
|
||
} /* END OF FUNCTION StrToHex */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static unsigned int StrToOct(unsigned char *str)
|
||
{
|
||
unsigned char c;
|
||
unsigned int val = 0;
|
||
|
||
while ((c = *str) != '\0')
|
||
{
|
||
if ('0' <= c && c <= '7')
|
||
{
|
||
val = val*8+c-'0';
|
||
}
|
||
else
|
||
{
|
||
return (-1);
|
||
}
|
||
str++;
|
||
}
|
||
|
||
return (val);
|
||
|
||
} /* END OF FUNCTION StrToOct */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ScanAlphanumeric (linePP)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Scan string until a non-alphanumeric character is encountered.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = nonNULL pointer to current line buffer pointer
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = nonNULL pointer to revised line buffer pointer
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* Assumes linePP is nonNULL
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
void ScanAlphanumeric (unsigned char **linePP)
|
||
{
|
||
int chlen;
|
||
|
||
while (*linePP &&
|
||
((chlen = mblen ((char *) *linePP, MB_CUR_MAX)) > 0) &&
|
||
((chlen > 1) || isalnum (**linePP)))
|
||
{
|
||
(*linePP) += chlen;
|
||
}
|
||
} /* END OF FUNCTION ScanAlphanumeric */
|
||
|
||
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* PWarning (message)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function lists a resource description parse message to stderr.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* message = pointer to a message string
|
||
* cfileP = (global) file pointer to fopened configuration file or NULL
|
||
* linec = (global) line counter
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
void
|
||
PWarning (char *message)
|
||
{
|
||
|
||
char pch[MAXWMPATH+1];
|
||
String sMessage;
|
||
char *pchFile;
|
||
|
||
sMessage = XtNewString ((String) message);
|
||
if (cfileP != NULL)
|
||
{
|
||
if (pConfigStackTop->fileName)
|
||
{
|
||
pchFile = pConfigStackTop->fileName;
|
||
}
|
||
else
|
||
{
|
||
pchFile = wmGD.configFile;
|
||
}
|
||
|
||
sprintf (pch, pWarningStringFile,
|
||
GETMESSAGE(20,1,"Workspace Manager"),
|
||
sMessage, linec, pchFile);
|
||
}
|
||
else
|
||
{
|
||
sprintf (pch, pWarningStringLine,
|
||
GETMESSAGE(20,1,"Workspace Manager"),
|
||
sMessage, linec);
|
||
}
|
||
_DtSimpleError (wmGD.mwmName, DtIgnore, NULL, pch, NULL);
|
||
XtFree (sMessage);
|
||
|
||
|
||
} /* END OF FUNCTION PWarning */
|
||
|
||
/*
|
||
* Key substitution table entry
|
||
*/
|
||
|
||
typedef struct _keySubs
|
||
{
|
||
unsigned char * pchFrom;
|
||
int lenFrom;
|
||
unsigned char * pchTo;
|
||
} KeySub;
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* InitKeySubs (ppKeySubs, pNumKeySubs)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Initialize key label substitutions used in acclerator text
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* ppKeySubs = ptr to key substitution table ptr
|
||
* pNumKeySubs = ptr to number of key substitutions
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* *ppKeySubs = ptr to key substitution table
|
||
* *pNumKeySubs = number of substitutions found
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* *ppKeySubs is allocated with XtMalloc in a complicated way.
|
||
* If this ever needs to be freed, a function to free it needs to
|
||
* be written.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void InitKeySubs (
|
||
KeySub **ppKeySubs,
|
||
int *pNumKeySubs)
|
||
{
|
||
int numKS;
|
||
KeySub *pKS;
|
||
KeySub *pKSret;
|
||
unsigned char *pch0;
|
||
unsigned char *pch1;
|
||
int len;
|
||
int chlen;
|
||
|
||
pch0 = (unsigned char *)GETMESSAGE(60, 40, "");
|
||
|
||
if ((pch0 == NULL) || (*pch0 == '\0'))
|
||
{
|
||
*ppKeySubs = NULL;
|
||
*pNumKeySubs = 0;
|
||
return;
|
||
}
|
||
|
||
pKSret = NULL;
|
||
numKS = 0;
|
||
|
||
while (*pch0 != '\0')
|
||
{
|
||
ScanWhitespace (&pch0);
|
||
if (*pch0 == '\0') break;
|
||
|
||
/*
|
||
* allocate space for next key sub
|
||
*/
|
||
if (pKSret == NULL)
|
||
{
|
||
pKSret = (KeySub *) XtMalloc (1*sizeof(KeySub));
|
||
}
|
||
else
|
||
{
|
||
pKSret = (KeySub *) XtRealloc ((char *)pKSret,
|
||
(numKS+1)*sizeof(KeySub));
|
||
}
|
||
pKS = &pKSret[numKS];
|
||
|
||
/* get "from" string */
|
||
pch1 = pch0;
|
||
while (*pch1 && ((chlen = mblen ((char *)pch1, MB_CUR_MAX)) > 0))
|
||
{
|
||
if ((chlen == 1) && (*pch1 == ' '))
|
||
{
|
||
break;
|
||
}
|
||
pch1 += chlen;
|
||
}
|
||
pKS->lenFrom = pch1 - pch0;
|
||
if (pKS->lenFrom < 1)
|
||
{
|
||
/*
|
||
* no "from" string
|
||
*/
|
||
break;
|
||
}
|
||
pKS->pchFrom = (unsigned char *) XtMalloc (1+pKS->lenFrom);
|
||
memcpy (pKS->pchFrom, pch0, pKS->lenFrom);
|
||
pKS->pchFrom[pKS->lenFrom] = '\0';
|
||
|
||
/* get "to" string */
|
||
ScanWhitespace (&pch1);
|
||
pch0 = pch1;
|
||
|
||
while (*pch1 && ((chlen = mblen ((char *)pch1, MB_CUR_MAX)) > 0))
|
||
{
|
||
if ((chlen == 1) && (*pch1 == ' '))
|
||
{
|
||
break;
|
||
}
|
||
pch1 += chlen;
|
||
}
|
||
|
||
len = pch1 - pch0;
|
||
if (len < 1)
|
||
{
|
||
/*
|
||
* Invalid format, "from" string with no "to" string.
|
||
*/
|
||
break;
|
||
}
|
||
pKS->pchTo = (unsigned char *) XtMalloc (1+len);
|
||
memcpy (pKS->pchTo, pch0, len);
|
||
pKS->pchTo[len] = '\0';
|
||
|
||
/* advance cursor */
|
||
pch0 = pch1;
|
||
|
||
/* got one, bump the counter */
|
||
numKS++;
|
||
}
|
||
|
||
*ppKeySubs = pKSret;
|
||
*pNumKeySubs = numKS;
|
||
}
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ProcessAccelText (startP, endP, destP)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Process accelerator text and copy into string.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* startP = pointer to start of valid accelerator specification
|
||
* endP = pointer past end of accelerator specification
|
||
* destP = pointer to destination buffer
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* Destination buffer has processed accelerator text.
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* None.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void ProcessAccelText (unsigned char *startP, unsigned char *endP,
|
||
unsigned char *destP)
|
||
{
|
||
int chlen;
|
||
static Boolean bAccelInit = False;
|
||
static KeySub *pKeySub;
|
||
static int numKeySubs;
|
||
unsigned char * pchFirst;
|
||
unsigned char * pchSub;
|
||
int lenSub;
|
||
int i;
|
||
|
||
if (!bAccelInit)
|
||
{
|
||
InitKeySubs (&pKeySub, &numKeySubs);
|
||
bAccelInit = True;
|
||
}
|
||
|
||
/*
|
||
* Copy modifiers
|
||
*/
|
||
|
||
ScanWhitespace (&startP);
|
||
|
||
while (*startP != '<')
|
||
{
|
||
if (*startP == '~')
|
||
{
|
||
*destP++ = *startP++;
|
||
}
|
||
pchFirst = startP;
|
||
|
||
while (*startP &&
|
||
(((chlen = mblen ((char *)startP, MB_CUR_MAX)) > 1)
|
||
|| isalnum (*startP)))
|
||
{
|
||
while (chlen--)
|
||
{
|
||
startP++;
|
||
}
|
||
}
|
||
|
||
/* find substitution */
|
||
pchSub = NULL;
|
||
lenSub = 0;
|
||
|
||
for (i=0; i<numKeySubs; i++)
|
||
{
|
||
if ((pKeySub[i].lenFrom == startP-pchFirst) &&
|
||
(!strncasecmp ((char *)pKeySub[i].pchFrom, (char *)pchFirst,
|
||
pKeySub[i].lenFrom)))
|
||
{
|
||
pchSub = pKeySub[i].pchTo;
|
||
lenSub = strlen((char *)pchSub);
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
if ((pchSub != NULL) && (lenSub > 0))
|
||
{
|
||
memcpy (destP, pchSub, lenSub);
|
||
destP += lenSub;
|
||
}
|
||
else
|
||
{
|
||
memcpy (destP, pchFirst, startP-pchFirst);
|
||
destP += startP-pchFirst;
|
||
}
|
||
*destP++ = '+';
|
||
|
||
ScanWhitespace (&startP);
|
||
}
|
||
|
||
/*
|
||
* Skip the key event type.
|
||
*/
|
||
startP++; /* skip '<' */
|
||
while (*startP != '>')
|
||
{
|
||
startP += mblen ((char *)startP, MB_CUR_MAX);
|
||
}
|
||
startP++; /* skip '>' */
|
||
|
||
/*
|
||
* Copy the KeySym string.
|
||
*/
|
||
|
||
ScanWhitespace (&startP);
|
||
while (startP != endP)
|
||
{
|
||
*destP++ = *startP++;
|
||
}
|
||
*destP = '\0';
|
||
|
||
} /* END OF FUNCTION ProcessAccelText */
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ProcessCommandLine (argc, argv)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function looks for and processes mwm options in the command line
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* argc = argument count.
|
||
* argv = argument vector.
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* Changes global data to based on command line options recognized
|
||
*
|
||
*
|
||
*************************************<->***********************************/
|
||
#define SCREENS_OPT "-screens"
|
||
#define MULTI_SCREEN_OPT "-multiscreen"
|
||
|
||
void ProcessCommandLine (int argc, char *argv[])
|
||
{
|
||
unsigned char *string;
|
||
int argnum;
|
||
unsigned char *lineP;
|
||
|
||
for (argnum = 1; argnum < argc; argnum++)
|
||
{
|
||
lineP = (unsigned char *) argv[argnum];
|
||
if ((string = GetString (&lineP)) == NULL)
|
||
/* empty or comment line */
|
||
{
|
||
continue;
|
||
}
|
||
if (!strcmp((char *)string, MULTI_SCREEN_OPT))
|
||
{
|
||
wmGD.multiScreen = True;
|
||
wmGD.numScreens = ScreenCount (DISPLAY);
|
||
}
|
||
else if (!strcmp((char *)string, SCREENS_OPT))
|
||
{
|
||
argnum++; /* skip to next arg */
|
||
ParseScreensArgument (argc, argv, &argnum, lineP);
|
||
}
|
||
}
|
||
|
||
} /* END OF FUNCTION ProcessCommandLine */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseScreensArgument (argc, argv, pArgnum, lineP)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function processes the ``-screens'' command line argument
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* argc = argument count.
|
||
* argv = argument vector.
|
||
* pArgnum = pointer to argument number where processing left off
|
||
* lineP = pointer into argv[*pArgnum] where processing left off
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* Changes global data to based on command line options recognized
|
||
* + wmGD.screenNames
|
||
* + wmGD.numScreens
|
||
* Assumes default screenNames are already in place
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void ParseScreensArgument (int argc, char *argv[], int *pArgnum,
|
||
unsigned char *lineP)
|
||
{
|
||
unsigned char *string;
|
||
int sNum = 0;
|
||
int lastLen;
|
||
int nameCount = 0;
|
||
|
||
for (; (*pArgnum < argc) && (sNum < ScreenCount(DISPLAY));
|
||
(*pArgnum)++, sNum++)
|
||
{
|
||
lineP = (unsigned char *)argv[*pArgnum];
|
||
if (*argv[*pArgnum] == '"')
|
||
{
|
||
/*
|
||
* if Quote, use GetString to strip it
|
||
*/
|
||
if ((string = GetString (&lineP)) == NULL)
|
||
/* empty or comment line */
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
string = (unsigned char *)argv[*pArgnum];
|
||
if (*string == '-')
|
||
{
|
||
/* another option, end of screens names */
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!(wmGD.screenNames[sNum] = (unsigned char *)
|
||
XtRealloc ((char*)wmGD.screenNames[sNum],
|
||
1 + strlen((char *)string))))
|
||
{
|
||
Warning (((char *)GETMESSAGE(60, 31, "Insufficient memory for screen names")));
|
||
ExitWM(WM_ERROR_EXIT_VALUE);
|
||
}
|
||
else
|
||
{
|
||
strcpy((char *)wmGD.screenNames[sNum], (char *)string);
|
||
nameCount++;
|
||
}
|
||
}
|
||
|
||
(*pArgnum)--;
|
||
|
||
/*
|
||
* remaining screens (if any) get first name specified
|
||
*/
|
||
if (nameCount > 0)
|
||
{
|
||
lastLen = 1 + strlen((char *)wmGD.screenNames[0]);
|
||
for (; sNum < ScreenCount(DISPLAY); sNum++)
|
||
{
|
||
if (!(wmGD.screenNames[sNum] = (unsigned char *)
|
||
XtRealloc ((char*)wmGD.screenNames[sNum], lastLen)))
|
||
{
|
||
Warning (((char *)GETMESSAGE(60, 32, "Insufficient memory for screen names")));
|
||
ExitWM(WM_ERROR_EXIT_VALUE);
|
||
}
|
||
else
|
||
{
|
||
strcpy((char *)wmGD.screenNames[sNum],
|
||
(char *)wmGD.screenNames[0]);
|
||
}
|
||
}
|
||
}
|
||
|
||
} /* END OF FUNCTION ParseScreensArgument */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ProcessMotifBindings ()
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function is used retrieve the motif input bindings
|
||
* and put them into a property on the root window.
|
||
*
|
||
*
|
||
*************************************<->***********************************/
|
||
void ProcessMotifBindings (void)
|
||
{
|
||
char fileName[MAXWMPATH+1];
|
||
char *bindings = NULL;
|
||
char *homeDir = XmeGetHomeDirName();
|
||
|
||
/*
|
||
* Look in the user's home directory for .motifbind
|
||
*/
|
||
|
||
strcpy (fileName, homeDir);
|
||
strncat(fileName, "/", MAXWMPATH-strlen(fileName));
|
||
strncat(fileName, MOTIF_BINDINGS_FILE, MAXWMPATH-strlen(fileName));
|
||
|
||
XDeleteProperty (DISPLAY, RootWindow (DISPLAY, 0),
|
||
XInternAtom (DISPLAY, "_MOTIF_BINDINGS", False));
|
||
XDeleteProperty (DISPLAY, RootWindow (DISPLAY, 0),
|
||
XInternAtom (DISPLAY, "_MOTIF_DEFAULT_BINDINGS", False));
|
||
|
||
if (_XmVirtKeysLoadFileBindings (fileName, &bindings) == True) {
|
||
XChangeProperty (DISPLAY, RootWindow(DISPLAY, 0),
|
||
XInternAtom (DISPLAY, "_MOTIF_BINDINGS", False),
|
||
XA_STRING, 8, PropModeReplace,
|
||
(unsigned char *)bindings, strlen(bindings));
|
||
}
|
||
else {
|
||
_XmVirtKeysLoadFallbackBindings (DISPLAY, &bindings);
|
||
}
|
||
XtFree (bindings);
|
||
} /* END OF FUNCTION ProcessMotifBindings */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* void
|
||
* ParseWmFunctionArg (linePP, ix, wmFunc, ppArg, sClientName)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parse the function arguments for a window manager function.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to line buffer pointer (contains string arg).
|
||
* ix = window manager function index (returned by ParseWmFunction)
|
||
* pWmFunction = pointer to window manager function destination.
|
||
* ppArg = ptr to argument pointer.
|
||
* sClientName = string name of client
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* *ppArg = arg to pass to window manager function when invoking.
|
||
* Return = true on succes, false on some kind of parse error
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* functionTable (window manager function table) is indexed with ix
|
||
* to get parsing info.
|
||
*
|
||
* This function may malloc memory for the returned arg.
|
||
*
|
||
* The sClientName is needed for starting some hpterm-based push_recall
|
||
* clients. It needs to be passed into the action so the hpterm gets
|
||
* named appropriately.
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
Boolean
|
||
ParseWmFunctionArg (
|
||
unsigned char **linePP,
|
||
int ix,
|
||
WmFunction wmFunc,
|
||
void **ppArg,
|
||
String sClientName,
|
||
String sTitle)
|
||
{
|
||
unsigned char *lineP = *linePP;
|
||
Boolean bValidArg = True;
|
||
unsigned char *str = NULL;
|
||
|
||
/*
|
||
* If this is (possibly) a string argument, put it
|
||
* in quotes so that it will be parsed properly.
|
||
*/
|
||
if ((functionTable[ix].parseProc == ParseWmFuncStrArg) ||
|
||
(functionTable[ix].parseProc == ParseWmFuncMaybeStrArg))
|
||
{
|
||
if (lineP && *lineP != '"')
|
||
{
|
||
/*
|
||
* not in quotes, repackage it, escaping the appropriate
|
||
* characters.
|
||
*/
|
||
str = _DtWmParseMakeQuotedString (lineP);
|
||
if (str)
|
||
{
|
||
lineP = str;
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Apply the function argument parser.
|
||
*/
|
||
if ((functionTable[ix].wmFunction != wmFunc) ||
|
||
!(*(functionTable [ix].parseProc)) (&lineP, wmFunc, ppArg))
|
||
{
|
||
bValidArg = False;
|
||
}
|
||
|
||
/*
|
||
* Add the exec parms if this is an f.action
|
||
*/
|
||
if ((wmFunc == F_Action) && ppArg && *ppArg)
|
||
{
|
||
WmActionArg *pAP = (WmActionArg *) *ppArg;
|
||
int totLen = 0;
|
||
|
||
/*
|
||
* allocate more than enough string space to copy
|
||
* strings and intervening spaces.
|
||
*/
|
||
if (sClientName && *sClientName)
|
||
{
|
||
/* length of: "name=" + sClientName + NULL */
|
||
totLen += 5 + strlen(sClientName) + 1;
|
||
}
|
||
if (sTitle && *sTitle)
|
||
{
|
||
/* length of: "," + "title=" + sTitle + NULL */
|
||
totLen += 1 + 6 + strlen(sTitle) + 1;
|
||
}
|
||
|
||
if (totLen > 0)
|
||
{
|
||
pAP->szExecParms = (String) XtMalloc (totLen);
|
||
/* start with empty string */
|
||
pAP->szExecParms[0] = '\0';
|
||
|
||
if (sClientName && *sClientName)
|
||
{
|
||
strcat (pAP->szExecParms, "name=");
|
||
strcat (pAP->szExecParms, sClientName);
|
||
}
|
||
if (sTitle && *sTitle)
|
||
{
|
||
if (pAP->szExecParms[0] != '\0')
|
||
{
|
||
strcat (pAP->szExecParms, ",");
|
||
}
|
||
strcat (pAP->szExecParms, "title=");
|
||
strcat (pAP->szExecParms, sTitle);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (str)
|
||
{
|
||
XtFree ((char *) str);
|
||
}
|
||
|
||
return (bValidArg);
|
||
|
||
} /* END OF FUNCTION ParseWmFunctionArg */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* SystemCmd (pchCmd)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function fiddles with our signal handling and calls the
|
||
* system() function to invoke a unix command.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pchCmd = string with the command we want to exec.
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* The system() command is touchy about the SIGCLD behavior. Restore
|
||
* the default SIGCLD handler during the time we run system().
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
void
|
||
SystemCmd (char *pchCmd)
|
||
{
|
||
struct sigaction sa;
|
||
struct sigaction osa;
|
||
|
||
(void) sigemptyset(&sa.sa_mask);
|
||
sa.sa_flags = 0;
|
||
sa.sa_handler = SIG_DFL;
|
||
|
||
(void) sigaction (SIGCHLD, &sa, &osa);
|
||
|
||
system (pchCmd);
|
||
|
||
(void) sigaction (SIGCHLD, &osa, (struct sigaction *) 0);
|
||
}
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* DeleteTempConfigFileIfAny ()
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function deletes the temporary config file used to process
|
||
* old dtwmrc syntax.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
void
|
||
DeleteTempConfigFileIfAny (void)
|
||
{
|
||
char pchCmd[MAXWMPATH+1];
|
||
|
||
if (pConfigStackTop->tempName)
|
||
{
|
||
strcpy (pchCmd, "/bin/rm ");
|
||
strcat (pchCmd, pConfigStackTop->tempName);
|
||
SystemCmd (pchCmd);
|
||
XtFree ((char *) pConfigStackTop->tempName);
|
||
pConfigStackTop->tempName = NULL;
|
||
}
|
||
if (pConfigStackTop->cppName)
|
||
{
|
||
strcpy (pchCmd, "/bin/rm ");
|
||
strcat (pchCmd, pConfigStackTop->cppName);
|
||
SystemCmd (pchCmd);
|
||
XtFree ((char *) pConfigStackTop->cppName);
|
||
pConfigStackTop->cppName = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseIncludeSet (pSD, lineP)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* cfileP = (global) file pointer to fopened configuration file or NULL
|
||
* lineP = pointer to line buffer
|
||
* line = (global) line buffer
|
||
* linec = (global) line count
|
||
* parseP = (global) parse string pointer if cfileP == NULL
|
||
* pSD->rootWindow = default root window of display
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linec = (global) line count incremented
|
||
* parseP = (global) parse string pointer if cfileP == NULL
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void ParseIncludeSet (WmScreenData *pSD, unsigned char *lineP)
|
||
{
|
||
unsigned char *string;
|
||
unsigned char *pchName;
|
||
|
||
/*
|
||
* Require leading '{' on the next line.
|
||
*/
|
||
|
||
while ((GetNextLine () != NULL)) /* not EOF nor read error */
|
||
{
|
||
lineP = line;
|
||
ScanWhitespace(&lineP);
|
||
|
||
if ((lineP == NULL) || (*line == '!') || (*lineP == '\0') || (*lineP == '#'))
|
||
/* ignore empty or comment line */
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (*lineP == '{')
|
||
/* found '{' */
|
||
{
|
||
break;
|
||
}
|
||
|
||
/* not a '{' */
|
||
PWarning (((char *)GETMESSAGE(60, 37, "Expected '{'")));
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* Found leading "{" or EOF.
|
||
* Parse include files until "}" or EOF found.
|
||
*/
|
||
while ((GetNextLine () != NULL))
|
||
{
|
||
lineP = line;
|
||
if ((*line == '!') || (string = GetString (&lineP)) == NULL)
|
||
/* ignore empty or comment lines */
|
||
{
|
||
continue;
|
||
}
|
||
if (*string == '}') /* finished with set. */
|
||
{
|
||
break;
|
||
}
|
||
pchName = _DtWmParseFilenameExpand (string);
|
||
if (pchName && ConfigStackPush (pchName))
|
||
{
|
||
ProcessWmFile (pSD, True /* nested */);
|
||
ConfigStackPop ();
|
||
XtFree ((char *) pchName);
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ConfigStackInit (pchFileName)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Initializes the config file processing stack
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pchFileName = name of new file to start parsing
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void ConfigStackInit (char *pchFileName)
|
||
{
|
||
|
||
pConfigStack = XtNew (ConfigFileStackEntry);
|
||
|
||
if (pConfigStack)
|
||
{
|
||
pConfigStackTop = pConfigStack;
|
||
pConfigStackTop->fileName = XtNewString (pchFileName);
|
||
pConfigStackTop->tempName = NULL;
|
||
pConfigStackTop->cppName = NULL;
|
||
pConfigStackTop->offset = 0;
|
||
pConfigStackTop->pWmPB = wmGD.pWmPB;
|
||
pConfigStackTop->wmgdConfigFile = wmGD.configFile;
|
||
pConfigStackTop->pIncluder = NULL;
|
||
|
||
}
|
||
else
|
||
{
|
||
sprintf ((char *)wmGD.tmpBuffer,
|
||
(char *)GETMESSAGE(60,36,"Insufficient memory to process included file: %s"),
|
||
pchFileName);
|
||
Warning ((char *)wmGD.tmpBuffer);
|
||
}
|
||
}
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ConfigStackPush (pchFileName)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Open an included config file
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pchFileName = name of new file to start parsing
|
||
* wmGD.pWmPB = global parse buffer (pickle this)
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* wmGD.pWmPB = global parse buffer (new one for new file)
|
||
* return = FILE * to open file or NULL
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static FILE *
|
||
ConfigStackPush (unsigned char *pchFileName)
|
||
{
|
||
ConfigFileStackEntry *pEntry;
|
||
FILE *pNewFile = NULL;
|
||
|
||
pEntry = XtNew (ConfigFileStackEntry);
|
||
if (pEntry)
|
||
{
|
||
/* save off state of current config file */
|
||
pConfigStackTop->offset = ftell (cfileP);
|
||
pConfigStackTop->pWmPB = wmGD.pWmPB;
|
||
fclose (cfileP);
|
||
|
||
/* set up state of new config file */
|
||
pEntry->fileName = XtNewString ((char *)pchFileName);
|
||
pEntry->tempName = NULL;
|
||
pEntry->cppName = NULL;
|
||
pEntry->wmgdConfigFile = (String) pEntry->fileName;
|
||
|
||
/* set globals for new config file */
|
||
wmGD.pWmPB = _DtWmParseNewBuf ();
|
||
wmGD.configFile = pEntry->wmgdConfigFile;
|
||
|
||
/* put new entry onto stack */
|
||
pEntry->pIncluder = pConfigStackTop;
|
||
pConfigStackTop = pEntry;
|
||
|
||
/* open the file */
|
||
pNewFile = cfileP = FopenConfigFile();
|
||
|
||
if (!pNewFile)
|
||
{
|
||
/* file open failed! back out */
|
||
ConfigStackPop ();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sprintf ((char *)wmGD.tmpBuffer,
|
||
(char *)GETMESSAGE(60,36,"Insufficient memory to process included file: %s"),
|
||
pchFileName);
|
||
Warning ((char *)wmGD.tmpBuffer);
|
||
}
|
||
|
||
return (pNewFile);
|
||
}
|
||
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ConfigStackPop ()
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pchFileName = name of new file to start parsing
|
||
* wmGD.pWmPB = global parse buffer (pickle this)
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* wmGD.pWmPB = global parse buffer (new one for new file)
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* assumes cfileP is closed already
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void ConfigStackPop (void)
|
||
{
|
||
ConfigFileStackEntry *pPrev;
|
||
char pchCmd[MAXWMPATH+1];
|
||
|
||
if (pConfigStackTop != pConfigStack)
|
||
{
|
||
pPrev = pConfigStackTop->pIncluder;
|
||
|
||
_DtWmParseDestroyBuf (wmGD.pWmPB);
|
||
if (pConfigStackTop->tempName)
|
||
{
|
||
XtFree (pConfigStackTop->tempName);
|
||
}
|
||
if (pConfigStackTop->cppName)
|
||
{
|
||
strcpy (pchCmd, "/bin/rm ");
|
||
strcat (pchCmd, pConfigStackTop->cppName);
|
||
SystemCmd (pchCmd);
|
||
XtFree ((char *) pConfigStackTop->cppName);
|
||
pConfigStackTop->cppName = NULL;
|
||
}
|
||
if (pConfigStackTop->fileName)
|
||
{
|
||
XtFree (pConfigStackTop->fileName);
|
||
}
|
||
|
||
wmGD.pWmPB = pPrev->pWmPB;
|
||
wmGD.configFile = pPrev->wmgdConfigFile;
|
||
if (pPrev->tempName)
|
||
{
|
||
cfileP = fopen (pPrev->tempName, "r");
|
||
}
|
||
else if (pPrev->cppName)
|
||
{
|
||
cfileP = fopen (pPrev->cppName, "r");
|
||
}
|
||
else
|
||
{
|
||
cfileP = fopen (pPrev->fileName, "r");
|
||
}
|
||
if (cfileP)
|
||
{
|
||
fseek (cfileP, pPrev->offset, 0);
|
||
}
|
||
else
|
||
{
|
||
char msg[MAXWMPATH+1];
|
||
|
||
sprintf(msg, ((char *)GETMESSAGE(60, 39,
|
||
"Could not reopen configuration file %s")),
|
||
pPrev->fileName);
|
||
Warning (msg);
|
||
}
|
||
|
||
XtFree ((char *)pConfigStackTop);
|
||
pConfigStackTop = pPrev;
|
||
}
|
||
}
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* ParseWmFuncActionArg (linePP, wmFunction, pArgs)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* Parses a window manager f.action argument
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* linePP = pointer to current line buffer pointer.
|
||
* wmFunction = function for which the argument string is intended.
|
||
* pArgs = pointer to argument destination.
|
||
*
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
* linePP = pointer to revised line buffer pointer.
|
||
* pArgs = pointer to parsed argument.
|
||
* Return = FALSE iff insufficient memory
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
Boolean ParseWmFuncActionArg (unsigned char **linePP,
|
||
WmFunction wmFunction, String *pArgs)
|
||
{
|
||
#define WM_ACTION_ARG_INCREMENT 5
|
||
#define WM_ACTION_ARG_PAD 256
|
||
unsigned char *string;
|
||
char *pch;
|
||
WmActionArg *pAP;
|
||
int iArgSz;
|
||
|
||
pAP = XtNew (WmActionArg);
|
||
if (pAP && (string = GetString (linePP)) != NULL)
|
||
{
|
||
/* Got action name */
|
||
pAP->actionName = XtNewString ((char *) string);
|
||
|
||
/* Get action arguments, if any */
|
||
if ((pAP->aap = (DtActionArg *)
|
||
XtMalloc (WM_ACTION_ARG_INCREMENT * sizeof (DtActionArg))))
|
||
{
|
||
iArgSz = WM_ACTION_ARG_INCREMENT;
|
||
pAP->numArgs = 0;
|
||
|
||
while ((string = GetString (linePP)) != NULL)
|
||
{
|
||
if ((pAP->aap[pAP->numArgs].u.file.name = (char *)
|
||
XtMalloc(1 + strlen((char *)string))))
|
||
{
|
||
pAP->aap[pAP->numArgs].argClass = DtACTION_FILE;
|
||
|
||
/* format the action argument */
|
||
pch = pAP->aap[pAP->numArgs].u.file.name;
|
||
|
||
/*
|
||
* Expand environment variable
|
||
*/
|
||
if (string[0] == '$')
|
||
{
|
||
string = (unsigned char *) getenv ((char *)&string[1]);
|
||
if (!string)
|
||
{
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* Make sure there's room for the new
|
||
* string.
|
||
*/
|
||
pch = (char *)
|
||
XtRealloc (pch, (1+strlen((char *)string)));
|
||
pAP->aap[pAP->numArgs].u.file.name = pch;
|
||
}
|
||
}
|
||
|
||
/* !!! No host name processing is done!!! */
|
||
|
||
strcpy (pch, (char *)string);
|
||
|
||
pAP->numArgs++;
|
||
if (pAP->numArgs == iArgSz)
|
||
{
|
||
/* need to increase our array space */
|
||
iArgSz += WM_ACTION_ARG_INCREMENT;
|
||
pAP->aap = (DtActionArg *)
|
||
XtRealloc((char *)pAP->aap,
|
||
(iArgSz * sizeof (DtActionArg)));
|
||
if (!pAP->aap)
|
||
{
|
||
break; /* out of memory */
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
break; /* out of memory */
|
||
}
|
||
}
|
||
|
||
}
|
||
pAP->szExecParms = NULL;
|
||
*pArgs = (String) pAP;
|
||
}
|
||
else
|
||
/* NULL string argument */
|
||
{
|
||
*pArgs = NULL;
|
||
}
|
||
|
||
return (TRUE);
|
||
|
||
} /* END OF FUNCTION ParseWmFuncActionArg */
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* PreprocessConfigFile (pSD)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function runs the configuration file through the C
|
||
* preprocessor
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pSD = ptr to screen data
|
||
*
|
||
* Outputs:
|
||
* -------
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static void
|
||
PreprocessConfigFile (void)
|
||
{
|
||
#define CPP_NAME_SIZE ((L_tmpnam)+1)
|
||
char pchCmd[MAXWMPATH+1];
|
||
|
||
if (wmGD.cppCommand && *wmGD.cppCommand)
|
||
{
|
||
/*
|
||
* Generate a temp file name.
|
||
*/
|
||
pConfigStackTop->cppName = XtMalloc (CPP_NAME_SIZE * sizeof(char));
|
||
if (pConfigStackTop->cppName)
|
||
{
|
||
(void) tmpnam (pConfigStackTop->cppName);
|
||
|
||
/*
|
||
* Build up the command line.
|
||
*/
|
||
strcpy (pchCmd, wmGD.cppCommand);
|
||
strcat (pchCmd, " ");
|
||
strcat (pchCmd, pConfigStackTop->fileName);
|
||
strcat (pchCmd, " ");
|
||
strcat (pchCmd, pConfigStackTop->cppName);
|
||
|
||
/*
|
||
* Run the config file through the converter program
|
||
* and send the output to a temp file.
|
||
*/
|
||
SystemCmd (pchCmd);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/*************************************<->*************************************
|
||
*
|
||
* GetNetworkFileName (char *pchFile)
|
||
*
|
||
*
|
||
* Description:
|
||
* -----------
|
||
* This function returns a local representation for a network
|
||
* file.
|
||
*
|
||
*
|
||
* Inputs:
|
||
* ------
|
||
* pchFile - pointer to file name of form [<host>:]<path>
|
||
*
|
||
* Return:
|
||
* -------
|
||
* String - ptr to allocated string of local file name. If input
|
||
* is not a network file, the a copy of pchFile is returned.
|
||
*
|
||
*
|
||
* Comments:
|
||
* --------
|
||
* returned file name should be freed with XtFree().
|
||
*
|
||
*************************************<->***********************************/
|
||
|
||
static String
|
||
GetNetworkFileName (char *pchFile)
|
||
{
|
||
char *pch;
|
||
char *host_part;
|
||
char *file_part;
|
||
char *netfile;
|
||
char *sName = NULL;
|
||
char *pchName = NULL;
|
||
int count;
|
||
char **pchTok;
|
||
String sReturn = NULL;
|
||
char *homeDir;
|
||
int len;
|
||
|
||
|
||
pch = strchr (pchFile, ':');
|
||
|
||
if (pch)
|
||
{
|
||
/*
|
||
* Expand special chars and find matching file.
|
||
*/
|
||
pchTok = (char **)shellscan (pchFile, &count, 0);
|
||
|
||
if ((count == 1) || (count == 2))
|
||
{
|
||
/* one match found */
|
||
host_part = pchTok[0];
|
||
}
|
||
else if (count > 2)
|
||
{
|
||
/* several matches found, pick one */
|
||
host_part = pchTok[1];
|
||
}
|
||
else
|
||
{
|
||
host_part = NULL;
|
||
}
|
||
|
||
if (host_part != NULL)
|
||
{
|
||
pch = strchr (host_part, ':');
|
||
if (pch)
|
||
{
|
||
/*
|
||
* copy the string so we don't munge data
|
||
* inside shellscan
|
||
*/
|
||
host_part = sName = XtNewString ((String) host_part);
|
||
pch = strchr (sName, ':');
|
||
|
||
/*
|
||
* separate the host and file parts of the
|
||
* file name
|
||
*/
|
||
*pch = '\0';
|
||
file_part = pch+1;
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* The colon went away. Hmm...
|
||
*/
|
||
file_part = host_part;
|
||
host_part = NULL;
|
||
}
|
||
|
||
if ((mblen(file_part, MB_CUR_MAX) == 1) &&
|
||
(mblen(file_part+1, MB_CUR_MAX) == 1) &&
|
||
(*file_part == '~') &&
|
||
(*(file_part+1) == '/'))
|
||
{
|
||
/*
|
||
* Replace '~' with $HOME
|
||
*/
|
||
homeDir = XmeGetHomeDirName();
|
||
len = strlen (host_part) + 1 +
|
||
strlen (homeDir) + strlen (file_part) + 1;
|
||
pch = (char *) XtMalloc (len);
|
||
strcpy (pch, sName);
|
||
host_part = pch;
|
||
pch += strlen (pch) + 1;
|
||
strcpy (pch, homeDir);
|
||
strcat (pch, file_part+1);
|
||
file_part = pch;
|
||
XtFree (sName);
|
||
sName = host_part;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
* shellscan had a problem with the file name.
|
||
* just operate on the name as-is.
|
||
* temporarily replace ':' with a NULL
|
||
*/
|
||
host_part = sName = XtNewString ((String) pchFile);
|
||
pch = strchr (sName, ':');
|
||
*pch = '\0';
|
||
host_part = pchFile;
|
||
file_part = pch+1;
|
||
}
|
||
|
||
/* convert to canonical host/file name */
|
||
netfile = (char *)
|
||
tt_host_file_netfile (host_part, file_part);
|
||
if (tt_pointer_error (netfile) == TT_OK)
|
||
{
|
||
/* convert to local file name equivalent */
|
||
pchName = tt_netfile_file (netfile);
|
||
|
||
if (tt_pointer_error (pchName) == TT_OK)
|
||
{
|
||
sReturn = XtNewString ((String) pchName);
|
||
tt_free ((char *)pchName);
|
||
}
|
||
tt_free (netfile);
|
||
}
|
||
|
||
if (sName)
|
||
{
|
||
XtFree ((char *)sName);
|
||
}
|
||
}
|
||
|
||
if (sReturn == NULL)
|
||
{
|
||
if ((mblen(pchFile, MB_CUR_MAX) == 1) &&
|
||
(mblen(pchFile+1, MB_CUR_MAX) == 1) &&
|
||
(*pchFile == '~') &&
|
||
(*(pchFile+1) == '/'))
|
||
{
|
||
/*
|
||
* Replace '~' with $HOME
|
||
*/
|
||
homeDir = XmeGetHomeDirName();
|
||
len = strlen (homeDir) + strlen (pchFile) + 1;
|
||
sReturn = (char *) XtMalloc (len);
|
||
strcpy (sReturn, homeDir);
|
||
strcat (sReturn, pchFile+1);
|
||
}
|
||
else
|
||
{
|
||
sReturn = XtNewString ((String) pchFile);
|
||
}
|
||
}
|
||
|
||
return (sReturn);
|
||
}
|
||
/**************************** eof ***************************/
|
||
|