smallm
/
twmruined
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
twmruined/src/parse.c

897 lines
26 KiB
C
Raw Blame History

/*****************************************************************************/
/*
Copyright 1989, 1998 The Open Group
Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear in supporting
documentation.
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of The Open Group shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from The Open Group.
*/
/** Copyright 1988 by Evans & Sutherland Computer Corporation, **/
/** Salt Lake City, Utah **/
/** Cambridge, Massachusetts **/
/** **/
/** All Rights Reserved **/
/** **/
/** Permission to use, copy, modify, and distribute this software and **/
/** its documentation for any purpose and without fee is hereby **/
/** granted, provided that the above copyright notice appear in all **/
/** copies and that both that copyright notice and this permis- **/
/** sion notice appear in supporting documentation, and that the **/
/** name of Evans & Sutherland not be used in advertising **/
/** in publicity pertaining to distribution of the software without **/
/** specific, written prior permission. **/
/** **/
/** EVANS & SUTHERLAND DISCLAIMs ALL WARRANTIES WITH REGARD **/
/** TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- **/
/** ABILITY AND FITNESS, IN NO EVENT SHALL EVANS & SUTHERLAND **/
/** BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAM- **/
/** AGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA **/
/** OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER **/
/** TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE **/
/** OR PERFORMANCE OF THIS SOFTWARE. **/
/*****************************************************************************/
/***********************************************************************
*
* parse the .twmruinedrc file
*
* 17-Nov-87 Thomas E. LaStrange File created
* 10-Oct-90 David M. Sternlicht Storing saved colors on root
***********************************************************************/
#include <stdio.h>
#include <X11/Xos.h>
#include <X11/Xmu/CharSet.h>
#include "twm.h"
#include "screen.h"
#include "menus.h"
#include "util.h"
#include "gram.h"
#include "parse.h"
#include <X11/Xatom.h>
#include <X11/extensions/sync.h>
#ifndef SYSTEM_INIT_FILE
#define SYSTEM_INIT_FILE "/usr/lib/X11/twm/system.twmruinedrc"
#endif
#define BUF_LEN 300
static FILE *twmrc;
static int ptr = 0;
static int len = 0;
static unsigned char buff[BUF_LEN+1];
static unsigned char overflowbuff[20]; /* really only need one */
static int overflowlen;
static unsigned char **stringListSource, *currentString;
static int doparse ( int (*ifunc)(void), const char *srctypename, const char *srcname );
static int twmFileInput ( void );
static int twmStringListInput ( void );
static int ParseStringList ( unsigned char **sl );
extern int yylineno;
int ConstrainedMoveTime = 400; /* milliseconds, event times */
int (*twmInputFunc)(void);
/**
* parse the .twmruinedrc file
* \param filename the filename to parse.
* NULL indicates $HOME/.twmruinedrc
*/
static int doparse (int (*ifunc)(void),
const char *srctypename, const char *srcname)
{
mods = 0;
ptr = 0;
len = 0;
yylineno = 1;
ParseError = FALSE;
twmInputFunc = ifunc;
overflowlen = 0;
yyparse();
if (Scr->PointerForeground.pixel != Scr->Black ||
Scr->PointerBackground.pixel != Scr->White)
{
XRecolorCursor(dpy, UpperLeftCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, RightButt,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, LeftButt,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, MiddleButt,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, Scr->FrameCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, Scr->TitleCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, Scr->IconCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, Scr->MoveCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, Scr->ResizeCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, Scr->MenuCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, Scr->ButtonCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, Scr->WaitCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, Scr->SelectCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
XRecolorCursor(dpy, Scr->DestroyCursor,
&Scr->PointerForeground, &Scr->PointerBackground);
}
if (ParseError) {
fprintf (stderr, "%s: errors found in twm %s",
ProgramName, srctypename);
if (srcname) fprintf (stderr, " \"%s\"", srcname);
fprintf (stderr, "\n");
}
return (ParseError ? 0 : 1);
}
int ParseTwmrc (char *filename)
{
int i;
char *home = NULL;
int homelen = 0;
const char *cp = NULL;
char tmpfilename[257];
/*
* If filename given, try it, else try ~/.twmruinedrc.# then
* ~/.twmruinedrc. Then try system.twmruinedrc; finally using
* built-in defaults.
*/
for (twmrc = NULL, i = 0; !twmrc && i < 4; i++) {
switch (i) {
case 0: /* -f filename */
cp = filename;
break;
case 1: /* ~/.twmruinedrc.screennum */
if (!filename) {
home = getenv ("HOME");
if (home) {
homelen = strlen (home);
cp = tmpfilename;
(void) snprintf (tmpfilename, sizeof(tmpfilename),
"%s/.twmruinedrc.%d", home, Scr->screen);
break;
}
}
continue;
case 2: /* ~/.twmruinedrc */
if (home) {
tmpfilename[homelen + 13] = '\0';
}
break;
case 3: /* system.twmruinedrc */
cp = SYSTEM_INIT_FILE;
break;
}
if (cp) twmrc = fopen (cp, "r");
}
if (twmrc) {
int status;
if (filename && cp != filename) {
fprintf (stderr,
"%s: unable to open twmrc file %s, using %s instead\n",
ProgramName, filename, cp);
}
status = doparse (twmFileInput, "file", cp);
fclose (twmrc);
return status;
} else {
if (filename) {
fprintf (stderr,
"%s: unable to open twmrc file %s, using built-in defaults instead\n",
ProgramName, filename);
}
return ParseStringList (defTwmrc);
}
}
static int ParseStringList (unsigned char **sl)
{
stringListSource = sl;
currentString = *sl;
return doparse (twmStringListInput, "string list", (char *)NULL);
}
/**
* redefinition of the lex input routine for file input
*
* \return the next input character
*/
static int twmFileInput(void)
{
if (overflowlen) return (int) overflowbuff[--overflowlen];
while (ptr == len)
{
if (fgets((char *) buff, BUF_LEN, twmrc) == NULL)
return 0;
ptr = 0;
len = strlen((char *) buff);
}
return ((int)buff[ptr++]);
}
static int twmStringListInput(void)
{
if (overflowlen) return (int) overflowbuff[--overflowlen];
/*
* return the character currently pointed to
*/
if (currentString) {
unsigned int c = (unsigned int) *currentString++;
if (c) return c; /* if non-nul char */
currentString = *++stringListSource; /* advance to next bol */
return '\n'; /* but say that we hit last eol */
}
return 0; /* eof */
}
/*
* redefinition of the lex unput routine
*
* \param c the character to push back onto the input stream
*/
void twmUnput (int c)
{
if (overflowlen < sizeof overflowbuff) {
overflowbuff[overflowlen++] = (unsigned char) c;
} else {
twmrc_error_prefix ();
fprintf (stderr, "unable to unput character (%d)\n",
c);
}
}
/**
* redefinition of the lex output routine
*
* \param c the character to print
*/
void
TwmOutput(int c)
{
putchar(c);
}
/**********************************************************************
* Parsing table and routines
***********************************************************************/
typedef struct _TwmKeyword {
const char *name;
int value;
int subnum;
} TwmKeyword;
#define kw0_NoDefaults 1
#define kw0_AutoRelativeResize 2
#define kw0_ForceIcons 3
#define kw0_InterpolateMenuColors 6
#define kw0_NoVersion 7
#define kw0_NoMenuShadows 10
#define kw0_NoRaiseOnMove 11
#define kw0_NoRaiseOnResize 12
#define kw0_NoRaiseOnDeiconify 13
#define kw0_DontMoveOff 14
#define kw0_NoBackingStore 15
#define kw0_NoSaveUnders 16
#define kw0_RestartPreviousState 17
#define kw0_NoTitleFocus 19
#define kw0_DecorateTransients 21
#define kw0_NoRaiseOnWarp 24
#define kw0_WarpUnmapped 25
#define kws_IconFont 2
#define kws_ResizeFont 3
#define kws_MenuFont 4
#define kws_TitleFont 5
#define kws_UnknownIcon 7
#define kws_IconDirectory 8
#define kws_MaxWindowSize 9
#define kwn_ConstrainedMoveTime 1
#define kwn_XorValue 3
#define kwn_FramePadding 4
#define kwn_ButtonIndent 6
#define kwn_Priority 10
#define kwcl_BorderColor 1
#define kwcl_BorderTileForeground 3
#define kwcl_BorderTileBackground 4
#define kwcl_TitleForeground 5
#define kwcl_TitleBackground 6
#define kwcl_IconForeground 7
#define kwcl_IconBackground 8
#define kwcl_IconBorderColor 9
#define kwc_DefaultForeground 1
#define kwc_DefaultBackground 2
#define kwc_MenuForeground 3
#define kwc_MenuBackground 4
#define kwc_MenuTitleForeground 5
#define kwc_MenuTitleBackground 6
#define kwc_MenuShadowColor 7
#define kwc_PointerForeground 8
#define kwc_PointerBackground 9
#define kwc_MenuBorderColor 10
/*
* The following is sorted alphabetically according to name (which
* must be in lowercase). It is fed to a binary search to parse
* keywords.
*/
static TwmKeyword keytable[] = {
{ "all", ALL, 0 },
{ "autoraise", AUTO_RAISE, 0 },
{ "autorelativeresize", KEYWORD, kw0_AutoRelativeResize },
{ "bordercolor", CLKEYWORD, kwcl_BorderColor },
{ "bordertilebackground", CLKEYWORD, kwcl_BorderTileBackground },
{ "bordertileforeground", CLKEYWORD, kwcl_BorderTileForeground },
{ "button", BUTTON, 0 },
{ "buttonindent", NKEYWORD, kwn_ButtonIndent },
{ "c", CONTROL, 0 },
{ "center", JKEYWORD, J_CENTER },
{ "color", COLOR, 0 },
{ "constrainedmovetime", NKEYWORD, kwn_ConstrainedMoveTime },
{ "control", CONTROL, 0 },
{ "cursors", CURSORS, 0 },
{ "decoratetransients", KEYWORD, kw0_DecorateTransients },
{ "defaultbackground", CKEYWORD, kwc_DefaultBackground },
{ "defaultforeground", CKEYWORD, kwc_DefaultForeground },
{ "defaultfunction", DEFAULT_FUNCTION, 0 },
{ "destroy", KILL, 0 },
{ "dontmoveoff", KEYWORD, kw0_DontMoveOff },
{ "east", DKEYWORD, D_EAST },
{ "f", FRAME, 0 },
{ "f.autoraise", FKEYWORD, F_AUTORAISE },
{ "f.beep", FKEYWORD, F_BEEP },
{ "f.bottomzoom", FKEYWORD, F_BOTTOMZOOM },
{ "f.circledown", FKEYWORD, F_CIRCLEDOWN },
{ "f.circleup", FKEYWORD, F_CIRCLEUP },
{ "f.colormap", FSKEYWORD, F_COLORMAP },
{ "f.cut", FSKEYWORD, F_CUT },
{ "f.cutfile", FKEYWORD, F_CUTFILE },
{ "f.deiconify", FKEYWORD, F_DEICONIFY },
{ "f.delete", FKEYWORD, F_DELETE },
{ "f.destroy", FKEYWORD, F_DESTROY },
{ "f.exec", FSKEYWORD, F_EXEC },
{ "f.file", FSKEYWORD, F_FILE },
{ "f.focus", FKEYWORD, F_FOCUS },
{ "f.forcemove", FKEYWORD, F_FORCEMOVE },
{ "f.fullzoom", FKEYWORD, F_FULLZOOM },
{ "f.hbzoom", FKEYWORD, F_BOTTOMZOOM },
{ "f.horizoom", FKEYWORD, F_HORIZOOM },
{ "f.htzoom", FKEYWORD, F_TOPZOOM },
{ "f.hzoom", FKEYWORD, F_HORIZOOM },
{ "f.iconify", FKEYWORD, F_ICONIFY },
{ "f.identify", FKEYWORD, F_IDENTIFY },
{ "f.leftzoom", FKEYWORD, F_LEFTZOOM },
{ "f.lower", FKEYWORD, F_LOWER },
{ "f.menu", FSKEYWORD, F_MENU },
{ "f.move", FKEYWORD, F_MOVE },
{ "f.move-or-iconify", FKEYWORD, F_MOVE_OR_ICONIFY },
{ "f.move-or-lower", FKEYWORD, F_MOVE_OR_LOWER },
{ "f.move-or-raise", FKEYWORD, F_MOVE_OR_RAISE },
{ "f.nop", FKEYWORD, F_NOP },
{ "f.priority", FSKEYWORD, F_PRIORITY },
{ "f.quit", FKEYWORD, F_QUIT },
{ "f.raise", FKEYWORD, F_RAISE },
{ "f.raiselower", FKEYWORD, F_RAISELOWER },
{ "f.refresh", FKEYWORD, F_REFRESH },
{ "f.resize", FKEYWORD, F_RESIZE },
{ "f.restart", FKEYWORD, F_RESTART },
{ "f.rightzoom", FKEYWORD, F_RIGHTZOOM },
{ "f.saveyourself", FKEYWORD, F_SAVEYOURSELF },
{ "f.source", FSKEYWORD, F_BEEP }, /* XXX - don't work */
{ "f.startwm", FSKEYWORD, F_STARTWM },
{ "f.title", FKEYWORD, F_TITLE },
{ "f.topzoom", FKEYWORD, F_TOPZOOM },
{ "f.twmrc", FKEYWORD, F_RESTART },
{ "f.unfocus", FKEYWORD, F_UNFOCUS },
{ "f.version", FKEYWORD, F_VERSION },
{ "f.vlzoom", FKEYWORD, F_LEFTZOOM },
{ "f.vrzoom", FKEYWORD, F_RIGHTZOOM },
{ "f.warpnext", FKEYWORD, F_WARPNEXT },
{ "f.warpprev", FKEYWORD, F_WARPPREV },
{ "f.warpring", FSKEYWORD, F_WARPRING },
{ "f.warpto", FSKEYWORD, F_WARPTO },
{ "f.warptoscreen", FSKEYWORD, F_WARPTOSCREEN },
{ "f.winrefresh", FKEYWORD, F_WINREFRESH },
{ "f.zoom", FKEYWORD, F_ZOOM },
{ "forceicons", KEYWORD, kw0_ForceIcons },
{ "frame", FRAME, 0 },
{ "framepadding", NKEYWORD, kwn_FramePadding },
{ "grayscale", GRAYSCALE, 0 },
{ "greyscale", GRAYSCALE, 0 },
{ "i", ICON, 0 },
{ "icon", ICON, 0 },
{ "iconbackground", CLKEYWORD, kwcl_IconBackground },
{ "iconbordercolor", CLKEYWORD, kwcl_IconBorderColor },
{ "icondirectory", SKEYWORD, kws_IconDirectory },
{ "iconfont", SKEYWORD, kws_IconFont },
{ "iconforeground", CLKEYWORD, kwcl_IconForeground },
{ "icons", ICONS, 0 },
{ "interpolatemenucolors", KEYWORD, kw0_InterpolateMenuColors },
{ "l", LOCK, 0 },
{ "left", JKEYWORD, J_LEFT },
{ "lefttitlebutton", LEFT_TITLEBUTTON, 0 },
{ "lock", LOCK, 0 },
{ "m", META, 0 },
{ "maketitle", MAKE_TITLE, 0 },
{ "maxwindowsize", SKEYWORD, kws_MaxWindowSize },
{ "menu", MENU, 0 },
{ "menubackground", CKEYWORD, kwc_MenuBackground },
{ "menubordercolor", CKEYWORD, kwc_MenuBorderColor },
{ "menufont", SKEYWORD, kws_MenuFont },
{ "menuforeground", CKEYWORD, kwc_MenuForeground },
{ "menushadowcolor", CKEYWORD, kwc_MenuShadowColor },
{ "menutitlebackground", CKEYWORD, kwc_MenuTitleBackground },
{ "menutitleforeground", CKEYWORD, kwc_MenuTitleForeground },
{ "meta", META, 0 },
{ "mod", META, 0 }, /* fake it */
{ "monochrome", MONOCHROME, 0 },
{ "move", MOVE, 0 },
{ "nobackingstore", KEYWORD, kw0_NoBackingStore },
{ "nodefaults", KEYWORD, kw0_NoDefaults },
{ "nomenushadows", KEYWORD, kw0_NoMenuShadows },
{ "noraiseondeiconify", KEYWORD, kw0_NoRaiseOnDeiconify },
{ "noraiseonmove", KEYWORD, kw0_NoRaiseOnMove },
{ "noraiseonresize", KEYWORD, kw0_NoRaiseOnResize },
{ "noraiseonwarp", KEYWORD, kw0_NoRaiseOnWarp },
{ "north", DKEYWORD, D_NORTH },
{ "nosaveunders", KEYWORD, kw0_NoSaveUnders },
{ "nostackmode", NO_STACKMODE, 0 },
{ "notitle", NO_TITLE, 0 },
{ "notitlefocus", KEYWORD, kw0_NoTitleFocus },
{ "noversion", KEYWORD, kw0_NoVersion },
{ "pointerbackground", CKEYWORD, kwc_PointerBackground },
{ "pointerforeground", CKEYWORD, kwc_PointerForeground },
{ "priority", NKEYWORD, kwn_Priority },
{ "r", ROOT, 0 },
{ "resize", RESIZE, 0 },
{ "resizefont", SKEYWORD, kws_ResizeFont },
{ "restartpreviousstate", KEYWORD, kw0_RestartPreviousState },
{ "right", JKEYWORD, J_RIGHT },
{ "righttitlebutton", RIGHT_TITLEBUTTON, 0 },
{ "root", ROOT, 0 },
{ "s", SHIFT, 0 },
{ "savecolor", SAVECOLOR, 0},
{ "select", SELECT, 0 },
{ "shift", SHIFT, 0 },
{ "south", DKEYWORD, D_SOUTH },
{ "starticonified", START_ICONIFIED, 0 },
{ "t", TITLE, 0 },
{ "title", TITLE, 0 },
{ "titlebackground", CLKEYWORD, kwcl_TitleBackground },
{ "titlefont", SKEYWORD, kws_TitleFont },
{ "titleforeground", CLKEYWORD, kwcl_TitleForeground },
{ "unknownicon", SKEYWORD, kws_UnknownIcon },
{ "w", WINDOW, 0 },
{ "wait", WAIT, 0 },
{ "warpcursor", WARP_CURSOR, 0 },
{ "warpunmapped", KEYWORD, kw0_WarpUnmapped },
{ "west", DKEYWORD, D_WEST },
{ "window", WINDOW, 0 },
{ "windowfunction", WINDOW_FUNCTION, 0 },
{ "windowring", WINDOW_RING, 0 },
{ "xorvalue", NKEYWORD, kwn_XorValue },
};
const int numkeywords = (sizeof(keytable)/sizeof(keytable[0]));
int parse_keyword(char *s, int *nump)
{
register int lower = 0, upper = numkeywords - 1;
XmuCopyISOLatin1Lowered(s, s);
while (lower <= upper) {
int middle = (lower + upper) / 2;
TwmKeyword *p = &keytable[middle];
int res = strcmp(p->name, s);
if (res < 0) {
lower = middle + 1;
} else if (res == 0) {
*nump = p->subnum;
return p->value;
} else {
upper = middle - 1;
}
}
return ERRORTOKEN;
}
/*
* action routines called by grammar
*/
int do_single_keyword (int keyword)
{
switch (keyword) {
case kw0_NoDefaults:
Scr->NoDefaults = TRUE;
return 1;
case kw0_AutoRelativeResize:
Scr->AutoRelativeResize = TRUE;
return 1;
case kw0_ForceIcons:
if (Scr->FirstTime) Scr->ForceIcon = TRUE;
return 1;
case kw0_InterpolateMenuColors:
if (Scr->FirstTime) Scr->InterpolateMenuColors = TRUE;
return 1;
case kw0_NoVersion:
/* obsolete */
return 1;
case kw0_NoMenuShadows:
if (Scr->FirstTime) Scr->Shadow = FALSE;
return 1;
case kw0_NoRaiseOnMove:
if (Scr->FirstTime) Scr->NoRaiseMove = TRUE;
return 1;
case kw0_NoRaiseOnResize:
if (Scr->FirstTime) Scr->NoRaiseResize = TRUE;
return 1;
case kw0_NoRaiseOnDeiconify:
if (Scr->FirstTime) Scr->NoRaiseDeicon = TRUE;
return 1;
case kw0_DontMoveOff:
Scr->DontMoveOff = TRUE;
return 1;
case kw0_NoBackingStore:
Scr->BackingStore = FALSE;
return 1;
case kw0_NoSaveUnders:
Scr->SaveUnder = FALSE;
return 1;
case kw0_RestartPreviousState:
RestartPreviousState = True;
return 1;
case kw0_NoTitleFocus:
Scr->TitleFocus = FALSE;
return 1;
case kw0_DecorateTransients:
Scr->DecorateTransients = TRUE;
return 1;
case kw0_NoRaiseOnWarp:
Scr->NoRaiseWarp = TRUE;
return 1;
case kw0_WarpUnmapped:
Scr->WarpUnmapped = TRUE;
return 1;
}
return 0;
}
int do_string_keyword (int keyword, char *s)
{
switch (keyword) {
case kws_IconFont:
if (!Scr->HaveFonts) Scr->IconFont.name = s;
return 1;
case kws_ResizeFont:
if (!Scr->HaveFonts) Scr->SizeFont.name = s;
return 1;
case kws_MenuFont:
if (!Scr->HaveFonts) Scr->MenuFont.name = s;
return 1;
case kws_TitleFont:
if (!Scr->HaveFonts) Scr->TitleBarFont.name = s;
return 1;
case kws_UnknownIcon:
if (Scr->FirstTime) GetUnknownIcon (s);
return 1;
case kws_IconDirectory:
if (Scr->FirstTime) Scr->IconDirectory = ExpandFilename (s);
return 1;
case kws_MaxWindowSize:
JunkMask = XParseGeometry (s, &JunkX, &JunkY, &JunkWidth, &JunkHeight);
if ((JunkMask & (WidthValue | HeightValue)) !=
(WidthValue | HeightValue)) {
twmrc_error_prefix();
fprintf (stderr, "bad MaxWindowSize \"%s\"\n", s);
return 0;
}
if (JunkWidth <= 0 || JunkHeight <= 0) {
twmrc_error_prefix();
fprintf (stderr, "MaxWindowSize \"%s\" must be positive\n", s);
return 0;
}
Scr->MaxWindowWidth = JunkWidth;
Scr->MaxWindowHeight = JunkHeight;
return 1;
}
return 0;
}
int do_number_keyword(int keyword, int num)
{
switch (keyword) {
case kwn_ConstrainedMoveTime:
ConstrainedMoveTime = num;
return 1;
case kwn_XorValue:
if (Scr->FirstTime) Scr->XORvalue = num;
return 1;
case kwn_FramePadding:
if (Scr->FirstTime) Scr->FramePadding = num;
return 1;
case kwn_ButtonIndent:
if (Scr->FirstTime) Scr->ButtonIndent = num;
return 1;
case kwn_Priority:
if (HasSync) XSyncSetPriority(dpy, /*self*/ None, num);
return 1;
}
return 0;
}
name_list **do_colorlist_keyword (int keyword, int colormode, char *s)
{
switch (keyword) {
case kwcl_BorderColor:
GetColor (colormode, &Scr->BorderColor, s);
return &Scr->BorderColorL;
case kwcl_BorderTileForeground:
GetColor (colormode, &Scr->BorderTileC.fore, s);
return &Scr->BorderTileForegroundL;
case kwcl_BorderTileBackground:
GetColor (colormode, &Scr->BorderTileC.back, s);
return &Scr->BorderTileBackgroundL;
case kwcl_TitleForeground:
GetColor (colormode, &Scr->TitleC.fore, s);
return &Scr->TitleForegroundL;
case kwcl_TitleBackground:
GetColor (colormode, &Scr->TitleC.back, s);
return &Scr->TitleBackgroundL;
case kwcl_IconForeground:
GetColor (colormode, &Scr->IconC.fore, s);
return &Scr->IconForegroundL;
case kwcl_IconBackground:
GetColor (colormode, &Scr->IconC.back, s);
return &Scr->IconBackgroundL;
case kwcl_IconBorderColor:
GetColor (colormode, &Scr->IconBorderColor, s);
return &Scr->IconBorderColorL;
}
return NULL;
}
int do_color_keyword (int keyword, int colormode, char *s)
{
switch (keyword) {
case kwc_DefaultForeground:
GetColor (colormode, &Scr->DefaultC.fore, s);
return 1;
case kwc_DefaultBackground:
GetColor (colormode, &Scr->DefaultC.back, s);
return 1;
case kwc_MenuForeground:
GetColor (colormode, &Scr->MenuC.fore, s);
return 1;
case kwc_MenuBackground:
GetColor (colormode, &Scr->MenuC.back, s);
return 1;
case kwc_MenuBorderColor:
GetColor (colormode, &Scr->MenuBorderColor, s);
return 1;
case kwc_MenuTitleForeground:
GetColor (colormode, &Scr->MenuTitleC.fore, s);
return 1;
case kwc_MenuTitleBackground:
GetColor (colormode, &Scr->MenuTitleC.back, s);
return 1;
case kwc_MenuShadowColor:
GetColor (colormode, &Scr->MenuShadowColor, s);
return 1;
case kwc_PointerForeground:
GetColorValue (colormode, &Scr->PointerForeground, s);
return 1;
case kwc_PointerBackground:
GetColorValue (colormode, &Scr->PointerBackground, s);
return 1;
}
return 0;
}
/**
* Save a pixel value in twm root window color property.
*/
static void
put_pixel_on_root(Pixel pixel)
{
int i, addPixel = 1;
Atom pixelAtom, retAtom;
int retFormat;
unsigned long nPixels, retAfter;
unsigned char*retProp;
Pixel *pixelProp;
pixelAtom = XInternAtom(dpy, "_MIT_PRIORITY_COLORS", True);
if (XGetWindowProperty(dpy, Scr->Root, pixelAtom, 0, 8192,
False, XA_CARDINAL, &retAtom,
&retFormat, &nPixels, &retAfter,
&retProp) == Success) {
pixelProp = (Pixel *) retProp;
for (i = 0; i < nPixels; i++)
if (pixel == pixelProp[i])
addPixel = 0;
}
if (addPixel)
XChangeProperty (dpy, Scr->Root, _XA_MIT_PRIORITY_COLORS,
XA_CARDINAL, 32, PropModeAppend,
(unsigned char *)&pixel, 1);
}
/**
* save a color from a string in the twmrc file.
*/
void
do_string_savecolor(int colormode, char *s)
{
Pixel p;
GetColor(colormode, &p, s);
put_pixel_on_root(p);
}
typedef struct _cnode {int i; struct _cnode *next;} Cnode, *Cptr;
static Cptr chead = NULL;
/**
* save a color from a var in the twmrc file
*/
void
do_var_savecolor(int key)
{
Cptr cptrav, cpnew;
if (!chead) {
chead = malloc(sizeof(Cnode));
chead->i = key; chead->next = NULL;
}
else {
cptrav = chead;
while (cptrav->next != NULL) { cptrav = cptrav->next; }
cpnew = malloc(sizeof(Cnode));
cpnew->i = key; cpnew->next = NULL; cptrav->next = cpnew;
}
}
/**
* traverse the var save color list placing the pixels
* in the root window property.
*/
void
assign_var_savecolor(void)
{
Cptr cp = chead;
while (cp != NULL) {
switch (cp->i) {
case kwcl_BorderColor:
put_pixel_on_root(Scr->BorderColor);
break;
case kwcl_BorderTileForeground:
put_pixel_on_root(Scr->BorderTileC.fore);
break;
case kwcl_BorderTileBackground:
put_pixel_on_root(Scr->BorderTileC.back);
break;
case kwcl_TitleForeground:
put_pixel_on_root(Scr->TitleC.fore);
break;
case kwcl_TitleBackground:
put_pixel_on_root(Scr->TitleC.back);
break;
case kwcl_IconForeground:
put_pixel_on_root(Scr->IconC.fore);
break;
case kwcl_IconBackground:
put_pixel_on_root(Scr->IconC.back);
break;
case kwcl_IconBorderColor:
put_pixel_on_root(Scr->IconBorderColor);
break;
}
cp = cp->next;
}
if (chead) {
free(chead);
chead = NULL;
}
}
Reference in New Issue View Git Blame Copy Permalink