2 * CDE - Common Desktop Environment
4 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
6 * These libraries and programs are free software; you can
7 * redistribute them and/or modify them under the terms of the GNU
8 * Lesser General Public License as published by the Free Software
9 * Foundation; either version 2 of the License, or (at your option)
12 * These libraries and programs are distributed in the hope that
13 * they will be useful, but WITHOUT ANY WARRANTY; without even the
14 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU Lesser General Public License for more
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with these libraries and programs; if not, write
20 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
21 * Floor, Boston, MA 02110-1301 USA
23 /* $XConsortium: resource.c /main/4 1996/06/19 09:47:56 mustafa $ */
27 * (c) Copyright 1993, 1994 Hewlett-Packard Company *
28 * (c) Copyright 1993, 1994 International Business Machines Corp. *
29 * (c) Copyright 1993, 1994 Sun Microsystems, Inc. *
30 * (c) Copyright 1993, 1994 Novell, Inc. *
33 * resource.c - resource management for dtscreen, the X Window System lockscreen.
35 * Copyright (c) 1991 by Patrick J. Naughton.
37 * See dtscreen.c for copying information.
40 * 25-Sep-91: added worm mode.
41 * 06-Jun-91: Added flame mode.
42 * 16-May-91: Added random mode and pyro mode.
43 * 26-Mar-91: CheckResources: delay must be >= 0.
44 * 29-Oct-90: Added #include <ctype.h> for missing isupper() on some OS revs.
45 * moved -mode option, reordered Xrm database evaluation.
46 * 28-Oct-90: Added text strings.
47 * 26-Oct-90: Fix bug in mode specific options.
48 * 31-Jul-90: Fix ':' handling in parsefilepath
49 * 07-Jul-90: Created from resource work in dtscreen.c
60 #include <X11/Xresource.h>
62 /* include file for message texts */
65 #define MF_DTSCREEN "dtscreen.cat"
68 extern nl_catd scmc_catd; /* Cat descriptor for scmc conversion */
71 * Declare external interface routines for supported screen savers.
74 extern void inithop();
75 extern void drawhop();
77 extern void initlife();
78 extern void drawlife();
80 extern void initqix();
81 extern void drawqix();
83 extern void initimage();
84 extern void drawimage();
86 extern void initblank();
87 extern void drawblank();
89 extern void initswarm();
90 extern void drawswarm();
92 extern void initrotor();
93 extern void drawrotor();
95 extern void initpyro();
96 extern void drawpyro();
98 extern void initflame();
99 extern void drawflame();
101 extern void initworm();
102 extern void drawworm();
104 void CheckResources(void);
109 void (*lp_callback) ();
112 float def_saturation;
116 static char randomstring[] = "random";
118 static LockStruct LockProcs[] = {
119 {"hop", inithop, drawhop, 0, 1000, 1.0, "Hopalong iterated fractals"},
120 {"qix", initqix, drawqix, 30000, 64, 1.0, "Spinning lines a la Qix(tm)"},
121 {"image", initimage, drawimage, 2000000, 8, 0.3, "Random bouncing image"},
122 {"life", initlife, drawlife, 1000000, 100, 1.0, "Conway's game of Life"},
123 {"swarm", initswarm, drawswarm, 10000, 100, 1.0, "Swarm of bees"},
124 {"rotor", initrotor, drawrotor, 10000, 4, 0.4, "Rotor"},
125 {"pyro", initpyro, drawpyro, 15000, 40, 1.0, "Fireworks"},
126 {"flame", initflame, drawflame, 10000, 20, 1.0, "Cosmic Flame Fractals"},
127 {"worm", initworm, drawworm, 10000, 20, 1.0, "Wiggly Worms"},
128 {"blank", initblank, drawblank, 5000000, 1, 1.0, "Blank screen"},
129 {randomstring, NULL, NULL, 0, 0, 0.0, "Random mode"},
131 #define NUMPROCS (sizeof LockProcs / sizeof LockProcs[0])
134 extern char *getenv();
136 #ifndef DEF_FILESEARCHPATH
137 #define DEF_FILESEARCHPATH "/usr/lib/X11/%T/%N%S"
139 #define DEF_DISPLAY ":0"
140 #define DEF_MODE "swarm"
141 #define DEF_BG "White"
142 #define DEF_FG "Black"
143 #define DEF_BC "100" /* vectors (or whatever) per batch */
144 #define DEF_DELAY "200000"/* microseconds between batches */
145 #define DEF_NICE "10" /* dtscreen process nicelevel */
146 #define DEF_SAT "1.0" /* color ramp saturation 0->1 */
147 #define DEF_CLASSNAME "Dtscreen"
149 static char *classname;
150 static char modename[1024];
151 static char modeclass[1024];
153 static XrmOptionDescRec genTable[] = {
154 {"-mode", ".mode", XrmoptionSepArg, (caddr_t) NULL},
155 {"-mono", ".mono", XrmoptionNoArg, (caddr_t) "on"},
156 {"+mono", ".mono", XrmoptionNoArg, (caddr_t) "off"},
157 {"-nice", ".nice", XrmoptionSepArg, (caddr_t) NULL},
158 {"-create", ".create", XrmoptionNoArg, (caddr_t) "on"},
160 #define genEntries (sizeof genTable / sizeof genTable[0])
162 /*************************************************************/
163 /** This table was changed for AIX. In order to read these **/
164 /** command line options properly, the specifier field must **/
165 /** be built on the fly. **/
166 /*************************************************************/
167 static XrmOptionDescRec modeTable[] = {
168 {"-delay", NULL, XrmoptionSepArg, (caddr_t) NULL},
169 {"-batchcount", NULL, XrmoptionSepArg, (caddr_t) NULL},
170 {"-saturation", NULL, XrmoptionSepArg, (caddr_t) NULL},
172 #define modeEntries (sizeof modeTable / sizeof modeTable[0])
174 static XrmOptionDescRec cmdlineTable[] = {
175 {"-display", ".display", XrmoptionSepArg, (caddr_t) NULL},
176 {"-xrm", NULL, XrmoptionResArg, (caddr_t) NULL},
178 #define cmdlineEntries (sizeof cmdlineTable / sizeof cmdlineTable[0])
180 static XrmOptionDescRec nameTable[] = {
181 {"-name", ".name", XrmoptionSepArg, (caddr_t) NULL},
190 static OptionStruct opDesc[] = {
191 {"-help", "print out this message"},
192 {"-resources", "print default resource file to standard output"},
193 {"-display displayname", "X server to contact"},
194 {"-/+mono", "turn on/off monochrome override"},
195 {"-delay usecs", "microsecond delay between screen updates"},
196 {"-batchcount num", "number of things per batch"},
197 {"-nice level", "nice level for dtscreen process"},
198 {"-saturation value", "saturation of color ramp"},
199 {"-create", "create a window in which to draw"},
201 #define opDescEntries (sizeof opDesc / sizeof opDesc[0])
226 static argtype genvars[] = {
227 {(caddr_t *) &nicelevel, "nice", "Nice", DEF_NICE, t_Int},
228 {(caddr_t *) &mono, "mono", "Mono", "off", t_Bool},
229 {(caddr_t *) &create, "create", "Create", "off", t_Bool},
231 #define NGENARGS (sizeof genvars / sizeof genvars[0])
233 static argtype modevars[] = {
234 {(caddr_t *) &delay, "delay", "Delay", DEF_DELAY, t_Int},
235 {(caddr_t *) &batchcount, "batchcount", "BatchCount", DEF_BC, t_Int},
236 {(caddr_t *) &saturation, "saturation", "Saturation", DEF_SAT, t_Float},
238 #define NMODEARGS (sizeof modevars / sizeof modevars[0])
242 Syntax(char *badOption)
247 fprintf(stderr, "%s: bad command line option: %s.\n\n",
248 ProgramName, badOption);
250 fprintf(stderr, catgets(scmc_catd, 2, 1,
251 "%s: Bad command line option: %s.\n\n"),
252 ProgramName, badOption);
255 fprintf(stderr, "usage: %s", ProgramName);
256 col = 8 + strlen(ProgramName);
257 for (i = 0; i < opDescEntries; i++) {
258 len = 3 + strlen(opDesc[i].opt); /* space [ string ] */
259 if (col + len > 79) {
260 fprintf(stderr, "\n "); /* 3 spaces */
263 fprintf(stderr, " [%s]", opDesc[i].opt);
267 len = 8 + strlen(LockProcs[0].cmdline_arg);
268 if (col + len > 79) {
269 fprintf(stderr, "\n "); /* 3 spaces */
272 fprintf(stderr, " [-mode %s", LockProcs[0].cmdline_arg);
274 for (i = 1; i < NUMPROCS; i++) {
275 len = 3 + strlen(LockProcs[i].cmdline_arg);
276 if (col + len > 79) {
277 fprintf(stderr, "\n "); /* 3 spaces */
280 fprintf(stderr, " | %s", LockProcs[i].cmdline_arg);
283 fprintf(stderr, "]\n");
286 fprintf(stderr, "\nType %s -help for a full description.\n\n",
289 fprintf(stderr, catgets(scmc_catd, 2, 2,
290 "\nType %s -help for a full description.\n\n"),
302 fprintf(stderr, "usage:\n %s [-options ...]\n\n", ProgramName);
303 fprintf(stderr, "where options include:\n");
306 fprintf(stderr, catgets(scmc_catd, 2, 3,
307 "Usage:\n %s [-options ...]\n\n\
308 where options include:\n"), ProgramName);
311 for (i = 0; i < opDescEntries; i++) {
312 fprintf(stderr, " %-28s %s\n", opDesc[i].opt, opDesc[i].desc);
316 fprintf(stderr, " %-28s %s\n", "-mode mode", "animation mode");
317 fprintf(stderr, " where mode is one of:\n");
319 fprintf(stderr, catgets(scmc_catd, 2, 5,
320 " %-28s %s\n\t where mode is one of:\n"),
321 "-mode mode", "animation mode");
323 for (i = 0; i < NUMPROCS; i++) {
324 fprintf(stderr, " %-23s %s\n",
325 LockProcs[i].cmdline_arg, LockProcs[i].desc);
337 printf("%s.mode: %s\n", classname, DEF_MODE);
339 for (i = 0; i < NGENARGS; i++)
340 printf("%s.%s: %s\n",
341 classname, genvars[i].name, genvars[i].def);
343 for (i = 0; i < NUMPROCS - 1; i++) {
344 printf("%s.%s.%s: %d\n", classname, LockProcs[i].cmdline_arg,
345 "delay", LockProcs[i].def_delay);
346 printf("%s.%s.%s: %d\n", classname, LockProcs[i].cmdline_arg,
347 "batchcount", LockProcs[i].def_batchcount);
348 printf("%s.%s.%s: %g\n", classname, LockProcs[i].cmdline_arg,
349 "saturation", LockProcs[i].def_saturation);
367 GetResource(XrmDatabase database, char *parentname, char *parentclass,
368 char *name, char *class, int valueType, char *def,
369 caddr_t *valuep /* RETURN */)
376 char fullclass[1024];
379 sprintf(fullname, "%s.%s", parentname, name);
380 sprintf(fullclass, "%s.%s", parentclass, class);
381 if (XrmGetResource(database, fullname, fullclass, &type, &value)) {
386 len = strlen(string);
388 (void) strncpy(buffer, string, sizeof(buffer));
389 buffer[sizeof(buffer) - 1] = '\0';
395 s = (char *) malloc(len + 1);
396 if (s == (char *) NULL)
398 error("%s: GetResource - couldn't allocate memory");
401 fprintf(stderr, catgets(scmc_catd, 2, 18,
402 "%s: GetResource - couldn't allocate memory.\n"),ProgramName);
406 (void) strncpy(s, string, len);
408 *((char **) valuep) = s;
413 *((int *) valuep) = (!strcmp(buffer, "true") ||
414 !strcmp(buffer, "on") ||
415 !strcmp(buffer, "enabled") ||
416 !strcmp(buffer, "yes")) ? True : False;
419 *((int *) valuep) = atoi(buffer);
422 *((float *) valuep) = (float) atof(buffer);
429 parsefilepath(char *xfilesearchpath, char *TypeName, char *ClassName)
431 XrmDatabase database = NULL;
432 char appdefaults[1024];
436 src = xfilesearchpath;
437 appdefaults[0] = '\0';
449 (void) strcat(dst, TypeName);
451 dst += strlen(TypeName);
454 (void) strcat(dst, ClassName);
456 dst += strlen(ClassName);
465 } else if (*src == ':') {
466 database = XrmGetFileDatabase(appdefaults);
467 if (database == NULL) {
472 } else if (*src == '\0') {
473 database = XrmGetFileDatabase(appdefaults);
483 /*******************************************************************/
484 /** screenIOErrorHandler **/
486 /** this function will exit cleanly when the connection is broken **/
487 /*******************************************************************/
488 static int screenIOErrorHandler(Display *dpy)
497 if (display != NULL) {
498 char *colon = strchr(display, ':');
502 error("%s: Malformed -display argument, \"%s\"\n", display);
505 fprintf(stderr, catgets(scmc_catd, 2, 19,
506 "%s: Malformed -display argument: %s.\n"), ProgramName,display);
513 if (!(dsp = XOpenDisplay(display)))
515 error("%s: unable to open display %s.\n", display);
518 fprintf(stderr, catgets(scmc_catd, 2, 17,
519 "%s: Unable to open display %s.\n"),ProgramName, display);
524 XSetIOErrorHandler(screenIOErrorHandler);
528 printvar(char *class, argtype var)
532 fprintf(stderr, "%s.%s: %s\n",
533 class, var.name, *((char **) var.var));
536 fprintf(stderr, "%s.%s: %s\n",
537 class, var.name, *((int *) var.var)
541 fprintf(stderr, "%s.%s: %d\n",
542 class, var.name, *((int *) var.var));
545 fprintf(stderr, "%s.%s: %g\n",
546 class, var.name, *((float *) var.var));
553 GetResources(int argc, char *argv[])
555 XrmDatabase RDB = NULL;
556 XrmDatabase modeDB = NULL;
557 XrmDatabase nameDB = NULL;
558 XrmDatabase cmdlineDB = NULL;
559 XrmDatabase generalDB = NULL;
560 XrmDatabase homeDB = NULL;
561 XrmDatabase applicationDB = NULL;
562 XrmDatabase serverDB = NULL;
563 XrmDatabase userDB = NULL;
570 /***************************/
571 /** new variables for AIX **/
572 /***************************/
573 char delaySpecifier[64];
574 char batchcountSpecifier[64];
575 char saturationSpecifier[64];
579 for (i = 0; i < argc; i++) {
580 if (!strncmp(argv[i], "-help", strlen(argv[i])))
586 * get -name arg from command line so you can have different resource
587 * files for different configurations/machines etc...
589 XrmParseCommand(&nameDB, nameTable, 1, ProgramName,
591 GetResource(nameDB, ProgramName, "*", "name", "Name", t_String,
592 DEF_CLASSNAME, &classname);
594 homeenv = getenv("HOME");
598 env = getenv("XFILESEARCHPATH");
599 applicationDB = parsefilepath(env ? env : DEF_FILESEARCHPATH,
600 "app-defaults", classname);
602 XrmParseCommand(&cmdlineDB, cmdlineTable, cmdlineEntries, ProgramName,
605 userpath = getenv("XUSERFILESEARCHPATH");
607 env = getenv("XAPPLRESDIR");
609 snprintf(userfile, 1024 - 1, "%s/%%N:%s/%%N", env, homeenv);
611 snprintf(userfile, 1024 - 1, "%s/%%N", homeenv);
614 userDB = parsefilepath(userpath, "app-defaults", classname);
616 (void) XrmMergeDatabases(applicationDB, &RDB);
617 (void) XrmMergeDatabases(userDB, &RDB);
618 (void) XrmMergeDatabases(cmdlineDB, &RDB);
620 env = getenv("DISPLAY");
621 GetResource(RDB, ProgramName, classname, "display", "Display", t_String,
622 env ? env : DEF_DISPLAY, &display);
624 serverString = XResourceManagerString(dsp);
626 serverDB = XrmGetStringDatabase(serverString);
627 (void) XrmMergeDatabases(serverDB, &RDB);
630 sprintf(buf, "%s/.Xdefaults", homeenv);
631 homeDB = XrmGetFileDatabase(buf);
632 (void) XrmMergeDatabases(homeDB, &RDB);
635 XrmParseCommand(&generalDB, genTable, genEntries, ProgramName, &argc, argv);
636 (void) XrmMergeDatabases(generalDB, &RDB);
638 GetResource(RDB, ProgramName, classname, "mode", "Mode", t_String,
639 DEF_MODE, (caddr_t *) &mode);
642 * if random< mode, then just grab a random entry from the table
644 if (!strcmp(mode, randomstring))
645 mode = LockProcs[random() % (NUMPROCS - 2)].cmdline_arg;
647 sprintf(modename, "%s.%s", ProgramName, mode);
648 sprintf(modeclass, "%s.%s", classname, mode);
651 /*********************************************************************/
652 /** New code for AIX **/
653 /** We must build the specifier fields of the modeTable on the fly. **/
654 /*********************************************************************/
655 sprintf(delaySpecifier, ".%s.delay", mode);
656 sprintf(batchcountSpecifier, ".%s.batchcount", mode);
657 sprintf(saturationSpecifier, ".%s.saturation", mode);
658 modeTable[0].specifier = delaySpecifier;
659 modeTable[1].specifier = batchcountSpecifier;
660 modeTable[2].specifier = saturationSpecifier;
663 XrmParseCommand(&modeDB, modeTable, modeEntries, ProgramName, &argc, argv);
664 (void) XrmMergeDatabases(modeDB, &RDB);
666 /* Parse the rest of the command line */
667 for (argc--, argv++; argc > 0; argc--, argv++) {
670 switch (argv[0][1]) {
680 /* the RDB is set, now query load the variables from the database */
682 for (i = 0; i < NGENARGS; i++)
683 GetResource(RDB, ProgramName, classname,
684 genvars[i].name, genvars[i].class,
685 genvars[i].type, genvars[i].def, genvars[i].var);
687 for (i = 0; i < NMODEARGS; i++)
688 GetResource(RDB, modename, modeclass,
689 modevars[i].name, modevars[i].class,
690 modevars[i].type, modevars[i].def, modevars[i].var);
692 (void) XrmDestroyDatabase(RDB);
697 void CheckResources(void)
702 Syntax("-batchcount argument must be positive.");
703 if (saturation < 0.0 || saturation > 1.0)
704 Syntax("-saturation argument must be between 0.0 and 1.0.");
706 Syntax("-delay argument must be positive.");
708 for (i = 0; i < NUMPROCS; i++) {
709 if (!strncmp(LockProcs[i].cmdline_arg, mode, strlen(mode))) {
710 init = LockProcs[i].lp_init;
711 callback = LockProcs[i].lp_callback;
717 fprintf(stderr, "Unknown mode: ");
719 fprintf(stderr, "%s", catgets(scmc_catd, 2, 7,