parse.c revision fb81d040
1/*****************************************************************************/ 2/** Copyright 1988 by Evans & Sutherland Computer Corporation, **/ 3/** Salt Lake City, Utah **/ 4/** Portions Copyright 1989 by the Massachusetts Institute of Technology **/ 5/** Cambridge, Massachusetts **/ 6/** **/ 7/** All Rights Reserved **/ 8/** **/ 9/** Permission to use, copy, modify, and distribute this software and **/ 10/** its documentation for any purpose and without fee is hereby **/ 11/** granted, provided that the above copyright notice appear in all **/ 12/** copies and that both that copyright notice and this permis- **/ 13/** sion notice appear in supporting documentation, and that the **/ 14/** names of Evans & Sutherland and M.I.T. not be used in advertising **/ 15/** in publicity pertaining to distribution of the software without **/ 16/** specific, written prior permission. **/ 17/** **/ 18/** EVANS & SUTHERLAND AND M.I.T. DISCLAIM ALL WARRANTIES WITH REGARD **/ 19/** TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- **/ 20/** ABILITY AND FITNESS, IN NO EVENT SHALL EVANS & SUTHERLAND OR **/ 21/** M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAM- **/ 22/** AGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA **/ 23/** OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER **/ 24/** TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE **/ 25/** OR PERFORMANCE OF THIS SOFTWARE. **/ 26/*****************************************************************************/ 27/* 28 * [ ctwm ] 29 * 30 * Copyright 1992 Claude Lecommandeur. 31 * 32 * Permission to use, copy, modify and distribute this software [ctwm] and 33 * its documentation for any purpose is hereby granted without fee, provided 34 * that the above copyright notice appear in all copies and that both that 35 * copyright notice and this permission notice appear in supporting documen- 36 * tation, and that the name of Claude Lecommandeur not be used in adverti- 37 * sing or publicity pertaining to distribution of the software without 38 * specific, written prior permission. Claude Lecommandeur make no represen- 39 * tations about the suitability of this software for any purpose. It is 40 * provided "as is" without express or implied warranty. 41 * 42 * Claude Lecommandeur DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 43 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO 44 * EVENT SHALL Claude Lecommandeur BE LIABLE FOR ANY SPECIAL, INDIRECT OR 45 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF 46 * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 47 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 48 * PERFORMANCE OF THIS SOFTWARE. 49 * 50 * Author: Claude Lecommandeur [ lecom@sic.epfl.ch ][ April 1992 ] 51 */ 52 53 54/*********************************************************************** 55 * 56 * $XConsortium: parse.c,v 1.52 91/07/12 09:59:37 dave Exp $ 57 * 58 * parse the .twmrc file 59 * 60 * 17-Nov-87 Thomas E. LaStrange File created 61 * 10-Oct-90 David M. Sternlicht Storing saved colors on root 62 * 63 * Do the necessary modification to be integrated in ctwm. 64 * Can no longer be used for the standard twm. 65 * 66 * 22-April-92 Claude Lecommandeur. 67 * 68 ***********************************************************************/ 69 70#include <stdio.h> 71#include <sys/types.h> 72#include <sys/wait.h> 73#if defined(sony_news) || defined __QNX__ 74# include <ctype.h> 75#endif 76#ifdef VMS 77#include <ctype.h> 78#include <decw$include/Xos.h> 79#include <X11Xmu/CharSet.h> 80#include <X11Xmu/SysUtil.h> 81#else 82#include <X11/Xos.h> 83#include <X11/Xmu/CharSet.h> 84#include <X11/Xmu/SysUtil.h> 85#endif 86#include "twm.h" 87#include "screen.h" 88#include "menus.h" 89#include "util.h" 90#include "parse.h" 91#include "version.h" 92#ifdef SOUNDS 93# include "sound.h" 94#endif 95#ifdef VMS 96# include <decw$include/Xatom.h> 97#else 98# include <X11/Xatom.h> 99#endif 100 101/* For m4... */ 102#ifdef USEM4 103#include <sys/param.h> 104#include <sys/types.h> 105#include <sys/socket.h> 106#include <netdb.h> 107 108extern int GoThroughM4; 109extern char *keepM4_filename; 110extern int KeepTmpFile; 111#endif 112 113#if defined(ultrix) 114#define NOSTEMP 115#endif 116 117#ifndef SYSTEM_INIT_FILE 118#ifdef VMS 119#define SYSTEM_INIT_FILE "DECW$SYSTEM_DEFAULTS:SYSTEM.CTWMRC" 120#else 121#define SYSTEM_INIT_FILE "/usr/lib/X11/twm/system.twmrc" 122#endif 123#endif 124#define BUF_LEN 300 125 126static int ParseRandomPlacement (register char *s); 127static int ParseButtonStyle (register char *s); 128extern int yyparse(void); 129extern void twmrc_error_prefix(void); 130 131static FILE *twmrc; 132static int ptr = 0; 133static int len = 0; 134static char buff[BUF_LEN+1]; 135static char overflowbuff[20]; /* really only need one */ 136static int overflowlen; 137static char **stringListSource, *currentString; 138static int ParseUsePPosition (register char *s); 139#ifdef USEM4 140static FILE *start_m4(FILE *fraw); 141static char *m4_defs(Display *display, char *host); 142#endif 143 144extern int mods; 145 146int ConstrainedMoveTime = 400; /* milliseconds, event times */ 147 148int RaiseDelay = 0; /* msec, for AutoRaise */ 149 150static int twmStringListInput(void); 151#ifndef USEM4 152static int twmFileInput(void); 153#else 154static int m4twmFileInput (void); 155#endif 156int (*twmInputFunc)(void); 157 158extern char *defTwmrc[]; /* default bindings */ 159 160extern char *captivename; 161 162/*********************************************************************** 163 * 164 * Procedure: 165 * ParseTwmrc - parse the .twmrc file 166 * 167 * Inputs: 168 * filename - the filename to parse. A NULL indicates $HOME/.twmrc 169 * 170 *********************************************************************** 171 */ 172 173#ifdef YYDEBUG 174int yydebug = 1; 175#endif 176 177static int doparse (int (*ifunc)(void), char *srctypename, char *srcname) 178{ 179 mods = 0; 180 ptr = 0; 181 len = 0; 182 twmrc_lineno = 0; 183 ParseError = FALSE; 184 twmInputFunc = ifunc; 185 overflowlen = 0; 186 187 yyparse(); 188 189 if (ParseError) { 190 fprintf (stderr, "%s: errors found in twm %s", 191 ProgramName, srctypename); 192 if (srcname) fprintf (stderr, " \"%s\"", srcname); 193 fprintf (stderr, "\n"); 194 } 195 return (ParseError ? 0 : 1); 196} 197 198 199int ParseTwmrc (char *filename) 200{ 201 int i; 202 char *home = NULL; 203 int homelen = 0; 204 char *cp = NULL; 205 char tmpfilename[257]; 206#ifdef USEM4 207 static FILE *raw; 208#endif 209 210 /* 211 * Check for the twmrc file in the following order: 212 * Unix | VMS 213 * 0. -f filename.# | -f filename_# 214 * 1. -f filename | -f filename 215 * 2. .ctwmrc.# | ctwm.rc_# 216 * 3. .ctwmrc | ctwm.rc 217 * 4. .twmrc.# | twm.rc_# 218 * 5. .twmrc | twm.rc 219 * 6. system.ctwmrc | system.ctwmrc 220 */ 221 for (twmrc = NULL, i = 0; !twmrc && i < 7; i++) { 222 switch (i) { 223#ifdef VMS 224 case 0: 225 if (filename != NULL) { 226 cp = tmpfilename; 227 (void) sprintf (tmpfilename, "%s_%d", filename, Scr->screen); 228 } else 229 cp = filename; 230 break; 231 232 case 1: 233 cp = filename; 234 break; 235 236 case 2: 237 if (!filename) { 238 home = getenv ("DECW$USER_DEFAULTS"); 239 if (home) { 240 homelen = strlen (home); 241 cp = tmpfilename; 242 (void) sprintf (tmpfilename, "%sctwm.rc_%d", 243 home, Scr->screen); 244 break; 245 } 246 } 247 continue; 248 249 case 3: 250 if (home) { 251 tmpfilename[homelen + 7] = '\0'; 252 } 253 break; 254 255 case 4: 256 if (!filename) { 257 home = getenv ("DECW$USER_DEFAULTS"); 258 if (home) { 259 homelen = strlen (home); 260 cp = tmpfilename; 261 (void) sprintf (tmpfilename, "%stwm.rc_%d", 262 home, Scr->screen); 263 break; 264 } 265 } 266 continue; 267 268 case 5: 269 if (home) { 270 tmpfilename[homelen + 6] = '\0'; 271 } 272 break; 273#else 274 case 0: /* -f filename.# */ 275 if (filename) { 276 cp = tmpfilename; 277 (void) sprintf (tmpfilename, "%s.%d", filename, Scr->screen); 278 } 279 else cp = filename; 280 break; 281 282 case 1: /* -f filename */ 283 cp = filename; 284 break; 285 286 case 2: /* ~/.ctwmrc.screennum */ 287 if (!filename) { 288 home = getenv ("HOME"); 289 if (home) { 290 homelen = strlen (home); 291 cp = tmpfilename; 292 (void) sprintf (tmpfilename, "%s/.ctwmrc.%d", 293 home, Scr->screen); 294 break; 295 } 296 } 297 continue; 298 299 case 3: /* ~/.ctwmrc */ 300 if (home) { 301 tmpfilename[homelen + 8] = '\0'; 302 } 303 break; 304 305 case 4: /* ~/.twmrc.screennum */ 306 if (!filename) { 307 home = getenv ("HOME"); 308 if (home) { 309 homelen = strlen (home); 310 cp = tmpfilename; 311 (void) sprintf (tmpfilename, "%s/.twmrc.%d", 312 home, Scr->screen); 313 break; 314 } 315 } 316 continue; 317 318 case 5: /* ~/.twmrc */ 319 if (home) { 320 tmpfilename[homelen + 7] = '\0'; /* C.L. */ 321 } 322 break; 323#endif 324 325 case 6: /* system.twmrc */ 326 cp = SYSTEM_INIT_FILE; 327 break; 328 } 329 330 if (cp) { 331 twmrc = fopen (cp, "r"); 332#ifdef USEM4 333 raw = twmrc; 334#endif 335 336 } 337 } 338 339#ifdef USEM4 340 if (raw) { 341#else 342 if (twmrc) { 343#endif 344 345 int status; 346 347 if (filename && strncmp (cp, filename, strlen (filename))) { 348 fprintf (stderr, 349 "%s: unable to open twmrc file %s, using %s instead\n", 350 ProgramName, filename, cp); 351 } 352#ifdef USEM4 353 if (GoThroughM4) twmrc = start_m4(raw); 354 status = doparse (m4twmFileInput, "file", cp); 355 wait (0); 356 fclose (twmrc); 357 if (GoThroughM4) fclose (raw); 358#else 359 status = doparse (twmFileInput, "file", cp); 360 fclose (twmrc); 361#endif 362 return status; 363 } else { 364 if (filename) { 365 fprintf (stderr, 366 "%s: unable to open twmrc file %s, using built-in defaults instead\n", 367 ProgramName, filename); 368 } 369 return ParseStringList (defTwmrc); 370 } 371} 372 373int ParseStringList (char **sl) 374{ 375 stringListSource = sl; 376 currentString = *sl; 377 return doparse (twmStringListInput, "string list", (char *)NULL); 378} 379 380 381/*********************************************************************** 382 * 383 * Procedure: 384 * twmFileInput - redefinition of the lex input routine for file input 385 * 386 * Returned Value: 387 * the next input character 388 * 389 *********************************************************************** 390 */ 391 392 393#ifndef USEM4 394 395/* This has Tom's include() funtionality. This is utterly useless if you 396 * can use m4 for the same thing. Chris P. Ross */ 397 398#define MAX_INCLUDES 10 399 400static struct incl { 401 FILE *fp; 402 char *name; 403 int lineno; 404} rc_includes[MAX_INCLUDES]; 405static int include_file = 0; 406 407 408static int twmFileInput() 409{ 410 if (overflowlen) return (int) overflowbuff[--overflowlen]; 411 412 while (ptr == len) 413 { 414 while (include_file) { 415 if (fgets(buff, BUF_LEN, rc_includes[include_file].fp) == NULL) { 416 free(rc_includes[include_file].name); 417 fclose(rc_includes[include_file].fp); 418 twmrc_lineno = rc_includes[include_file--].lineno; 419 } else 420 break; 421 } 422 423 if (!include_file) 424 if (fgets(buff, BUF_LEN, twmrc) == NULL) 425 return 0; 426 twmrc_lineno++; 427 428 if (strncmp(buff, "include", 7) == 0) { 429 /* Whoops, an include file! */ 430 char *p = buff + 7, *q; 431 FILE *fp; 432 433 while (isspace(*p)) p++; 434 for (q = p; *q && !isspace(*q); q++) 435 continue; 436 *q = 0; 437 438 if ((fp = fopen(p, "r")) == NULL) { 439 fprintf(stderr, "%s: Unable to open included init file %s\n", 440 ProgramName, p); 441 continue; 442 } 443 if (++include_file >= MAX_INCLUDES) { 444 fprintf(stderr, "%s: init file includes nested too deep\n", 445 ProgramName); 446 continue; 447 } 448 rc_includes[include_file].fp = fp; 449 rc_includes[include_file].lineno = twmrc_lineno; 450 twmrc_lineno = 0; 451 rc_includes[include_file].name = malloc(strlen(p)+1); 452 strcpy(rc_includes[include_file].name, p); 453 continue; 454 } 455 ptr = 0; 456 len = strlen(buff); 457 } 458 return ((int)buff[ptr++]); 459} 460#else /* USEM4 */ 461/* If you're going to use m4, use this version instead. Much simpler. 462 * m4 ism's credit to Josh Osborne (stripes) */ 463 464static int m4twmFileInput(void) 465{ 466 int line; 467 static FILE *cp = NULL; 468 469 if ( cp == NULL && keepM4_filename ) { 470 cp = fopen (keepM4_filename,"w"); 471 if ( cp == NULL ) { 472 fprintf (stderr, 473 "%s: unable to create m4 output %s, ignoring\n", 474 ProgramName, keepM4_filename); 475 keepM4_filename = NULL; 476 } 477 } 478 479 if (overflowlen){ 480 return((int) overflowbuff[--overflowlen]); 481 } 482 483 while (ptr == len) { 484 nextline: 485 if (fgets(buff, BUF_LEN, twmrc) == NULL) { 486 if ( cp ) fclose (cp); 487 return(0); 488 } 489 if ( cp ) fputs (buff, cp); 490 491 if (sscanf(buff, "#line %d", &line)) { 492 twmrc_lineno = line - 1; 493 goto nextline; 494 } else { 495 twmrc_lineno++; 496 } 497 498 ptr = 0; 499 len = strlen(buff); 500 } 501 return ((int)buff[ptr++]); 502} 503#endif /* USEM4 */ 504 505 506static int twmStringListInput(void) 507{ 508 if (overflowlen) return (int) overflowbuff[--overflowlen]; 509 510 /* 511 * return the character currently pointed to 512 */ 513 if (currentString) { 514 unsigned int c = (unsigned int) *currentString++; 515 516 if (c) return c; /* if non-nul char */ 517 currentString = *++stringListSource; /* advance to next bol */ 518 return '\n'; /* but say that we hit last eol */ 519 } 520 return 0; /* eof */ 521} 522 523 524/*********************************************************************** 525 * 526 * Procedure: 527 * twmUnput - redefinition of the lex unput routine 528 * 529 * Inputs: 530 * c - the character to push back onto the input stream 531 * 532 *********************************************************************** 533 */ 534 535void twmUnput (int c) 536{ 537 if (overflowlen < sizeof overflowbuff) { 538 overflowbuff[overflowlen++] = (char) c; 539 } else { 540 twmrc_error_prefix (); 541 fprintf (stderr, "unable to unput character (%c)\n", 542 c); 543 } 544} 545 546 547/*********************************************************************** 548 * 549 * Procedure: 550 * TwmOutput - redefinition of the lex output routine 551 * 552 * Inputs: 553 * c - the character to print 554 * 555 *********************************************************************** 556 */ 557 558void TwmOutput(int c) 559{ 560 putchar(c); 561} 562 563 564/********************************************************************** 565 * 566 * Parsing table and routines 567 * 568 ***********************************************************************/ 569 570typedef struct _TwmKeyword { 571 char *name; 572 int value; 573 int subnum; 574} TwmKeyword; 575 576#define kw0_NoDefaults 1 577#define kw0_AutoRelativeResize 2 578#define kw0_ForceIcons 3 579#define kw0_NoIconManagers 4 580#define kw0_InterpolateMenuColors 6 581#define kw0_NoVersion 7 582#define kw0_SortIconManager 8 583#define kw0_NoGrabServer 9 584#define kw0_NoMenuShadows 10 585#define kw0_NoRaiseOnMove 11 586#define kw0_NoRaiseOnResize 12 587#define kw0_NoRaiseOnDeiconify 13 588#define kw0_DontMoveOff 14 589#define kw0_NoBackingStore 15 590#define kw0_NoSaveUnders 16 591#define kw0_RestartPreviousState 17 592#define kw0_ClientBorderWidth 18 593#define kw0_NoTitleFocus 19 594#define kw0_DecorateTransients 21 595#define kw0_ShowIconManager 22 596#define kw0_NoCaseSensitive 23 597#define kw0_NoRaiseOnWarp 24 598#define kw0_WarpUnmapped 25 599#define kw0_ShowWorkspaceManager 27 600#define kw0_StartInMapState 28 601#define kw0_NoShowOccupyAll 29 602#define kw0_AutoOccupy 30 603#define kw0_TransientHasOccupation 31 604#define kw0_DontPaintRootWindow 32 605#define kw0_Use3DMenus 33 606#define kw0_Use3DTitles 34 607#define kw0_Use3DIconManagers 35 608#define kw0_Use3DBorders 36 609#define kw0_SunkFocusWindowTitle 37 610#define kw0_BeNiceToColormap 38 611#define kw0_WarpRingOnScreen 40 612#define kw0_NoIconManagerFocus 41 613#define kw0_StayUpMenus 42 614#define kw0_ClickToFocus 43 615#define kw0_BorderResizeCursors 44 616#define kw0_ReallyMoveInWorkspaceManager 45 617#define kw0_ShowWinWhenMovingInWmgr 46 618#define kw0_Use3DWMap 47 619#define kw0_ReverseCurrentWorkspace 48 620#define kw0_DontWarpCursorInWMap 49 621#define kw0_CenterFeedbackWindow 50 622#define kw0_WarpToDefaultMenuEntry 51 623#define kw0_ShrinkIconTitles 52 624#define kw0_AutoRaiseIcons 53 625#define kw0_use3DIconBorders 54 626#define kw0_UseSunkTitlePixmap 55 627#define kw0_ShortAllWindowsMenus 56 628#define kw0_RaiseWhenAutoUnSqueeze 57 629#define kw0_RaiseOnClick 58 630#define kw0_IgnoreLockModifier 59 631#define kw0_AutoFocusToTransients 60 /* kai */ 632#define kw0_PackNewWindows 61 633#define kw0_IgnoreCaseInMenuSelection 62 634#define kw0_SloppyFocus 63 635#define kw0_NoImagesInWorkSpaceManager 64 636#define kw0_NoWarpToMenuTitle 65 637#define kw0_SaveWorkspaceFocus 66 /* blais */ 638#define kw0_RaiseOnWarp 67 639 640#define kws_UsePPosition 1 641#define kws_IconFont 2 642#define kws_ResizeFont 3 643#define kws_MenuFont 4 644#define kws_TitleFont 5 645#define kws_IconManagerFont 6 646#define kws_UnknownIcon 7 647#define kws_IconDirectory 8 648#define kws_MaxWindowSize 9 649#define kws_PixmapDirectory 10 650/* RandomPlacement moved because it's now a string string keyword */ 651#define kws_IconJustification 12 652#define kws_TitleJustification 13 653#define kws_IconRegionJustification 14 654#define kws_IconRegionAlignement 15 655#ifdef SOUNDS 656#define kws_SoundHost 16 657#endif 658#define kws_WMgrButtonStyle 17 659#define kws_WorkSpaceFont 18 660#define kws_IconifyStyle 19 661 662#define kwss_RandomPlacement 1 663 664#define kwn_ConstrainedMoveTime 1 665#define kwn_MoveDelta 2 666#define kwn_XorValue 3 667#define kwn_FramePadding 4 668#define kwn_TitlePadding 5 669#define kwn_ButtonIndent 6 670#define kwn_BorderWidth 7 671#define kwn_IconBorderWidth 8 672#define kwn_TitleButtonBorderWidth 9 673#define kwn_RaiseDelay 10 674#define kwn_TransientOnTop 11 675#define kwn_OpaqueMoveThreshold 12 676#define kwn_OpaqueResizeThreshold 13 677#define kwn_WMgrVertButtonIndent 14 678#define kwn_WMgrHorizButtonIndent 15 679#define kwn_ClearShadowContrast 16 680#define kwn_DarkShadowContrast 17 681#define kwn_WMgrButtonShadowDepth 18 682#define kwn_MaxIconTitleWidth 19 683#define kwn_AnimationSpeed 20 684#define kwn_ThreeDBorderWidth 21 685#define kwn_MoveOffResistance 22 686#define kwn_BorderShadowDepth 23 687#define kwn_TitleShadowDepth 24 688#define kwn_TitleButtonShadowDepth 25 689#define kwn_MenuShadowDepth 26 690#define kwn_IconManagerShadowDepth 27 691#define kwn_MovePackResistance 28 692#define kwn_XMoveGrid 29 693#define kwn_YMoveGrid 30 694#define kwn_OpenWindowTimeout 31 695#define kwn_RaiseOnClickButton 32 696 697#define kwn_BorderTop 33 698#define kwn_BorderBottom 34 699#define kwn_BorderLeft 35 700#define kwn_BorderRight 36 701 702#define kwcl_BorderColor 1 703#define kwcl_IconManagerHighlight 2 704#define kwcl_BorderTileForeground 3 705#define kwcl_BorderTileBackground 4 706#define kwcl_TitleForeground 5 707#define kwcl_TitleBackground 6 708#define kwcl_IconForeground 7 709#define kwcl_IconBackground 8 710#define kwcl_IconBorderColor 9 711#define kwcl_IconManagerForeground 10 712#define kwcl_IconManagerBackground 11 713#define kwcl_MapWindowBackground 12 714#define kwcl_MapWindowForeground 13 715 716#define kwc_DefaultForeground 1 717#define kwc_DefaultBackground 2 718#define kwc_MenuForeground 3 719#define kwc_MenuBackground 4 720#define kwc_MenuTitleForeground 5 721#define kwc_MenuTitleBackground 6 722#define kwc_MenuShadowColor 7 723 724/* 725 * The following is sorted alphabetically according to name (which must be 726 * in lowercase and only contain the letters a-z). It is fed to a binary 727 * search to parse keywords. 728 */ 729static TwmKeyword keytable[] = { 730 { "a", ALTER, 0 }, 731 { "all", ALL, 0 }, 732 { "alter", ALTER, 0 }, 733 { "alwaysontop", ALWAYS_ON_TOP, 0 }, 734 { "alwaysshowwindowwhenmovingfromworkspacemanager", KEYWORD, kw0_ShowWinWhenMovingInWmgr }, 735 { "alwayssqueezetogravity", ALWAYSSQUEEZETOGRAVITY, 0 }, 736 { "animationspeed", NKEYWORD, kwn_AnimationSpeed }, 737 { "autofocustotransients", KEYWORD, kw0_AutoFocusToTransients }, /* kai */ 738 { "autolower", AUTO_LOWER, 0 }, 739 { "autooccupy", KEYWORD, kw0_AutoOccupy }, 740 { "autoraise", AUTO_RAISE, 0 }, 741 { "autoraiseicons", KEYWORD, kw0_AutoRaiseIcons }, 742 { "autorelativeresize", KEYWORD, kw0_AutoRelativeResize }, 743 { "autosqueeze", AUTOSQUEEZE, 0 }, 744 { "benicetocolormap", KEYWORD, kw0_BeNiceToColormap }, 745 { "borderbottom", NKEYWORD, kwn_BorderBottom }, 746 { "bordercolor", CLKEYWORD, kwcl_BorderColor }, 747 { "borderleft", NKEYWORD, kwn_BorderLeft }, 748 { "borderresizecursors", KEYWORD, kw0_BorderResizeCursors }, 749 { "borderright", NKEYWORD, kwn_BorderRight }, 750 { "bordershadowdepth", NKEYWORD, kwn_BorderShadowDepth }, 751 { "bordertilebackground", CLKEYWORD, kwcl_BorderTileBackground }, 752 { "bordertileforeground", CLKEYWORD, kwcl_BorderTileForeground }, 753 { "bordertop", NKEYWORD, kwn_BorderTop }, 754 { "borderwidth", NKEYWORD, kwn_BorderWidth }, 755 { "button", BUTTON, 0 }, 756 { "buttonindent", NKEYWORD, kwn_ButtonIndent }, 757 { "c", CONTROL, 0 }, 758 { "center", JKEYWORD, J_CENTER }, 759 { "centerfeedbackwindow", KEYWORD, kw0_CenterFeedbackWindow }, 760 { "changeworkspacefunction", CHANGE_WORKSPACE_FUNCTION, 0 }, 761 { "clearshadowcontrast", NKEYWORD, kwn_ClearShadowContrast }, 762 { "clicktofocus", KEYWORD, kw0_ClickToFocus }, 763 { "clientborderwidth", KEYWORD, kw0_ClientBorderWidth }, 764 { "color", COLOR, 0 }, 765 { "constrainedmovetime", NKEYWORD, kwn_ConstrainedMoveTime }, 766 { "control", CONTROL, 0 }, 767 { "cursors", CURSORS, 0 }, 768 { "darkshadowcontrast", NKEYWORD, kwn_DarkShadowContrast }, 769 { "decoratetransients", KEYWORD, kw0_DecorateTransients }, 770 { "defaultbackground", CKEYWORD, kwc_DefaultBackground }, 771 { "defaultforeground", CKEYWORD, kwc_DefaultForeground }, 772 { "defaultfunction", DEFAULT_FUNCTION, 0 }, 773 { "deiconifyfunction", DEICONIFY_FUNCTION, 0 }, 774 { "destroy", KILL, 0 }, 775 { "donticonifybyunmapping", DONT_ICONIFY_BY_UNMAPPING, 0 }, 776 { "dontmoveoff", KEYWORD, kw0_DontMoveOff }, 777 { "dontpaintrootwindow", KEYWORD, kw0_DontPaintRootWindow }, 778 { "dontsave", DONT_SAVE, 0 }, 779 { "dontsetinactive", DONTSETINACTIVE, 0 }, 780 { "dontsqueezetitle", DONT_SQUEEZE_TITLE, 0 }, 781 { "donttoggleworkspacemanagerstate", DONTTOGGLEWORKSPACEMANAGERSTATE, 0 }, 782 { "dontwarpcursorinwmap", KEYWORD, kw0_DontWarpCursorInWMap }, 783 { "east", DKEYWORD, D_EAST }, 784 { "f", FRAME, 0 }, 785 { "f.addtoworkspace", FSKEYWORD, F_ADDTOWORKSPACE }, 786 { "f.adoptwindow", FKEYWORD, F_ADOPTWINDOW }, 787 { "f.altcontext", FKEYWORD, F_ALTCONTEXT }, 788 { "f.altkeymap", FSKEYWORD, F_ALTKEYMAP }, 789 { "f.autolower", FKEYWORD, F_AUTOLOWER }, 790 { "f.autoraise", FKEYWORD, F_AUTORAISE }, 791 { "f.backiconmgr", FKEYWORD, F_BACKICONMGR }, 792 { "f.backmapiconmgr", FKEYWORD, F_BACKMAPICONMGR }, 793 { "f.beep", FKEYWORD, F_BEEP }, 794 { "f.bottomzoom", FKEYWORD, F_BOTTOMZOOM }, 795 { "f.changesize", FSKEYWORD, F_CHANGESIZE }, 796 { "f.circledown", FKEYWORD, F_CIRCLEDOWN }, 797 { "f.circleup", FKEYWORD, F_CIRCLEUP }, 798 { "f.colormap", FSKEYWORD, F_COLORMAP }, 799 { "f.cut", FSKEYWORD, F_CUT }, 800 { "f.cutfile", FKEYWORD, F_CUTFILE }, 801 { "f.deiconify", FKEYWORD, F_DEICONIFY }, 802 { "f.delete", FKEYWORD, F_DELETE }, 803 { "f.deleteordestroy", FKEYWORD, F_DELETEORDESTROY }, 804 { "f.deltastop", FKEYWORD, F_DELTASTOP }, 805 { "f.destroy", FKEYWORD, F_DESTROY }, 806 { "f.downiconmgr", FKEYWORD, F_DOWNICONMGR }, 807 { "f.downworkspace", FKEYWORD, F_DOWNWORKSPACE }, 808 { "f.exec", FSKEYWORD, F_EXEC }, 809 { "f.file", FSKEYWORD, F_FILE }, 810 { "f.fill", FSKEYWORD, F_FILL }, 811 { "f.fittocontent", FKEYWORD, F_FITTOCONTENT }, 812 { "f.focus", FKEYWORD, F_FOCUS }, 813 { "f.forcemove", FKEYWORD, F_FORCEMOVE }, 814 { "f.forwiconmgr", FKEYWORD, F_FORWICONMGR }, 815 { "f.forwmapiconmgr", FKEYWORD, F_FORWMAPICONMGR }, 816 { "f.fullzoom", FKEYWORD, F_FULLZOOM }, 817 { "f.function", FSKEYWORD, F_FUNCTION }, 818 { "f.gotoworkspace", FSKEYWORD, F_GOTOWORKSPACE }, 819 { "f.hbzoom", FKEYWORD, F_BOTTOMZOOM }, 820 { "f.hideiconmgr", FKEYWORD, F_HIDELIST }, 821 { "f.hideworkspacemgr", FKEYWORD, F_HIDEWORKMGR }, 822 { "f.horizoom", FKEYWORD, F_HORIZOOM }, 823 { "f.htzoom", FKEYWORD, F_TOPZOOM }, 824 { "f.hypermove", FKEYWORD, F_HYPERMOVE }, 825 { "f.hzoom", FKEYWORD, F_HORIZOOM }, 826 { "f.iconify", FKEYWORD, F_ICONIFY }, 827 { "f.identify", FKEYWORD, F_IDENTIFY }, 828 { "f.initsize", FKEYWORD, F_INITSIZE }, 829 { "f.jumpdown", FSKEYWORD, F_JUMPDOWN }, 830 { "f.jumpleft", FSKEYWORD, F_JUMPLEFT }, 831 { "f.jumpright", FSKEYWORD, F_JUMPRIGHT }, 832 { "f.jumpup", FSKEYWORD, F_JUMPUP }, 833 { "f.lefticonmgr", FKEYWORD, F_LEFTICONMGR }, 834 { "f.leftworkspace", FKEYWORD, F_LEFTWORKSPACE }, 835 { "f.leftzoom", FKEYWORD, F_LEFTZOOM }, 836 { "f.lower", FKEYWORD, F_LOWER }, 837 { "f.menu", FSKEYWORD, F_MENU }, 838 { "f.move", FKEYWORD, F_MOVE }, 839 { "f.movemenu", FKEYWORD, F_MOVEMENU }, 840 { "f.movepack", FKEYWORD, F_MOVEPACK }, 841 { "f.movepush", FKEYWORD, F_MOVEPUSH }, 842 { "f.moveresize", FSKEYWORD, F_MOVERESIZE }, 843 { "f.movetitlebar", FKEYWORD, F_MOVETITLEBAR }, 844 { "f.movetonextworkspace", FKEYWORD, F_MOVETONEXTWORKSPACE }, 845 { "f.movetonextworkspaceandfollow", FKEYWORD, F_MOVETONEXTWORKSPACEANDFOLLOW }, 846 { "f.movetoprevworkspace", FKEYWORD, F_MOVETOPREVWORKSPACE }, 847 { "f.movetoprevworkspaceandfollow", FKEYWORD, F_MOVETOPREVWORKSPACEANDFOLLOW }, 848 { "f.nexticonmgr", FKEYWORD, F_NEXTICONMGR }, 849 { "f.nextworkspace", FKEYWORD, F_NEXTWORKSPACE }, 850 { "f.nop", FKEYWORD, F_NOP }, 851 { "f.occupy", FKEYWORD, F_OCCUPY }, 852 { "f.occupyall", FKEYWORD, F_OCCUPYALL }, 853 { "f.pack", FSKEYWORD, F_PACK }, 854 { "f.pin", FKEYWORD, F_PIN }, 855 { "f.previconmgr", FKEYWORD, F_PREVICONMGR }, 856 { "f.prevworkspace", FKEYWORD, F_PREVWORKSPACE }, 857 { "f.quit", FKEYWORD, F_QUIT }, 858 { "f.raise", FKEYWORD, F_RAISE }, 859 { "f.raiseicons", FKEYWORD, F_RAISEICONS }, 860 { "f.raiselower", FKEYWORD, F_RAISELOWER }, 861 { "f.refresh", FKEYWORD, F_REFRESH }, 862 { "f.removefromworkspace", FSKEYWORD, F_REMOVEFROMWORKSPACE }, 863#ifdef SOUNDS 864 { "f.rereadsounds", FKEYWORD, F_REREADSOUNDS }, 865#endif 866 { "f.resize", FKEYWORD, F_RESIZE }, 867 { "f.restart", FKEYWORD, F_RESTART }, 868 { "f.restoregeometry", FKEYWORD, F_RESTOREGEOMETRY }, 869 { "f.righticonmgr", FKEYWORD, F_RIGHTICONMGR }, 870 { "f.rightworkspace", FKEYWORD, F_RIGHTWORKSPACE }, 871 { "f.rightzoom", FKEYWORD, F_RIGHTZOOM }, 872 { "f.ring", FKEYWORD, F_RING }, 873 { "f.savegeometry", FKEYWORD, F_SAVEGEOMETRY }, 874 { "f.saveyourself", FKEYWORD, F_SAVEYOURSELF }, 875 { "f.separator", FKEYWORD, F_SEPARATOR }, 876 { "f.setbuttonsstate", FKEYWORD, F_SETBUTTONSTATE }, 877 { "f.setmapstate", FKEYWORD, F_SETMAPSTATE }, 878 { "f.showbackground", FKEYWORD, F_SHOWBGRD }, 879 { "f.showiconmgr", FKEYWORD, F_SHOWLIST }, 880 { "f.showworkspacemgr", FKEYWORD, F_SHOWWORKMGR }, 881 { "f.slowdownanimation", FKEYWORD, F_SLOWDOWNANIMATION }, 882 { "f.sorticonmgr", FKEYWORD, F_SORTICONMGR }, 883 { "f.source", FSKEYWORD, F_BEEP }, /* XXX - don't work */ 884 { "f.speedupanimation", FKEYWORD, F_SPEEDUPANIMATION }, 885 { "f.squeeze", FKEYWORD, F_SQUEEZE }, 886 { "f.startanimation", FKEYWORD, F_STARTANIMATION }, 887 { "f.stopanimation", FKEYWORD, F_STOPANIMATION }, 888 { "f.title", FKEYWORD, F_TITLE }, 889 { "f.toggleoccupation", FSKEYWORD, F_TOGGLEOCCUPATION }, 890#ifdef SOUNDS 891 { "f.togglesound", FKEYWORD, F_TOGGLESOUND }, 892#endif 893 { "f.togglestate", FKEYWORD, F_TOGGLESTATE }, 894 { "f.toggleworkspacemgr", FKEYWORD, F_TOGGLEWORKMGR }, 895 { "f.topzoom", FKEYWORD, F_TOPZOOM }, 896 { "f.trace", FSKEYWORD, F_TRACE }, 897 { "f.twmrc", FKEYWORD, F_RESTART }, 898 { "f.unfocus", FKEYWORD, F_UNFOCUS }, 899 { "f.upiconmgr", FKEYWORD, F_UPICONMGR }, 900 { "f.upworkspace", FKEYWORD, F_UPWORKSPACE }, 901 { "f.vanish", FKEYWORD, F_VANISH }, 902 { "f.version", FKEYWORD, F_VERSION }, 903 { "f.vlzoom", FKEYWORD, F_LEFTZOOM }, 904 { "f.vrzoom", FKEYWORD, F_RIGHTZOOM }, 905 { "f.warphere", FSKEYWORD, F_WARPHERE }, 906 { "f.warpring", FSKEYWORD, F_WARPRING }, 907 { "f.warpto", FSKEYWORD, F_WARPTO }, 908 { "f.warptoiconmgr", FSKEYWORD, F_WARPTOICONMGR }, 909 { "f.warptoscreen", FSKEYWORD, F_WARPTOSCREEN }, 910 { "f.winrefresh", FKEYWORD, F_WINREFRESH }, 911 { "f.zoom", FKEYWORD, F_ZOOM }, 912 { "forceicons", KEYWORD, kw0_ForceIcons }, 913 { "frame", FRAME, 0 }, 914 { "framepadding", NKEYWORD, kwn_FramePadding }, 915 { "function", FUNCTION, 0 }, 916 { "i", ICON, 0 }, 917 { "icon", ICON, 0 }, 918 { "iconbackground", CLKEYWORD, kwcl_IconBackground }, 919 { "iconbordercolor", CLKEYWORD, kwcl_IconBorderColor }, 920 { "iconborderwidth", NKEYWORD, kwn_IconBorderWidth }, 921 { "icondirectory", SKEYWORD, kws_IconDirectory }, 922 { "iconfont", SKEYWORD, kws_IconFont }, 923 { "iconforeground", CLKEYWORD, kwcl_IconForeground }, 924 { "iconifybyunmapping", ICONIFY_BY_UNMAPPING, 0 }, 925 { "iconifyfunction", ICONIFY_FUNCTION, 0 }, 926 { "iconifystyle", SKEYWORD, kws_IconifyStyle }, 927 { "iconjustification", SKEYWORD, kws_IconJustification }, 928 { "iconmanagerbackground", CLKEYWORD, kwcl_IconManagerBackground }, 929 { "iconmanagerdontshow", ICONMGR_NOSHOW, 0 }, 930 { "iconmanagerfont", SKEYWORD, kws_IconManagerFont }, 931 { "iconmanagerforeground", CLKEYWORD, kwcl_IconManagerForeground }, 932 { "iconmanagergeometry", ICONMGR_GEOMETRY, 0 }, 933 { "iconmanagerhighlight", CLKEYWORD, kwcl_IconManagerHighlight }, 934 { "iconmanagers", ICONMGRS, 0 }, 935 { "iconmanagershadowdepth", NKEYWORD, kwn_IconManagerShadowDepth }, 936 { "iconmanagershow", ICONMGR_SHOW, 0 }, 937 { "iconmenudontshow", ICONMENU_DONTSHOW, 0 }, 938 { "iconmgr", ICONMGR, 0 }, 939 { "iconregion", ICON_REGION, 0 }, 940 { "iconregionalignement", SKEYWORD, kws_IconRegionAlignement }, 941 { "iconregionjustification",SKEYWORD, kws_IconRegionJustification }, 942 { "icons", ICONS, 0 }, 943 { "ignorecaseinmenuselection", KEYWORD, kw0_IgnoreCaseInMenuSelection }, 944 { "ignorelockmodifier", KEYWORD, kw0_IgnoreLockModifier }, 945 { "ignoremodifier", IGNOREMODIFIER, 0 }, 946 { "ignoretransient", IGNORE_TRANSIENT, 0 }, 947 { "interpolatemenucolors", KEYWORD, kw0_InterpolateMenuColors }, 948 { "l", LOCK, 0 }, 949 { "left", JKEYWORD, J_LEFT }, 950 { "lefttitlebutton", LEFT_TITLEBUTTON, 0 }, 951 { "lock", LOCK, 0 }, 952 { "m", META, 0 }, 953 { "maketitle", MAKE_TITLE, 0 }, 954 { "mapwindowbackground", CLKEYWORD, kwcl_MapWindowBackground }, 955 { "mapwindowcurrentworkspace", MAPWINDOWCURRENTWORKSPACE, 0}, 956 { "mapwindowdefaultworkspace", MAPWINDOWDEFAULTWORKSPACE, 0}, 957 { "mapwindowforeground", CLKEYWORD, kwcl_MapWindowForeground }, 958 { "maxicontitlewidth", NKEYWORD, kwn_MaxIconTitleWidth }, 959 { "maxwindowsize", SKEYWORD, kws_MaxWindowSize }, 960 { "menu", MENU, 0 }, 961 { "menubackground", CKEYWORD, kwc_MenuBackground }, 962 { "menufont", SKEYWORD, kws_MenuFont }, 963 { "menuforeground", CKEYWORD, kwc_MenuForeground }, 964 { "menushadowcolor", CKEYWORD, kwc_MenuShadowColor }, 965 { "menushadowdepth", NKEYWORD, kwn_MenuShadowDepth }, 966 { "menutitlebackground", CKEYWORD, kwc_MenuTitleBackground }, 967 { "menutitleforeground", CKEYWORD, kwc_MenuTitleForeground }, 968 { "meta", META, 0 }, 969 { "mod", META, 0 }, /* fake it */ 970 { "monochrome", MONOCHROME, 0 }, 971 { "move", MOVE, 0 }, 972 { "movedelta", NKEYWORD, kwn_MoveDelta }, 973 { "moveoffresistance", NKEYWORD, kwn_MoveOffResistance }, 974 { "movepackresistance", NKEYWORD, kwn_MovePackResistance }, 975 { "nobackingstore", KEYWORD, kw0_NoBackingStore }, 976 { "noborder", NO_BORDER, 0 }, 977 { "nocasesensitive", KEYWORD, kw0_NoCaseSensitive }, 978 { "nodefaults", KEYWORD, kw0_NoDefaults }, 979 { "nograbserver", KEYWORD, kw0_NoGrabServer }, 980 { "nohighlight", NO_HILITE, 0 }, 981 { "noiconmanagerfocus", KEYWORD, kw0_NoIconManagerFocus }, 982 { "noiconmanagers", KEYWORD, kw0_NoIconManagers }, 983 { "noicontitle", NO_ICON_TITLE, 0 }, 984 { "noimagesinworkspacemanager", KEYWORD, kw0_NoImagesInWorkSpaceManager }, 985 { "nomenushadows", KEYWORD, kw0_NoMenuShadows }, 986 { "noopaquemove", NOOPAQUEMOVE, 0 }, 987 { "noopaqueresize", NOOPAQUERESIZE, 0 }, 988 { "noraiseondeiconify", KEYWORD, kw0_NoRaiseOnDeiconify }, 989 { "noraiseonmove", KEYWORD, kw0_NoRaiseOnMove }, 990 { "noraiseonresize", KEYWORD, kw0_NoRaiseOnResize }, 991 { "noraiseonwarp", KEYWORD, kw0_NoRaiseOnWarp }, 992 { "north", DKEYWORD, D_NORTH }, 993 { "nosaveunders", KEYWORD, kw0_NoSaveUnders }, 994 { "noshowoccupyall", KEYWORD, kw0_NoShowOccupyAll }, 995 { "nostackmode", NO_STACKMODE, 0 }, 996 { "notitle", NO_TITLE, 0 }, 997 { "notitlefocus", KEYWORD, kw0_NoTitleFocus }, 998 { "notitlehighlight", NO_TITLE_HILITE, 0 }, 999 { "noversion", KEYWORD, kw0_NoVersion }, 1000 { "nowarptomenutitle", KEYWORD, kw0_NoWarpToMenuTitle }, 1001 { "occupy", OCCUPYLIST, 0 }, 1002 { "occupyall", OCCUPYALL, 0 }, 1003 { "opaquemove", OPAQUEMOVE, 0 }, 1004 { "opaquemovethreshold", NKEYWORD, kwn_OpaqueMoveThreshold }, 1005 { "opaqueresize", OPAQUERESIZE, 0 }, 1006 { "opaqueresizethreshold", NKEYWORD, kwn_OpaqueResizeThreshold }, 1007 { "openwindowtimeout", NKEYWORD, kwn_OpenWindowTimeout }, 1008 { "packnewwindows", KEYWORD, kw0_PackNewWindows }, 1009 { "pixmapdirectory", SKEYWORD, kws_PixmapDirectory }, 1010 { "pixmaps", PIXMAPS, 0 }, 1011 { "r", ROOT, 0 }, 1012 { "raisedelay", NKEYWORD, kwn_RaiseDelay }, 1013 { "raiseonclick", KEYWORD, kw0_RaiseOnClick }, 1014 { "raiseonclickbutton", NKEYWORD, kwn_RaiseOnClickButton }, 1015 { "raiseonwarp", KEYWORD, kw0_RaiseOnWarp }, 1016 { "raisewhenautounsqueeze", KEYWORD, kw0_RaiseWhenAutoUnSqueeze }, 1017 { "randomplacement", SSKEYWORD, kwss_RandomPlacement }, 1018 { "reallymoveinworkspacemanager", KEYWORD, kw0_ReallyMoveInWorkspaceManager }, 1019 { "resize", RESIZE, 0 }, 1020 { "resizefont", SKEYWORD, kws_ResizeFont }, 1021 { "restartpreviousstate", KEYWORD, kw0_RestartPreviousState }, 1022 { "reversecurrentworkspace",KEYWORD, kw0_ReverseCurrentWorkspace }, 1023 { "right", JKEYWORD, J_RIGHT }, 1024 { "righttitlebutton", RIGHT_TITLEBUTTON, 0 }, 1025 { "root", ROOT, 0 }, 1026 { "s", SHIFT, 0 }, 1027 { "savecolor", SAVECOLOR, 0}, 1028 { "saveworkspacefocus", KEYWORD, kw0_SaveWorkspaceFocus }, 1029 { "schrinkicontitles", KEYWORD, kw0_ShrinkIconTitles }, 1030 { "select", SELECT, 0 }, 1031 { "shift", SHIFT, 0 }, 1032 { "shortallwindowsmenus", KEYWORD, kw0_ShortAllWindowsMenus }, 1033 { "showiconmanager", KEYWORD, kw0_ShowIconManager }, 1034 { "showworkspacemanager", KEYWORD, kw0_ShowWorkspaceManager }, 1035 { "shrinkicontitles", KEYWORD, kw0_ShrinkIconTitles }, 1036 { "sloppyfocus", KEYWORD, kw0_SloppyFocus }, 1037 { "sorticonmanager", KEYWORD, kw0_SortIconManager }, 1038#ifdef SOUNDS 1039 { "soundhost", SKEYWORD, kws_SoundHost }, 1040#endif 1041 { "south", DKEYWORD, D_SOUTH }, 1042 { "squeezetitle", SQUEEZE_TITLE, 0 }, 1043 { "starticonified", START_ICONIFIED, 0 }, 1044 { "startinmapstate", KEYWORD, kw0_StartInMapState }, 1045 { "startsqueezed", STARTSQUEEZED, 0 }, 1046 { "stayupmenus", KEYWORD, kw0_StayUpMenus }, 1047 { "sunkfocuswindowtitle", KEYWORD, kw0_SunkFocusWindowTitle }, 1048 { "t", TITLE, 0 }, 1049 { "threedborderwidth", NKEYWORD, kwn_ThreeDBorderWidth }, 1050 { "title", TITLE, 0 }, 1051 { "titlebackground", CLKEYWORD, kwcl_TitleBackground }, 1052 { "titlebuttonborderwidth", NKEYWORD, kwn_TitleButtonBorderWidth }, 1053 { "titlebuttonshadowdepth", NKEYWORD, kwn_TitleButtonShadowDepth }, 1054 { "titlefont", SKEYWORD, kws_TitleFont }, 1055 { "titleforeground", CLKEYWORD, kwcl_TitleForeground }, 1056 { "titlehighlight", TITLE_HILITE, 0 }, 1057 { "titlejustification", SKEYWORD, kws_TitleJustification }, 1058 { "titlepadding", NKEYWORD, kwn_TitlePadding }, 1059 { "titleshadowdepth", NKEYWORD, kwn_TitleShadowDepth }, 1060 { "transienthasoccupation", KEYWORD, kw0_TransientHasOccupation }, 1061 { "transientontop", NKEYWORD, kwn_TransientOnTop }, 1062 { "unknownicon", SKEYWORD, kws_UnknownIcon }, 1063 { "unmapbymovingfaraway", UNMAPBYMOVINGFARAWAY, 0 }, 1064 { "usepposition", SKEYWORD, kws_UsePPosition }, 1065 { "usesunktitlepixmap", KEYWORD, kw0_UseSunkTitlePixmap }, 1066 { "usethreedborders", KEYWORD, kw0_Use3DBorders }, 1067 { "usethreediconborders", KEYWORD, kw0_use3DIconBorders }, 1068 { "usethreediconmanagers", KEYWORD, kw0_Use3DIconManagers }, 1069 { "usethreedmenus", KEYWORD, kw0_Use3DMenus }, 1070 { "usethreedtitles", KEYWORD, kw0_Use3DTitles }, 1071 { "usethreedwmap", KEYWORD, kw0_Use3DWMap }, 1072 { "virtualscreens", VIRTUAL_SCREENS, 0 }, 1073 { "w", WINDOW, 0 }, 1074 { "wait", WAITC, 0 }, 1075 { "warpcursor", WARP_CURSOR, 0 }, 1076 { "warpringonscreen", KEYWORD, kw0_WarpRingOnScreen }, 1077 { "warptodefaultmenuentry", KEYWORD, kw0_WarpToDefaultMenuEntry }, 1078 { "warpunmapped", KEYWORD, kw0_WarpUnmapped }, 1079 { "west", DKEYWORD, D_WEST }, 1080 { "window", WINDOW, 0 }, 1081 { "windowbox", WINDOW_BOX, 0 }, 1082 { "windowfunction", WINDOW_FUNCTION, 0 }, 1083 { "windowgeometries", WINDOW_GEOMETRIES, 0 }, 1084 { "windowregion", WINDOW_REGION, 0 }, 1085 { "windowring", WINDOW_RING, 0 }, 1086 { "windowringexclude", WINDOW_RING_EXCLUDE, 0}, 1087 { "wmgrbuttonshadowdepth", NKEYWORD, kwn_WMgrButtonShadowDepth }, 1088 { "wmgrbuttonstyle", SKEYWORD, kws_WMgrButtonStyle }, 1089 { "wmgrhorizbuttonindent", NKEYWORD, kwn_WMgrHorizButtonIndent }, 1090 { "wmgrvertbuttonindent", NKEYWORD, kwn_WMgrVertButtonIndent }, 1091 { "workspace", WORKSPACE, 0 }, 1092 { "workspacefont", SKEYWORD, kws_WorkSpaceFont }, 1093 { "workspacemanagergeometry", WORKSPCMGR_GEOMETRY, 0 }, 1094 { "workspaces", WORKSPACES, 0}, 1095 { "xmovegrid", NKEYWORD, kwn_XMoveGrid }, 1096 { "xorvalue", NKEYWORD, kwn_XorValue }, 1097 { "xpmicondirectory", SKEYWORD, kws_PixmapDirectory }, 1098 { "ymovegrid", NKEYWORD, kwn_YMoveGrid }, 1099 { "zoom", ZOOM, 0 }, 1100}; 1101 1102static int numkeywords = (sizeof(keytable)/sizeof(keytable[0])); 1103 1104int parse_keyword (char *s, int *nump) 1105{ 1106 register int lower = 0, upper = numkeywords - 1; 1107 1108 XmuCopyISOLatin1Lowered (s, s); 1109 while (lower <= upper) { 1110 int middle = (lower + upper) / 2; 1111 TwmKeyword *p = &keytable[middle]; 1112 int res = strcmp (p->name, s); 1113 1114 if (res < 0) { 1115 lower = middle + 1; 1116 } else if (res == 0) { 1117 *nump = p->subnum; 1118 return p->value; 1119 } else { 1120 upper = middle - 1; 1121 } 1122 } 1123 return ERRORTOKEN; 1124} 1125 1126 1127 1128/* 1129 * action routines called by grammar 1130 */ 1131 1132int do_single_keyword (int keyword) 1133{ 1134 switch (keyword) { 1135 case kw0_NoDefaults: 1136 Scr->NoDefaults = TRUE; 1137 return 1; 1138 1139 case kw0_AutoRelativeResize: 1140 Scr->AutoRelativeResize = TRUE; 1141 return 1; 1142 1143 case kw0_ForceIcons: 1144 if (Scr->FirstTime) Scr->ForceIcon = TRUE; 1145 return 1; 1146 1147 case kw0_NoIconManagers: 1148 Scr->NoIconManagers = TRUE; 1149 return 1; 1150 1151 case kw0_InterpolateMenuColors: 1152 if (Scr->FirstTime) Scr->InterpolateMenuColors = TRUE; 1153 return 1; 1154 1155 case kw0_NoVersion: 1156 /* obsolete */ 1157 return 1; 1158 1159 case kw0_SortIconManager: 1160 if (Scr->FirstTime) Scr->SortIconMgr = TRUE; 1161 return 1; 1162 1163 case kw0_NoGrabServer: 1164 Scr->NoGrabServer = TRUE; 1165 return 1; 1166 1167 case kw0_NoMenuShadows: 1168 if (Scr->FirstTime) Scr->Shadow = FALSE; 1169 return 1; 1170 1171 case kw0_NoRaiseOnMove: 1172 if (Scr->FirstTime) Scr->NoRaiseMove = TRUE; 1173 return 1; 1174 1175 case kw0_NoRaiseOnResize: 1176 if (Scr->FirstTime) Scr->NoRaiseResize = TRUE; 1177 return 1; 1178 1179 case kw0_NoRaiseOnDeiconify: 1180 if (Scr->FirstTime) Scr->NoRaiseDeicon = TRUE; 1181 return 1; 1182 1183 case kw0_DontMoveOff: 1184 Scr->DontMoveOff = TRUE; 1185 return 1; 1186 1187 case kw0_NoBackingStore: 1188 Scr->BackingStore = FALSE; 1189 return 1; 1190 1191 case kw0_NoSaveUnders: 1192 Scr->SaveUnder = FALSE; 1193 return 1; 1194 1195 case kw0_RestartPreviousState: 1196 RestartPreviousState = True; 1197 return 1; 1198 1199 case kw0_ClientBorderWidth: 1200 if (Scr->FirstTime) Scr->ClientBorderWidth = TRUE; 1201 return 1; 1202 1203 case kw0_NoTitleFocus: 1204 Scr->TitleFocus = TRUE /*FALSE*/; 1205 return 1; 1206 1207 case kw0_DecorateTransients: 1208 Scr->DecorateTransients = TRUE; 1209 return 1; 1210 1211 case kw0_ShowIconManager: 1212 Scr->ShowIconManager = TRUE; 1213 return 1; 1214 1215 case kw0_ShowWorkspaceManager: 1216 Scr->ShowWorkspaceManager = TRUE; 1217 return 1; 1218 1219 case kw0_StartInMapState: 1220 Scr->workSpaceMgr.initialstate = MAPSTATE; 1221 return 1; 1222 1223 case kw0_NoShowOccupyAll: 1224 Scr->workSpaceMgr.noshowoccupyall = TRUE; 1225 return 1; 1226 1227 case kw0_AutoOccupy: 1228 Scr->AutoOccupy = TRUE; 1229 return 1; 1230 1231 case kw0_TransientHasOccupation: 1232 Scr->TransientHasOccupation = TRUE; 1233 return 1; 1234 1235 case kw0_DontPaintRootWindow: 1236 Scr->DontPaintRootWindow = TRUE; 1237 return 1; 1238 1239 case kw0_UseSunkTitlePixmap: 1240 Scr->UseSunkTitlePixmap = TRUE; 1241 return 1; 1242 1243 case kw0_Use3DBorders: 1244 Scr->use3Dborders = TRUE; 1245 return 1; 1246 1247 case kw0_Use3DIconManagers: 1248 Scr->use3Diconmanagers = TRUE; 1249 return 1; 1250 1251 case kw0_Use3DMenus: 1252 Scr->use3Dmenus = TRUE; 1253 return 1; 1254 1255 case kw0_Use3DTitles: 1256 Scr->use3Dtitles = TRUE; 1257 return 1; 1258 1259 case kw0_Use3DWMap: 1260 Scr->use3Dwmap = TRUE; 1261 return 1; 1262 1263 case kw0_SunkFocusWindowTitle: 1264 Scr->SunkFocusWindowTitle = TRUE; 1265 return 1; 1266 1267 case kw0_BeNiceToColormap: 1268 Scr->BeNiceToColormap = TRUE; 1269 return 1; 1270 1271 case kw0_BorderResizeCursors: 1272 Scr->BorderCursors = TRUE; 1273 return 1; 1274 1275 case kw0_NoCaseSensitive: 1276 Scr->CaseSensitive = FALSE; 1277 return 1; 1278 1279 case kw0_NoRaiseOnWarp: 1280 Scr->RaiseOnWarp = FALSE; 1281 return 1; 1282 1283 case kw0_RaiseOnWarp: 1284 Scr->RaiseOnWarp = TRUE; 1285 return 1; 1286 1287 case kw0_WarpUnmapped: 1288 Scr->WarpUnmapped = TRUE; 1289 return 1; 1290 1291 case kw0_WarpRingOnScreen: 1292 Scr->WarpRingAnyWhere = FALSE; 1293 return 1; 1294 1295 case kw0_NoIconManagerFocus: 1296 Scr->IconManagerFocus = FALSE; 1297 return 1; 1298 1299 case kw0_StayUpMenus: 1300 Scr->StayUpMenus = TRUE; 1301 return 1; 1302 1303 case kw0_ClickToFocus: 1304 Scr->ClickToFocus = TRUE; 1305 return 1; 1306 1307 case kw0_ReallyMoveInWorkspaceManager: 1308 Scr->ReallyMoveInWorkspaceManager = TRUE; 1309 return 1; 1310 1311 case kw0_ShowWinWhenMovingInWmgr: 1312 Scr->ShowWinWhenMovingInWmgr = TRUE; 1313 return 1; 1314 1315 case kw0_ReverseCurrentWorkspace: 1316 Scr->ReverseCurrentWorkspace = TRUE; 1317 return 1; 1318 1319 case kw0_DontWarpCursorInWMap: 1320 Scr->DontWarpCursorInWMap = TRUE; 1321 return 1; 1322 1323 case kw0_CenterFeedbackWindow: 1324 Scr->CenterFeedbackWindow = TRUE; 1325 return 1; 1326 1327 case kw0_WarpToDefaultMenuEntry: 1328 Scr->WarpToDefaultMenuEntry = TRUE; 1329 return 1; 1330 1331 case kw0_ShrinkIconTitles: 1332 Scr->ShrinkIconTitles = TRUE; 1333 return 1; 1334 1335 case kw0_AutoRaiseIcons: 1336 Scr->AutoRaiseIcons = TRUE; 1337 return 1; 1338 1339 /* kai */ 1340 case kw0_AutoFocusToTransients: 1341 Scr->AutoFocusToTransients = TRUE; 1342 return 1; 1343 1344 case kw0_use3DIconBorders: 1345 Scr->use3Diconborders = TRUE; 1346 return 1; 1347 1348 case kw0_ShortAllWindowsMenus: 1349 Scr->ShortAllWindowsMenus = TRUE; 1350 return 1; 1351 1352 case kw0_RaiseWhenAutoUnSqueeze: 1353 Scr->RaiseWhenAutoUnSqueeze = TRUE; 1354 return 1; 1355 1356 case kw0_RaiseOnClick: 1357 Scr->RaiseOnClick = TRUE; 1358 return 1; 1359 1360 case kw0_IgnoreLockModifier: 1361 Scr->IgnoreLockModifier = TRUE; 1362 return 1; 1363 1364 case kw0_PackNewWindows: 1365 Scr->PackNewWindows = TRUE; 1366 return 1; 1367 1368 case kw0_IgnoreCaseInMenuSelection: 1369 Scr->IgnoreCaseInMenuSelection = TRUE; 1370 return 1; 1371 1372 case kw0_SloppyFocus: 1373 Scr->SloppyFocus = TRUE; 1374 return 1; 1375 1376 case kw0_SaveWorkspaceFocus: 1377 Scr->SaveWorkspaceFocus = TRUE; 1378 return 1; 1379 1380 case kw0_NoImagesInWorkSpaceManager: 1381 Scr->NoImagesInWorkSpaceManager = TRUE; 1382 return 1; 1383 1384 case kw0_NoWarpToMenuTitle: 1385 Scr->NoWarpToMenuTitle = TRUE; 1386 return 1; 1387 1388 } 1389 return 0; 1390} 1391 1392 1393int do_string_string_keyword (int keyword, char *s1, char *s2) 1394{ 1395 switch (keyword) { 1396 case kwss_RandomPlacement: 1397 { 1398 int rp = ParseRandomPlacement (s1); 1399 if (rp < 0) { 1400 twmrc_error_prefix(); 1401 fprintf (stderr, 1402 "ignoring invalid RandomPlacement argument 1 \"%s\"\n", s1); 1403 } else { 1404 Scr->RandomPlacement = rp; 1405 } 1406 } 1407 { 1408 if (strcmp (s2, "default") == 0) return 1; 1409 JunkMask = XParseGeometry (s2, &JunkX, &JunkY, &JunkWidth, &JunkHeight); 1410#ifdef DEBUG 1411 fprintf (stderr, "DEBUG:: JunkMask = %x, WidthValue = %x, HeightValue = %x\n", JunkMask, WidthValue, HeightValue); 1412 fprintf (stderr, "DEBUG:: JunkX = %d, JunkY = %d\n", JunkX, JunkY); 1413#endif 1414 if ((JunkMask & (XValue | YValue)) != 1415 (XValue | YValue)) { 1416 twmrc_error_prefix(); 1417 fprintf (stderr, 1418 "ignoring invalid RandomPlacement displacement \"%s\"\n", s2); 1419 } else { 1420 Scr->RandomDisplacementX = JunkX; 1421 Scr->RandomDisplacementY = JunkY; 1422 } 1423 return 1; 1424 } 1425 } 1426 return 0; 1427} 1428 1429 1430int do_string_keyword (int keyword, char *s) 1431{ 1432 switch (keyword) { 1433 case kws_UsePPosition: 1434 { 1435 int ppos = ParseUsePPosition (s); 1436 if (ppos < 0) { 1437 twmrc_error_prefix(); 1438 fprintf (stderr, 1439 "ignoring invalid UsePPosition argument \"%s\"\n", s); 1440 } else { 1441 Scr->UsePPosition = ppos; 1442 } 1443 return 1; 1444 } 1445 1446 case kws_IconFont: 1447 if (!Scr->HaveFonts) Scr->IconFont.basename = s; 1448 return 1; 1449 1450 case kws_ResizeFont: 1451 if (!Scr->HaveFonts) Scr->SizeFont.basename = s; 1452 return 1; 1453 1454 case kws_MenuFont: 1455 if (!Scr->HaveFonts) Scr->MenuFont.basename = s; 1456 return 1; 1457 1458 case kws_WorkSpaceFont: 1459 if (!Scr->HaveFonts) Scr->workSpaceMgr.windowFont.basename = s; 1460 return 1; 1461 1462 case kws_TitleFont: 1463 if (!Scr->HaveFonts) Scr->TitleBarFont.basename = s; 1464 return 1; 1465 1466 case kws_IconManagerFont: 1467 if (!Scr->HaveFonts) Scr->IconManagerFont.basename = s; 1468 return 1; 1469 1470 case kws_UnknownIcon: 1471 if (Scr->FirstTime) GetUnknownIcon (s); 1472 return 1; 1473 1474 case kws_IconDirectory: 1475 if (Scr->FirstTime) Scr->IconDirectory = ExpandFilePath (s); 1476 return 1; 1477 1478 case kws_PixmapDirectory: 1479 if (Scr->FirstTime) Scr->PixmapDirectory = ExpandFilePath (s); 1480 return 1; 1481 1482 case kws_MaxWindowSize: 1483 JunkMask = XParseGeometry (s, &JunkX, &JunkY, &JunkWidth, &JunkHeight); 1484 if ((JunkMask & (WidthValue | HeightValue)) != 1485 (WidthValue | HeightValue)) { 1486 twmrc_error_prefix(); 1487 fprintf (stderr, "bad MaxWindowSize \"%s\"\n", s); 1488 return 0; 1489 } 1490 if (JunkWidth == 0 || JunkHeight == 0) { 1491 twmrc_error_prefix(); 1492 fprintf (stderr, "MaxWindowSize \"%s\" must be non-zero\n", s); 1493 return 0; 1494 } 1495 Scr->MaxWindowWidth = JunkWidth; 1496 Scr->MaxWindowHeight = JunkHeight; 1497 return 1; 1498 1499 case kws_IconJustification: 1500 { 1501 int just = ParseJustification (s); 1502 1503 if ((just < 0) || (just == J_BORDER)) { 1504 twmrc_error_prefix(); 1505 fprintf (stderr, 1506 "ignoring invalid IconJustification argument \"%s\"\n", s); 1507 } else { 1508 Scr->IconJustification = just; 1509 } 1510 return 1; 1511 } 1512 case kws_IconRegionJustification: 1513 { 1514 int just = ParseJustification (s); 1515 1516 if (just < 0) { 1517 twmrc_error_prefix(); 1518 fprintf (stderr, 1519 "ignoring invalid IconRegionJustification argument \"%s\"\n", s); 1520 } else { 1521 Scr->IconRegionJustification = just; 1522 } 1523 return 1; 1524 } 1525 case kws_IconRegionAlignement: 1526 { 1527 int just = ParseAlignement (s); 1528 1529 if (just < 0) { 1530 twmrc_error_prefix(); 1531 fprintf (stderr, 1532 "ignoring invalid IconRegionAlignement argument \"%s\"\n", s); 1533 } else { 1534 Scr->IconRegionAlignement = just; 1535 } 1536 return 1; 1537 } 1538 1539 case kws_TitleJustification: 1540 { 1541 int just = ParseJustification (s); 1542 1543 if ((just < 0) || (just == J_BORDER)) { 1544 twmrc_error_prefix(); 1545 fprintf (stderr, 1546 "ignoring invalid TitleJustification argument \"%s\"\n", s); 1547 } else { 1548 Scr->TitleJustification = just; 1549 } 1550 return 1; 1551 } 1552#ifdef SOUNDS 1553 case kws_SoundHost: 1554 if (Scr->FirstTime) set_sound_host(s); 1555 return 1; 1556#endif 1557 1558 case kws_WMgrButtonStyle: 1559 { 1560 int style = ParseButtonStyle (s); 1561 1562 if (style < 0) { 1563 twmrc_error_prefix(); 1564 fprintf (stderr, 1565 "ignoring invalid WMgrButtonStyle argument \"%s\"\n", s); 1566 } else { 1567 Scr->workSpaceMgr.buttonStyle = style; 1568 } 1569 return 1; 1570 } 1571 1572 case kws_IconifyStyle: 1573 { 1574 if (strlen (s) == 0) { 1575 twmrc_error_prefix(); 1576 fprintf (stderr, "ignoring invalid IconifyStyle argument \"%s\"\n", s); 1577 } 1578 if (strcmp (s, "default") == 0) Scr->IconifyStyle = ICONIFY_NORMAL; 1579 XmuCopyISOLatin1Lowered (s, s); 1580 if (strcmp (s, "normal") == 0) Scr->IconifyStyle = ICONIFY_NORMAL; 1581 if (strcmp (s, "mosaic") == 0) Scr->IconifyStyle = ICONIFY_MOSAIC; 1582 if (strcmp (s, "zoomin") == 0) Scr->IconifyStyle = ICONIFY_ZOOMIN; 1583 if (strcmp (s, "zoomout") == 0) Scr->IconifyStyle = ICONIFY_ZOOMOUT; 1584 if (strcmp (s, "sweep") == 0) Scr->IconifyStyle = ICONIFY_SWEEP; 1585 return 1; 1586 } 1587 } 1588 return 0; 1589} 1590 1591 1592int do_number_keyword (int keyword, int num) 1593{ 1594 switch (keyword) { 1595 case kwn_ConstrainedMoveTime: 1596 ConstrainedMoveTime = num; 1597 return 1; 1598 1599 case kwn_MoveDelta: 1600 Scr->MoveDelta = num; 1601 return 1; 1602 1603 case kwn_MoveOffResistance: 1604 Scr->MoveOffResistance = num; 1605 return 1; 1606 1607 case kwn_MovePackResistance: 1608 if (num < 0) num = 20; 1609 Scr->MovePackResistance = num; 1610 return 1; 1611 1612 case kwn_XMoveGrid: 1613 if (num < 1) num = 1; 1614 if (num > 100) num = 100; 1615 Scr->XMoveGrid = num; 1616 return 1; 1617 1618 case kwn_YMoveGrid: 1619 if (num < 1) num = 1; 1620 if (num > 100) num = 100; 1621 Scr->YMoveGrid = num; 1622 return 1; 1623 1624 case kwn_XorValue: 1625 if (Scr->FirstTime) Scr->XORvalue = num; 1626 return 1; 1627 1628 case kwn_FramePadding: 1629 if (Scr->FirstTime) Scr->FramePadding = num; 1630 return 1; 1631 1632 case kwn_TitlePadding: 1633 if (Scr->FirstTime) { 1634 Scr->TitlePadding = num; 1635 } 1636 return 1; 1637 1638 case kwn_ButtonIndent: 1639 if (Scr->FirstTime) Scr->ButtonIndent = num; 1640 return 1; 1641 1642 case kwn_ThreeDBorderWidth: 1643 if (Scr->FirstTime) Scr->ThreeDBorderWidth = num; 1644 return 1; 1645 1646 case kwn_BorderWidth: 1647 if (Scr->FirstTime) Scr->BorderWidth = num; 1648 return 1; 1649 1650 case kwn_IconBorderWidth: 1651 if (Scr->FirstTime) Scr->IconBorderWidth = num; 1652 return 1; 1653 1654 case kwn_TitleButtonBorderWidth: 1655 if (Scr->FirstTime) Scr->TBInfo.border = num; 1656 return 1; 1657 1658 case kwn_RaiseDelay: 1659 RaiseDelay = num; 1660 return 1; 1661 1662 case kwn_TransientOnTop: 1663 if (Scr->FirstTime) Scr->TransientOnTop = num; 1664 return 1; 1665 1666 case kwn_OpaqueMoveThreshold: 1667 if (Scr->FirstTime) Scr->OpaqueMoveThreshold = num; 1668 return 1; 1669 1670 case kwn_OpaqueResizeThreshold: 1671 if (Scr->FirstTime) Scr->OpaqueResizeThreshold = num; 1672 return 1; 1673 1674 case kwn_WMgrVertButtonIndent: 1675 if (Scr->FirstTime) Scr->WMgrVertButtonIndent = num; 1676 if (Scr->WMgrVertButtonIndent < 0) Scr->WMgrVertButtonIndent = 0; 1677 Scr->workSpaceMgr.vspace = Scr->WMgrVertButtonIndent; 1678 Scr->workSpaceMgr.occupyWindow->vspace = Scr->WMgrVertButtonIndent; 1679 return 1; 1680 1681 case kwn_WMgrHorizButtonIndent: 1682 if (Scr->FirstTime) Scr->WMgrHorizButtonIndent = num; 1683 if (Scr->WMgrHorizButtonIndent < 0) Scr->WMgrHorizButtonIndent = 0; 1684 Scr->workSpaceMgr.hspace = Scr->WMgrHorizButtonIndent; 1685 Scr->workSpaceMgr.occupyWindow->hspace = Scr->WMgrHorizButtonIndent; 1686 return 1; 1687 1688 case kwn_WMgrButtonShadowDepth: 1689 if (Scr->FirstTime) Scr->WMgrButtonShadowDepth = num; 1690 if (Scr->WMgrButtonShadowDepth < 1) Scr->WMgrButtonShadowDepth = 1; 1691 return 1; 1692 1693 case kwn_MaxIconTitleWidth: 1694 if (Scr->FirstTime) Scr->MaxIconTitleWidth = num; 1695 return 1; 1696 1697 case kwn_ClearShadowContrast: 1698 if (Scr->FirstTime) Scr->ClearShadowContrast = num; 1699 if (Scr->ClearShadowContrast < 0) Scr->ClearShadowContrast = 0; 1700 if (Scr->ClearShadowContrast > 100) Scr->ClearShadowContrast = 100; 1701 return 1; 1702 1703 case kwn_DarkShadowContrast: 1704 if (Scr->FirstTime) Scr->DarkShadowContrast = num; 1705 if (Scr->DarkShadowContrast < 0) Scr->DarkShadowContrast = 0; 1706 if (Scr->DarkShadowContrast > 100) Scr->DarkShadowContrast = 100; 1707 return 1; 1708 1709 case kwn_AnimationSpeed: 1710 if (num < 0) num = 0; 1711 SetAnimationSpeed (num); 1712 return 1; 1713 1714 case kwn_BorderShadowDepth: 1715 if (Scr->FirstTime) Scr->BorderShadowDepth = num; 1716 if (Scr->BorderShadowDepth < 0) Scr->BorderShadowDepth = 2; 1717 return 1; 1718 1719 case kwn_BorderLeft: 1720 if (Scr->FirstTime) Scr->BorderLeft = num; 1721 if (Scr->BorderLeft < 0) Scr->BorderLeft = 0; 1722 return 1; 1723 1724 case kwn_BorderRight: 1725 if (Scr->FirstTime) Scr->BorderRight = num; 1726 if (Scr->BorderRight < 0) Scr->BorderRight = 0; 1727 return 1; 1728 1729 case kwn_BorderTop: 1730 if (Scr->FirstTime) Scr->BorderTop = num; 1731 if (Scr->BorderTop < 0) Scr->BorderTop = 0; 1732 return 1; 1733 1734 case kwn_BorderBottom: 1735 if (Scr->FirstTime) Scr->BorderBottom = num; 1736 if (Scr->BorderBottom < 0) Scr->BorderBottom = 0; 1737 return 1; 1738 1739 case kwn_TitleButtonShadowDepth: 1740 if (Scr->FirstTime) Scr->TitleButtonShadowDepth = num; 1741 if (Scr->TitleButtonShadowDepth < 0) Scr->TitleButtonShadowDepth = 2; 1742 return 1; 1743 1744 case kwn_TitleShadowDepth: 1745 if (Scr->FirstTime) Scr->TitleShadowDepth = num; 1746 if (Scr->TitleShadowDepth < 0) Scr->TitleShadowDepth = 2; 1747 return 1; 1748 1749 case kwn_IconManagerShadowDepth: 1750 if (Scr->FirstTime) Scr->IconManagerShadowDepth = num; 1751 if (Scr->IconManagerShadowDepth < 0) Scr->IconManagerShadowDepth = 2; 1752 return 1; 1753 1754 case kwn_MenuShadowDepth: 1755 if (Scr->FirstTime) Scr->MenuShadowDepth = num; 1756 if (Scr->MenuShadowDepth < 0) Scr->MenuShadowDepth = 2; 1757 return 1; 1758 1759 case kwn_OpenWindowTimeout: 1760 if (Scr->FirstTime) Scr->OpenWindowTimeout = num; 1761 if (Scr->OpenWindowTimeout < 0) Scr->OpenWindowTimeout = 0; 1762 return 1; 1763 1764 case kwn_RaiseOnClickButton: 1765 if (Scr->FirstTime) Scr->RaiseOnClickButton = num; 1766 if (Scr->RaiseOnClickButton < 1) Scr->RaiseOnClickButton = 1; 1767 if (Scr->RaiseOnClickButton > MAX_BUTTONS) Scr->RaiseOnClickButton = MAX_BUTTONS; 1768 return 1; 1769 1770 } 1771 1772 return 0; 1773} 1774 1775name_list **do_colorlist_keyword (int keyword, int colormode, char *s) 1776{ 1777 switch (keyword) { 1778 case kwcl_BorderColor: 1779 GetColor (colormode, &Scr->BorderColorC.back, s); 1780 return &Scr->BorderColorL; 1781 1782 case kwcl_IconManagerHighlight: 1783 GetColor (colormode, &Scr->IconManagerHighlight, s); 1784 return &Scr->IconManagerHighlightL; 1785 1786 case kwcl_BorderTileForeground: 1787 GetColor (colormode, &Scr->BorderTileC.fore, s); 1788 return &Scr->BorderTileForegroundL; 1789 1790 case kwcl_BorderTileBackground: 1791 GetColor (colormode, &Scr->BorderTileC.back, s); 1792 return &Scr->BorderTileBackgroundL; 1793 1794 case kwcl_TitleForeground: 1795 GetColor (colormode, &Scr->TitleC.fore, s); 1796 return &Scr->TitleForegroundL; 1797 1798 case kwcl_TitleBackground: 1799 GetColor (colormode, &Scr->TitleC.back, s); 1800 return &Scr->TitleBackgroundL; 1801 1802 case kwcl_IconForeground: 1803 GetColor (colormode, &Scr->IconC.fore, s); 1804 return &Scr->IconForegroundL; 1805 1806 case kwcl_IconBackground: 1807 GetColor (colormode, &Scr->IconC.back, s); 1808 return &Scr->IconBackgroundL; 1809 1810 case kwcl_IconBorderColor: 1811 GetColor (colormode, &Scr->IconBorderColor, s); 1812 return &Scr->IconBorderColorL; 1813 1814 case kwcl_IconManagerForeground: 1815 GetColor (colormode, &Scr->IconManagerC.fore, s); 1816 return &Scr->IconManagerFL; 1817 1818 case kwcl_IconManagerBackground: 1819 GetColor (colormode, &Scr->IconManagerC.back, s); 1820 return &Scr->IconManagerBL; 1821 1822 case kwcl_MapWindowBackground: 1823 GetColor (colormode, &Scr->workSpaceMgr.windowcp.back, s); 1824 Scr->workSpaceMgr.windowcpgiven = True; 1825 return &Scr->workSpaceMgr.windowBackgroundL; 1826 1827 case kwcl_MapWindowForeground: 1828 GetColor (colormode, &Scr->workSpaceMgr.windowcp.fore, s); 1829 Scr->workSpaceMgr.windowcpgiven = True; 1830 return &Scr->workSpaceMgr.windowForegroundL; 1831 } 1832 return NULL; 1833} 1834 1835int do_color_keyword (int keyword, int colormode, char *s) 1836{ 1837 switch (keyword) { 1838 case kwc_DefaultForeground: 1839 GetColor (colormode, &Scr->DefaultC.fore, s); 1840 return 1; 1841 1842 case kwc_DefaultBackground: 1843 GetColor (colormode, &Scr->DefaultC.back, s); 1844 return 1; 1845 1846 case kwc_MenuForeground: 1847 GetColor (colormode, &Scr->MenuC.fore, s); 1848 return 1; 1849 1850 case kwc_MenuBackground: 1851 GetColor (colormode, &Scr->MenuC.back, s); 1852 return 1; 1853 1854 case kwc_MenuTitleForeground: 1855 GetColor (colormode, &Scr->MenuTitleC.fore, s); 1856 return 1; 1857 1858 case kwc_MenuTitleBackground: 1859 GetColor (colormode, &Scr->MenuTitleC.back, s); 1860 return 1; 1861 1862 case kwc_MenuShadowColor: 1863 GetColor (colormode, &Scr->MenuShadowColor, s); 1864 return 1; 1865 1866 } 1867 1868 return 0; 1869} 1870 1871/* 1872 * put_pixel_on_root() Save a pixel value in twm root window color property. 1873 */ 1874static void put_pixel_on_root(Pixel pixel) 1875{ 1876 int i, addPixel = 1; 1877 Atom retAtom; 1878 int retFormat; 1879 unsigned long nPixels, retAfter; 1880 Pixel *retProp; 1881 1882 if (XGetWindowProperty(dpy, Scr->Root, _XA_MIT_PRIORITY_COLORS, 0, 8192, 1883 False, XA_CARDINAL, &retAtom, 1884 &retFormat, &nPixels, &retAfter, 1885 (unsigned char **)&retProp) != Success || !retProp) 1886 return; 1887 1888 for (i=0; i< nPixels; i++) 1889 if (pixel == retProp[i]) addPixel = 0; 1890 1891 XFree((char *)retProp); 1892 1893 if (addPixel) 1894 XChangeProperty (dpy, Scr->Root, _XA_MIT_PRIORITY_COLORS, 1895 XA_CARDINAL, 32, PropModeAppend, 1896 (unsigned char *)&pixel, 1); 1897} 1898 1899/* 1900 * do_string_savecolor() save a color from a string in the twmrc file. 1901 */ 1902int do_string_savecolor(int colormode, char *s) 1903{ 1904 Pixel p; 1905 GetColor(colormode, &p, s); 1906 put_pixel_on_root(p); 1907 return 0; 1908} 1909 1910/* 1911 * do_var_savecolor() save a color from a var in the twmrc file. 1912 */ 1913typedef struct _cnode {int i; struct _cnode *next;} Cnode, *Cptr; 1914Cptr chead = NULL; 1915 1916int do_var_savecolor(int key) 1917{ 1918 Cptr cptrav, cpnew; 1919 if (!chead) { 1920 chead = (Cptr)malloc(sizeof(Cnode)); 1921 chead->i = key; chead->next = NULL; 1922 } 1923 else { 1924 cptrav = chead; 1925 while (cptrav->next != NULL) { cptrav = cptrav->next; } 1926 cpnew = (Cptr)malloc(sizeof(Cnode)); 1927 cpnew->i = key; cpnew->next = NULL; cptrav->next = cpnew; 1928 } 1929 return 0; 1930} 1931 1932/* 1933 * assign_var_savecolor() traverse the var save color list placeing the pixels 1934 * in the root window property. 1935 */ 1936void assign_var_savecolor(void) 1937{ 1938 Cptr cp = chead; 1939 while (cp != NULL) { 1940 switch (cp->i) { 1941 case kwcl_BorderColor: 1942 put_pixel_on_root(Scr->BorderColorC.back); 1943 break; 1944 case kwcl_IconManagerHighlight: 1945 put_pixel_on_root(Scr->IconManagerHighlight); 1946 break; 1947 case kwcl_BorderTileForeground: 1948 put_pixel_on_root(Scr->BorderTileC.fore); 1949 break; 1950 case kwcl_BorderTileBackground: 1951 put_pixel_on_root(Scr->BorderTileC.back); 1952 break; 1953 case kwcl_TitleForeground: 1954 put_pixel_on_root(Scr->TitleC.fore); 1955 break; 1956 case kwcl_TitleBackground: 1957 put_pixel_on_root(Scr->TitleC.back); 1958 break; 1959 case kwcl_IconForeground: 1960 put_pixel_on_root(Scr->IconC.fore); 1961 break; 1962 case kwcl_IconBackground: 1963 put_pixel_on_root(Scr->IconC.back); 1964 break; 1965 case kwcl_IconBorderColor: 1966 put_pixel_on_root(Scr->IconBorderColor); 1967 break; 1968 case kwcl_IconManagerForeground: 1969 put_pixel_on_root(Scr->IconManagerC.fore); 1970 break; 1971 case kwcl_IconManagerBackground: 1972 put_pixel_on_root(Scr->IconManagerC.back); 1973 break; 1974 case kwcl_MapWindowForeground: 1975 put_pixel_on_root(Scr->workSpaceMgr.windowcp.fore); 1976 break; 1977 case kwcl_MapWindowBackground: 1978 put_pixel_on_root(Scr->workSpaceMgr.windowcp.back); 1979 break; 1980 } 1981 cp = cp->next; 1982 } 1983 if (chead) { 1984 free(chead); 1985 chead = NULL; 1986 } 1987} 1988 1989static int ParseRandomPlacement (register char *s) 1990{ 1991 if (strlen (s) == 0) return RP_ALL; 1992 if (strcmp (s, "default") == 0) return RP_ALL; 1993 XmuCopyISOLatin1Lowered (s, s); 1994 1995 if (strcmp (s, "off") == 0) return RP_OFF; 1996 if (strcmp (s, "on") == 0) return RP_ALL; 1997 if (strcmp (s, "all") == 0) return RP_ALL; 1998 if (strcmp (s, "unmapped") == 0) return RP_UNMAPPED; 1999 return (-1); 2000} 2001 2002int ParseJustification (register char *s) 2003{ 2004 if (strlen (s) == 0) return (-1); 2005 if (strcmp (s, "default") == 0) return J_CENTER; 2006 if (strcmp (s, "undef") == 0) return J_UNDEF; 2007 XmuCopyISOLatin1Lowered (s, s); 2008 2009 if (strcmp (s, "undef") == 0) return J_UNDEF; 2010 if (strcmp (s, "default") == 0) return J_CENTER; 2011 if (strcmp (s, "left") == 0) return J_LEFT; 2012 if (strcmp (s, "center") == 0) return J_CENTER; 2013 if (strcmp (s, "right") == 0) return J_RIGHT; 2014 if (strcmp (s, "border") == 0) return J_BORDER; 2015 return (-1); 2016} 2017 2018int ParseAlignement (register char *s) 2019{ 2020 if (strlen (s) == 0) return (-1); 2021 if (strcmp (s, "default") == 0) return J_CENTER; 2022 if (strcmp (s, "undef") == 0) return J_UNDEF; 2023 XmuCopyISOLatin1Lowered (s, s); 2024 2025 if (strcmp (s, "undef") == 0) return J_UNDEF; 2026 if (strcmp (s, "default") == 0) return J_CENTER; 2027 if (strcmp (s, "top") == 0) return J_TOP; 2028 if (strcmp (s, "center") == 0) return J_CENTER; 2029 if (strcmp (s, "bottom") == 0) return J_BOTTOM; 2030 if (strcmp (s, "border") == 0) return J_BORDER; 2031 return (-1); 2032} 2033 2034static int ParseUsePPosition (register char *s) 2035{ 2036 if (strlen (s) == 0) return (-1); 2037 if (strcmp (s, "default") == 0) return PPOS_OFF; 2038 XmuCopyISOLatin1Lowered (s, s); 2039 2040 if (strcmp (s, "default") == 0) return PPOS_OFF; 2041 if (strcmp (s, "off") == 0) return PPOS_OFF; 2042 if (strcmp (s, "on") == 0) return PPOS_ON; 2043 if (strcmp (s, "non-zero") == 0) return PPOS_NON_ZERO; 2044 if (strcmp (s, "nonzero") == 0) return PPOS_NON_ZERO; 2045 return (-1); 2046} 2047 2048static int ParseButtonStyle (register char *s) 2049{ 2050 if (strlen (s) == 0) return (-1); 2051 if (strcmp (s, "default") == 0) return STYLE_NORMAL; 2052 XmuCopyISOLatin1Lowered (s, s); 2053 2054 if (strcmp (s, "normal") == 0) return STYLE_NORMAL; 2055 if (strcmp (s, "style1") == 0) return STYLE_STYLE1; 2056 if (strcmp (s, "style2") == 0) return STYLE_STYLE2; 2057 if (strcmp (s, "style3") == 0) return STYLE_STYLE3; 2058 return (-1); 2059} 2060 2061int do_squeeze_entry (name_list **list, /* squeeze or dont-squeeze list */ 2062 char *name, /* window name */ 2063 int justify, /* left, center, right */ 2064 int num, /* signed num */ 2065 int denom) /* 0 or indicates fraction denom */ 2066{ 2067 int absnum = (num < 0 ? -num : num); 2068 2069 if (denom < 0) { 2070 twmrc_error_prefix(); 2071 fprintf (stderr, "negative SqueezeTitle denominator %d\n", denom); 2072 return (1); 2073 } 2074 if (absnum > denom && denom != 0) { 2075 twmrc_error_prefix(); 2076 fprintf (stderr, "SqueezeTitle fraction %d/%d outside window\n", 2077 num, denom); 2078 return (1); 2079 } 2080 /* Process the special cases from the manual here rather than 2081 * each time we calculate the position of the title bar 2082 * in add_window.c:ComputeTitleLocation(). 2083 * In fact, it's better to get rid of them entirely, but we 2084 * probably should not do that for compatibility's sake. 2085 * By using a non-zero denominator the position will be relative. 2086 */ 2087 if (denom == 0 && num == 0) { 2088 if (justify == J_CENTER) { 2089 num = 1; 2090 denom = 2; 2091 } else if (justify == J_RIGHT) { 2092 num = 2; 2093 denom = 2; 2094 } 2095 twmrc_error_prefix(); 2096 fprintf (stderr, "deprecated SqueezeTitle faction 0/0, assuming %d/%d\n", 2097 num, denom); 2098 } 2099 2100 if (HasShape) { 2101 SqueezeInfo *sinfo; 2102 sinfo = (SqueezeInfo *) malloc (sizeof(SqueezeInfo)); 2103 2104 if (!sinfo) { 2105 twmrc_error_prefix(); 2106 fprintf (stderr, "unable to allocate %lu bytes for squeeze info\n", 2107 (unsigned long) sizeof(SqueezeInfo)); 2108 return (1); 2109 } 2110 sinfo->justify = justify; 2111 sinfo->num = num; 2112 sinfo->denom = denom; 2113 AddToList (list, name, (char *) sinfo); 2114 } 2115 return (0); 2116} 2117 2118#ifdef USEM4 2119 2120static FILE *start_m4(FILE *fraw) 2121{ 2122 int fno; 2123 int fids[2]; 2124 int fres; /* Fork result */ 2125 2126 fno = fileno(fraw); 2127 /* if (-1 == fcntl(fno, F_SETFD, 0)) perror("fcntl()"); */ 2128 if (pipe(fids) < 0) { 2129 perror("Pipe for " M4CMD " failed"); 2130 exit(23); 2131 } 2132 fres = fork(); 2133 if (fres < 0) { 2134 perror("Fork for " M4CMD " failed"); 2135 exit(23); 2136 } 2137 if (fres == 0) { 2138 char *tmp_file; 2139 2140 /* Child */ 2141 close(0); /* stdin */ 2142 close(1); /* stdout */ 2143 dup2(fno, 0); /* stdin = fraw */ 2144 dup2(fids[1], 1); /* stdout = pipe to parent */ 2145 /* get_defs("m4", dpy, display_name) */ 2146 tmp_file = m4_defs(dpy, display_name); 2147 execlp(M4CMD, M4CMD, "-s", tmp_file, "-", NULL); 2148 2149 /* If we get here we are screwed... */ 2150 perror("Can't execlp() " M4CMD); 2151 exit(124); 2152 } 2153 /* Parent */ 2154 close(fids[1]); 2155 return ((FILE*)fdopen(fids[0], "r")); 2156} 2157 2158/* Code taken and munged from xrdb.c */ 2159#define MAXHOSTNAME 255 2160#define Resolution(pixels, mm) ((((pixels) * 100000 / (mm)) + 50) / 100) 2161#define EXTRA 16 2162 2163static char *MkDef(char *name, char *def) 2164{ 2165 static char *cp = NULL; 2166 static int maxsize = 0; 2167 int n, nl; 2168 2169 if (def == NULL) return (""); /* XXX JWS: prevent segfaults */ 2170 /* The char * storage only lasts for 1 call... */ 2171 if ((n = EXTRA + ((nl = strlen(name)) + strlen(def))) > maxsize) { 2172 maxsize = n; 2173 if (cp) free(cp); 2174 2175 cp = malloc(n); 2176 } 2177 /* Otherwise cp is aready big 'nuf */ 2178 if (cp == NULL) { 2179 fprintf(stderr, "Can't get %d bytes for arg parm\n", n); 2180 exit(468); 2181 } 2182 strcpy (cp, "define(`"); 2183 strcat (cp, name); 2184 strcat (cp, "', `"); 2185 strcat (cp, def); 2186 strcat (cp, "')\n"); 2187 2188 return(cp); 2189} 2190 2191static char *MkNum(char *name, int def) 2192{ 2193 char num[20]; 2194 2195 sprintf(num, "%d", def); 2196 return(MkDef(name, num)); 2197} 2198 2199#ifdef NOSTEMP 2200int mkstemp(str) 2201char *str; 2202{ 2203 int fd; 2204 2205 mktemp(str); 2206 fd = creat(str, 0744); 2207 if (fd == -1) perror("mkstemp's creat"); 2208 return(fd); 2209} 2210#endif 2211 2212static char *m4_defs(Display *display, char *host) 2213{ 2214 Screen *screen; 2215 Visual *visual; 2216 char client[MAXHOSTNAME], server[MAXHOSTNAME], *colon; 2217 struct hostent *hostname; 2218 char *vc; /* Visual Class */ 2219 static char tmp_name[] = "/tmp/twmrcXXXXXX"; 2220 int fd; 2221 FILE *tmpf; 2222 char *user; 2223 2224 fd = mkstemp(tmp_name); /* I *hope* mkstemp exists, because */ 2225 /* I tried to find the "portable" */ 2226 /* mktmp... */ 2227 if (fd < 0) { 2228 perror("mkstemp failed in m4_defs"); 2229 exit(377); 2230 } 2231 tmpf = (FILE*) fdopen(fd, "w+"); 2232 XmuGetHostname(client, MAXHOSTNAME); 2233 hostname = gethostbyname(client); 2234 strcpy(server, XDisplayName(host)); 2235 colon = strchr(server, ':'); 2236 if (colon != NULL) *colon = '\0'; 2237 if ((server[0] == '\0') || (!strcmp(server, "unix"))) 2238 strcpy(server, client); /* must be connected to :0 or unix:0 */ 2239 /* The machine running the X server */ 2240 fputs(MkDef("SERVERHOST", server), tmpf); 2241 /* The machine running the window manager process */ 2242 fputs(MkDef("CLIENTHOST", client), tmpf); 2243 if (hostname) 2244 fputs(MkDef("HOSTNAME", hostname->h_name), tmpf); 2245 else 2246 fputs(MkDef("HOSTNAME", client), tmpf); 2247 2248 if (!(user=getenv("USER")) && !(user=getenv("LOGNAME"))) user = "unknown"; 2249 fputs(MkDef("USER", user), tmpf); 2250 fputs(MkDef("HOME", getenv("HOME")), tmpf); 2251 fputs(MkDef("PIXMAP_DIRECTORY", PIXMAP_DIRECTORY), tmpf); 2252 fputs(MkNum("VERSION", ProtocolVersion(display)), tmpf); 2253 fputs(MkNum("REVISION", ProtocolRevision(display)), tmpf); 2254 fputs(MkDef("VENDOR", ServerVendor(display)), tmpf); 2255 fputs(MkNum("RELEASE", VendorRelease(display)), tmpf); 2256 screen = ScreenOfDisplay(display, Scr->screen); 2257 visual = DefaultVisualOfScreen(screen); 2258 fputs(MkNum("WIDTH", screen->width), tmpf); 2259 fputs(MkNum("HEIGHT", screen->height), tmpf); 2260 fputs(MkNum("X_RESOLUTION",Resolution(screen->width,screen->mwidth)), tmpf); 2261 fputs(MkNum("Y_RESOLUTION",Resolution(screen->height,screen->mheight)),tmpf); 2262 fputs(MkNum("PLANES",DisplayPlanes(display, Scr->screen)), tmpf); 2263 fputs(MkNum("BITS_PER_RGB", visual->bits_per_rgb), tmpf); 2264 fputs(MkDef("TWM_TYPE", "ctwm"), tmpf); 2265 fputs(MkDef("TWM_VERSION", VersionNumber), tmpf); 2266 switch(visual->class) { 2267 case(StaticGray): vc = "StaticGray"; break; 2268 case(GrayScale): vc = "GrayScale"; break; 2269 case(StaticColor): vc = "StaticColor"; break; 2270 case(PseudoColor): vc = "PseudoColor"; break; 2271 case(TrueColor): vc = "TrueColor"; break; 2272 case(DirectColor): vc = "DirectColor"; break; 2273 default: vc = "NonStandard"; break; 2274 } 2275 fputs(MkDef("CLASS", vc), tmpf); 2276 if (visual->class != StaticGray && visual->class != GrayScale) { 2277 fputs(MkDef("COLOR", "Yes"), tmpf); 2278 } else { 2279 fputs(MkDef("COLOR", "No"), tmpf); 2280 } 2281#ifdef XPM 2282 fputs(MkDef("XPM", "Yes"), tmpf); 2283#endif 2284#ifdef JPEG 2285 fputs(MkDef("JPEG", "Yes"), tmpf); 2286#endif 2287#ifdef IMCONV 2288 fputs(MkDef("IMCONV", "Yes"), tmpf); 2289#endif 2290#ifdef GNOME 2291 fputs(MkDef("GNOME", "Yes"), tmpf); 2292#endif 2293#ifdef SOUNDS 2294 fputs(MkDef("SOUNDS", "Yes"), tmpf); 2295#endif 2296 fputs(MkDef("I18N", "Yes"), tmpf); 2297 if (captive && captivename) { 2298 fputs (MkDef ("TWM_CAPTIVE", "Yes"), tmpf); 2299 fputs (MkDef ("TWM_CAPTIVE_NAME", captivename), tmpf); 2300 } else { 2301 fputs (MkDef ("TWM_CAPTIVE", "No"), tmpf); 2302 } 2303 if (KeepTmpFile) { 2304 fprintf(stderr, "Left file: %s\n", tmp_name); 2305 } else { 2306 fprintf(tmpf, "syscmd(/bin/rm %s)\n", tmp_name); 2307 } 2308 fclose(tmpf); 2309 return(tmp_name); 2310} 2311#endif /* USEM4 */ 2312