http://ftp.x.org/contrib/applications/xscreensaver-3.19.tar.gz
[xscreensaver] / hacks / screenhack.c
1 /* xscreensaver, Copyright (c) 1992, 1995, 1997, 1998
2  *  Jamie Zawinski <jwz@jwz.org>
3  *
4  * Permission to use, copy, modify, distribute, and sell this software and its
5  * documentation for any purpose is hereby granted without fee, provided that
6  * the above copyright notice appear in all copies and that both that
7  * copyright notice and this permission notice appear in supporting
8  * documentation.  No representations are made about the suitability of this
9  * software for any purpose.  It is provided "as is" without express or 
10  * implied warranty.
11  *
12  * And remember: X Windows is to graphics hacking as roman numerals are to
13  * the square root of pi.
14  */
15
16 /* This file contains simple code to open a window or draw on the root.
17    The idea being that, when writing a graphics hack, you can just link
18    with this .o to get all of the uninteresting junk out of the way.
19
20    -  create a procedure `screenhack(dpy, window)'
21
22    -  create a variable `char *progclass' which names this program's
23       resource class.
24
25    -  create a variable `char defaults []' for the default resources, and
26       null-terminate it.
27
28    -  create a variable `XrmOptionDescRec options[]' for the command-line,
29       and null-terminate it.
30
31    And that's it...
32  */
33
34 #include <stdio.h>
35 #include <X11/Intrinsic.h>
36 #include <X11/IntrinsicP.h>
37 #include <X11/CoreP.h>
38 #include <X11/Shell.h>
39 #include <X11/StringDefs.h>
40 #include <X11/Xutil.h>
41 #include <X11/keysym.h>
42
43 #ifdef __sgi
44 # include <X11/SGIScheme.h>     /* for SgiUseSchemes() */
45 #endif /* __sgi */
46
47 #ifdef HAVE_XMU
48 # ifndef VMS
49 #  include <X11/Xmu/Error.h>
50 # else /* VMS */
51 #  include <Xmu/Error.h>
52 # endif
53 #else
54 # include "xmu.h"
55 #endif
56 #include "screenhack.h"
57 #include "version.h"
58 #include "vroot.h"
59
60 char *progname;
61 XrmDatabase db;
62 XtAppContext app;
63 Bool mono_p;
64
65 static XrmOptionDescRec default_options [] = {
66   { "-root",    ".root",                XrmoptionNoArg, "True" },
67   { "-window",  ".root",                XrmoptionNoArg, "False" },
68   { "-mono",    ".mono",                XrmoptionNoArg, "True" },
69   { "-install", ".installColormap",     XrmoptionNoArg, "True" },
70   { "-noinstall",".installColormap",    XrmoptionNoArg, "False" },
71   { "-visual",  ".visualID",            XrmoptionSepArg, 0 },
72   { "-window-id", ".windowID",          XrmoptionSepArg, 0 },
73   { 0, 0, 0, 0 }
74 };
75
76 static char *default_defaults[] = {
77   ".root:               false",
78   "*geometry:           600x480", /* this should be .geometry, but nooooo... */
79   "*mono:               false",
80   "*installColormap:    false",
81   "*visualID:           default",
82   "*windowID:           ",
83   0
84 };
85
86 static XrmOptionDescRec *merged_options;
87 static int merged_options_size;
88 static char **merged_defaults;
89
90 static void
91 merge_options (void)
92 {
93   int def_opts_size, opts_size;
94   int def_defaults_size, defaults_size;
95
96   for (def_opts_size = 0; default_options[def_opts_size].option;
97        def_opts_size++)
98     ;
99   for (opts_size = 0; options[opts_size].option; opts_size++)
100     ;
101
102   merged_options_size = def_opts_size + opts_size;
103   merged_options = (XrmOptionDescRec *)
104     malloc ((merged_options_size + 1) * sizeof(*default_options));
105   memcpy (merged_options, default_options,
106           (def_opts_size * sizeof(*default_options)));
107   memcpy (merged_options + def_opts_size, options,
108           ((opts_size + 1) * sizeof(*default_options)));
109
110   for (def_defaults_size = 0; default_defaults[def_defaults_size];
111        def_defaults_size++)
112     ;
113   for (defaults_size = 0; defaults[defaults_size]; defaults_size++)
114     ;
115   merged_defaults = (char **)
116     malloc ((def_defaults_size + defaults_size + 1) * sizeof (*defaults));;
117   memcpy (merged_defaults, default_defaults,
118           def_defaults_size * sizeof(*defaults));
119   memcpy (merged_defaults + def_defaults_size, defaults,
120           (defaults_size + 1) * sizeof(*defaults));
121
122   /* This totally sucks.  Xt should behave like this by default.
123      If the string in `defaults' looks like ".foo", change that
124      to "Progclass.foo".
125    */
126   {
127     char **s;
128     for (s = merged_defaults; *s; s++)
129       if (**s == '.')
130         {
131           const char *oldr = *s;
132           char *newr = (char *) malloc(strlen(oldr) + strlen(progclass) + 3);
133           strcpy (newr, progclass);
134           strcat (newr, oldr);
135           *s = newr;
136         }
137   }
138 }
139
140 \f
141 /* Make the X errors print out the name of this program, so we have some
142    clue which one has a bug when they die under the screensaver.
143  */
144
145 static int
146 screenhack_ehandler (Display *dpy, XErrorEvent *error)
147 {
148   fprintf (stderr, "\nX error in %s:\n", progname);
149   if (XmuPrintDefaultErrorMessage (dpy, error, stderr))
150     exit (-1);
151   else
152     fprintf (stderr, " (nonfatal.)\n");
153   return 0;
154 }
155
156 static Bool
157 MapNotify_event_p (Display *dpy, XEvent *event, XPointer window)
158 {
159   return (event->xany.type == MapNotify &&
160           event->xvisibility.window == (Window) window);
161 }
162
163
164 #ifdef XLOCKMORE
165 extern void pre_merge_options (void);
166 #endif
167
168
169 static Atom XA_WM_PROTOCOLS, XA_WM_DELETE_WINDOW;
170
171 /* Dead-trivial event handling: exits if "q" or "ESC" are typed.
172    Exit if the WM_PROTOCOLS WM_DELETE_WINDOW ClientMessage is received.
173  */
174 void
175 screenhack_handle_event (Display *dpy, XEvent *event)
176 {
177   switch (event->xany.type)
178     {
179     case KeyPress:
180       {
181         KeySym keysym;
182         char c = 0;
183         XLookupString (&event->xkey, &c, 1, &keysym, 0);
184         if (c == 'q' ||
185             c == 'Q' ||
186             c == 3 ||   /* ^C */
187             c == 27)    /* ESC */
188           exit (0);
189         else if (! (keysym >= XK_Shift_L && keysym <= XK_Hyper_R))
190           XBell (dpy, 0);  /* beep for non-chord keys */
191       }
192       break;
193     case ButtonPress:
194       XBell (dpy, 0);
195       break;
196     case ClientMessage:
197       {
198         if (event->xclient.message_type != XA_WM_PROTOCOLS)
199           {
200             char *s = XGetAtomName(dpy, event->xclient.message_type);
201             if (!s) s = "(null)";
202             fprintf (stderr, "%s: unknown ClientMessage %s received!\n",
203                      progname, s);
204           }
205         else if (event->xclient.data.l[0] != XA_WM_DELETE_WINDOW)
206           {
207             char *s1 = XGetAtomName(dpy, event->xclient.message_type);
208             char *s2 = XGetAtomName(dpy, event->xclient.data.l[0]);
209             if (!s1) s1 = "(null)";
210             if (!s2) s2 = "(null)";
211             fprintf (stderr, "%s: unknown ClientMessage %s[%s] received!\n",
212                      progname, s1, s2);
213           }
214         else
215           {
216             exit (0);
217           }
218       }
219       break;
220     }
221 }
222
223
224 void
225 screenhack_handle_events (Display *dpy)
226 {
227   while (XPending (dpy))
228     {
229       XEvent event;
230       XNextEvent (dpy, &event);
231       screenhack_handle_event (dpy, &event);
232     }
233 }
234
235
236 static Visual *
237 pick_visual (Screen *screen)
238 {
239 #ifdef USE_GL
240   /* If we're linking against GL (that is, this is the version of screenhack.o
241      that the GL hacks will use, which is different from the one that the
242      non-GL hacks will use) then try to pick the "best" visual by interrogating
243      the GL library instead of by asking Xlib.  GL knows better.
244    */
245   Visual *v = 0;
246   char *string = get_string_resource ("visualID", "VisualID");
247
248   if (!string || !*string ||
249       !strcmp (string, "gl") ||
250       !strcmp (string, "best") ||
251       !strcmp (string, "color") ||
252       !strcmp (string, "default"))
253     v = get_gl_visual (screen);         /* from ../utils/visual-gl.c */
254
255   if (string)
256     free (string);
257   if (v)
258     return v;
259 #endif /* USE_GL */
260
261   return get_visual_resource (screen, "visualID", "VisualID", False);
262 }
263
264
265 int
266 main (int argc, char **argv)
267 {
268   Widget toplevel;
269   Display *dpy;
270   Window window;
271   Visual *visual;
272   Colormap cmap;
273   Bool root_p;
274   Window on_window = 0;
275   XEvent event;
276   Boolean dont_clear /*, dont_map */;
277   char version[255];
278
279 #ifdef XLOCKMORE
280   pre_merge_options ();
281 #endif
282   merge_options ();
283
284 #ifdef __sgi
285   /* We have to do this on SGI to prevent the background color from being
286      overridden by the current desktop color scheme (we'd like our backgrounds
287      to be black, thanks.)  This should be the same as setting the
288      "*useSchemes: none" resource, but it's not -- if that resource is
289      present in the `default_defaults' above, it doesn't work, though it
290      does work when passed as an -xrm arg on the command line.  So screw it,
291      turn them off from C instead.
292    */
293   SgiUseSchemes ("none"); 
294 #endif /* __sgi */
295
296   toplevel = XtAppInitialize (&app, progclass, merged_options,
297                               merged_options_size, &argc, argv,
298                               merged_defaults, 0, 0);
299   dpy = XtDisplay (toplevel);
300   db = XtDatabase (dpy);
301   XtGetApplicationNameAndClass (dpy, &progname, &progclass);
302
303   /* half-assed way of avoiding buffer-overrun attacks. */
304   if (strlen (progname) >= 100) progname[100] = 0;
305
306   XSetErrorHandler (screenhack_ehandler);
307
308   XA_WM_PROTOCOLS = XInternAtom (dpy, "WM_PROTOCOLS", False);
309   XA_WM_DELETE_WINDOW = XInternAtom (dpy, "WM_DELETE_WINDOW", False);
310
311   {
312     char *v = (char *) strdup(strchr(screensaver_id, ' '));
313     char *s1, *s2, *s3, *s4;
314     s1 = (char *) strchr(v,  ' '); s1++;
315     s2 = (char *) strchr(s1, ' ');
316     s3 = (char *) strchr(v,  '('); s3++;
317     s4 = (char *) strchr(s3, ')');
318     *s2 = 0;
319     *s4 = 0;
320     sprintf (version, "%s: from the XScreenSaver %s distribution (%s.)",
321              progclass, s1, s3);
322     free(v);
323   }
324
325   if (argc > 1)
326     {
327       const char *s;
328       int i;
329       int x = 18;
330       int end = 78;
331       Bool help_p = !strcmp(argv[1], "-help");
332       fprintf (stderr, "%s\n", version);
333       for (s = progclass; *s; s++) fprintf(stderr, " ");
334       fprintf (stderr, "  http://www.jwz.org/xscreensaver/\n\n");
335
336       if (!help_p)
337         fprintf(stderr, "Unrecognised option: %s\n", argv[1]);
338       fprintf (stderr, "Options include: ");
339       for (i = 0; i < merged_options_size; i++)
340         {
341           char *sw = merged_options [i].option;
342           Bool argp = (merged_options [i].argKind == XrmoptionSepArg);
343           int size = strlen (sw) + (argp ? 6 : 0) + 2;
344           if (x + size >= end)
345             {
346               fprintf (stderr, "\n\t\t ");
347               x = 18;
348             }
349           x += size;
350           fprintf (stderr, "%s", sw);
351           if (argp) fprintf (stderr, " <arg>");
352           if (i != merged_options_size - 1) fprintf (stderr, ", ");
353         }
354       fprintf (stderr, ".\n");
355       exit (help_p ? 0 : 1);
356     }
357
358   dont_clear = get_boolean_resource ("dontClearRoot", "Boolean");
359 /*dont_map = get_boolean_resource ("dontMapWindow", "Boolean"); */
360   mono_p = get_boolean_resource ("mono", "Boolean");
361   if (CellsOfScreen (DefaultScreenOfDisplay (dpy)) <= 2)
362     mono_p = True;
363
364   root_p = get_boolean_resource ("root", "Boolean");
365
366   {
367     char *s = get_string_resource ("windowID", "WindowID");
368     if (s && *s)
369       on_window = get_integer_resource ("windowID", "WindowID");
370     if (s) free (s);
371   }
372
373   if (on_window)
374     {
375       XWindowAttributes xgwa;
376       window = (Window) on_window;
377       XtDestroyWidget (toplevel);
378       XGetWindowAttributes (dpy, window, &xgwa);
379       cmap = xgwa.colormap;
380       visual = xgwa.visual;
381     }
382   else if (root_p)
383     {
384       XWindowAttributes xgwa;
385       window = RootWindowOfScreen (XtScreen (toplevel));
386       XtDestroyWidget (toplevel);
387       XGetWindowAttributes (dpy, window, &xgwa);
388       cmap = xgwa.colormap;
389       visual = xgwa.visual;
390     }
391   else
392     {
393       Boolean def_visual_p;
394       Screen *screen = XtScreen (toplevel);
395       visual = pick_visual (screen);
396
397       if (toplevel->core.width <= 0)
398         toplevel->core.width = 600;
399       if (toplevel->core.height <= 0)
400         toplevel->core.height = 480;
401
402       def_visual_p = (visual == DefaultVisualOfScreen (screen));
403
404       if (!def_visual_p)
405         {
406           unsigned int bg, bd;
407           Widget new;
408
409           cmap = XCreateColormap (dpy, RootWindowOfScreen(screen),
410                                   visual, AllocNone);
411           bg = get_pixel_resource ("background", "Background", dpy, cmap);
412           bd = get_pixel_resource ("borderColor", "Foreground", dpy, cmap);
413
414           new = XtVaAppCreateShell (progname, progclass,
415                                     topLevelShellWidgetClass, dpy,
416                                     XtNmappedWhenManaged, False,
417                                     XtNvisual, visual,
418                                     XtNdepth, visual_depth (screen, visual),
419                                     XtNwidth, toplevel->core.width,
420                                     XtNheight, toplevel->core.height,
421                                     XtNcolormap, cmap,
422                                     XtNbackground, (Pixel) bg,
423                                     XtNborderColor, (Pixel) bd,
424                                     0);
425           XtDestroyWidget (toplevel);
426           toplevel = new;
427           XtRealizeWidget (toplevel);
428           window = XtWindow (toplevel);
429         }
430       else
431         {
432           XtVaSetValues (toplevel, XtNmappedWhenManaged, False, 0);
433           XtRealizeWidget (toplevel);
434           window = XtWindow (toplevel);
435
436           if (get_boolean_resource ("installColormap", "InstallColormap"))
437             {
438               cmap = XCreateColormap (dpy, window,
439                                    DefaultVisualOfScreen (XtScreen (toplevel)),
440                                       AllocNone);
441               XSetWindowColormap (dpy, window, cmap);
442             }
443           else
444             {
445               cmap = DefaultColormap (dpy, DefaultScreen (dpy));
446             }
447         }
448
449 /*
450       if (dont_map)
451         {
452           XtVaSetValues (toplevel, XtNmappedWhenManaged, False, 0);
453           XtRealizeWidget (toplevel);
454         }
455       else
456 */
457         {
458           XtPopup (toplevel, XtGrabNone);
459         }
460
461       XtVaSetValues(toplevel, XtNtitle, version, 0);
462
463       /* For screenhack_handle_events(): select KeyPress, and
464          announce that we accept WM_DELETE_WINDOW. */
465       {
466         XWindowAttributes xgwa;
467         XGetWindowAttributes (dpy, window, &xgwa);
468         XSelectInput (dpy, window,
469                       xgwa.your_event_mask | KeyPressMask | ButtonPressMask);
470         XChangeProperty (dpy, window, XA_WM_PROTOCOLS, XA_ATOM, 32,
471                          PropModeReplace,
472                          (unsigned char *) &XA_WM_DELETE_WINDOW, 1);
473       }
474     }
475
476   if (!dont_clear)
477     {
478       XSetWindowBackground (dpy, window,
479                             get_pixel_resource ("background", "Background",
480                                                 dpy, cmap));
481       XClearWindow (dpy, window);
482     }
483
484   if (!root_p && !on_window)
485     /* wait for it to be mapped */
486     XIfEvent (dpy, &event, MapNotify_event_p, (XPointer) window);
487
488   XSync (dpy, False);
489   srandom ((int) time ((time_t *) 0));
490   screenhack (dpy, window); /* doesn't return */
491   return 0;
492 }