git.hungrycats.org Git - xscreensaver/blob - 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 #ifndef isupper
  61 # define isupper(c)  ((c) >= 'A' && (c) <= 'Z')
  62 #endif
  63 #ifndef _tolower
  64 # define _tolower(c)  ((c) - 'A' + 'a')
  65 #endif
  66
  67
  68 char *progname;
  69 XrmDatabase db;
  70 XtAppContext app;
  71 Bool mono_p;
  72
  73 static XrmOptionDescRec default_options [] = {
  74   { "-root",    ".root",                XrmoptionNoArg, "True" },
  75   { "-window",  ".root",                XrmoptionNoArg, "False" },
  76   { "-mono",    ".mono",                XrmoptionNoArg, "True" },
  77   { "-install", ".installColormap",     XrmoptionNoArg, "True" },
  78   { "-noinstall",".installColormap",    XrmoptionNoArg, "False" },
  79   { "-visual",  ".visualID",            XrmoptionSepArg, 0 },
  80   { "-window-id", ".windowID",          XrmoptionSepArg, 0 },
  81   { 0, 0, 0, 0 }
  82 };
  83
  84 static char *default_defaults[] = {
  85   ".root:               false",
  86   "*geometry:           600x480", /* this should be .geometry, but nooooo... */
  87   "*mono:               false",
  88   "*installColormap:    false",
  89   "*visualID:           default",
  90   "*windowID:           ",
  91   0
  92 };
  93
  94 static XrmOptionDescRec *merged_options;
  95 static int merged_options_size;
  96 static char **merged_defaults;
  97
  98 static void
  99 merge_options (void)
 100 {
 101   int def_opts_size, opts_size;
 102   int def_defaults_size, defaults_size;
 103
 104   for (def_opts_size = 0; default_options[def_opts_size].option;
 105        def_opts_size++)
 106     ;
 107   for (opts_size = 0; options[opts_size].option; opts_size++)
 108     ;
 109
 110   merged_options_size = def_opts_size + opts_size;
 111   merged_options = (XrmOptionDescRec *)
 112     malloc ((merged_options_size + 1) * sizeof(*default_options));
 113   memcpy (merged_options, default_options,
 114           (def_opts_size * sizeof(*default_options)));
 115   memcpy (merged_options + def_opts_size, options,
 116           ((opts_size + 1) * sizeof(*default_options)));
 117
 118   for (def_defaults_size = 0; default_defaults[def_defaults_size];
 119        def_defaults_size++)
 120     ;
 121   for (defaults_size = 0; defaults[defaults_size]; defaults_size++)
 122     ;
 123   merged_defaults = (char **)
 124     malloc ((def_defaults_size + defaults_size + 1) * sizeof (*defaults));;
 125   memcpy (merged_defaults, default_defaults,
 126           def_defaults_size * sizeof(*defaults));
 127   memcpy (merged_defaults + def_defaults_size, defaults,
 128           (defaults_size + 1) * sizeof(*defaults));
 129
 130   /* This totally sucks.  Xt should behave like this by default.
 131      If the string in `defaults' looks like ".foo", change that
 132      to "Progclass.foo".
 133    */
 134   {
 135     char **s;
 136     for (s = merged_defaults; *s; s++)
 137       if (**s == '.')
 138         {
 139           const char *oldr = *s;
 140           char *newr = (char *) malloc(strlen(oldr) + strlen(progclass) + 3);
 141           strcpy (newr, progclass);
 142           strcat (newr, oldr);
 143           *s = newr;
 144         }
 145   }
 146 }
 147
 148 \f
 149 /* Make the X errors print out the name of this program, so we have some
 150    clue which one has a bug when they die under the screensaver.
 151  */
 152
 153 static int
 154 screenhack_ehandler (Display *dpy, XErrorEvent *error)
 155 {
 156   fprintf (stderr, "\nX error in %s:\n", progname);
 157   if (XmuPrintDefaultErrorMessage (dpy, error, stderr))
 158     exit (-1);
 159   else
 160     fprintf (stderr, " (nonfatal.)\n");
 161   return 0;
 162 }
 163
 164 static Bool
 165 MapNotify_event_p (Display *dpy, XEvent *event, XPointer window)
 166 {
 167   return (event->xany.type == MapNotify &&
 168           event->xvisibility.window == (Window) window);
 169 }
 170
 171
 172 #ifdef XLOCKMORE
 173 extern void pre_merge_options (void);
 174 #endif
 175
 176
 177 static Atom XA_WM_PROTOCOLS, XA_WM_DELETE_WINDOW;
 178
 179 /* Dead-trivial event handling: exits if "q" or "ESC" are typed.
 180    Exit if the WM_PROTOCOLS WM_DELETE_WINDOW ClientMessage is received.
 181  */
 182 void
 183 screenhack_handle_event (Display *dpy, XEvent *event)
 184 {
 185   switch (event->xany.type)
 186     {
 187     case KeyPress:
 188       {
 189         KeySym keysym;
 190         char c = 0;
 191         XLookupString (&event->xkey, &c, 1, &keysym, 0);
 192         if (c == 'q' ||
 193             c == 'Q' ||
 194             c == 3 ||   /* ^C */
 195             c == 27)    /* ESC */
 196           exit (0);
 197         else if (! (keysym >= XK_Shift_L && keysym <= XK_Hyper_R))
 198           XBell (dpy, 0);  /* beep for non-chord keys */
 199       }
 200       break;
 201     case ButtonPress:
 202       XBell (dpy, 0);
 203       break;
 204     case ClientMessage:
 205       {
 206         if (event->xclient.message_type != XA_WM_PROTOCOLS)
 207           {
 208             char *s = XGetAtomName(dpy, event->xclient.message_type);
 209             if (!s) s = "(null)";
 210             fprintf (stderr, "%s: unknown ClientMessage %s received!\n",
 211                      progname, s);
 212           }
 213         else if (event->xclient.data.l[0] != XA_WM_DELETE_WINDOW)
 214           {
 215             char *s1 = XGetAtomName(dpy, event->xclient.message_type);
 216             char *s2 = XGetAtomName(dpy, event->xclient.data.l[0]);
 217             if (!s1) s1 = "(null)";
 218             if (!s2) s2 = "(null)";
 219             fprintf (stderr, "%s: unknown ClientMessage %s[%s] received!\n",
 220                      progname, s1, s2);
 221           }
 222         else
 223           {
 224             exit (0);
 225           }
 226       }
 227       break;
 228     }
 229 }
 230
 231
 232 void
 233 screenhack_handle_events (Display *dpy)
 234 {
 235   while (XPending (dpy))
 236     {
 237       XEvent event;
 238       XNextEvent (dpy, &event);
 239       screenhack_handle_event (dpy, &event);
 240     }
 241 }
 242
 243
 244 static Visual *
 245 pick_visual (Screen *screen)
 246 {
 247 #ifdef USE_GL
 248   /* If we're linking against GL (that is, this is the version of screenhack.o
 249      that the GL hacks will use, which is different from the one that the
 250      non-GL hacks will use) then try to pick the "best" visual by interrogating
 251      the GL library instead of by asking Xlib.  GL knows better.
 252    */
 253   Visual *v = 0;
 254   char *string = get_string_resource ("visualID", "VisualID");
 255   char *s;
 256
 257   if (string)
 258     for (s = string; *s; s++)
 259       if (isupper (*s)) *s = _tolower (*s);
 260
 261   if (!string || !*string ||
 262       !strcmp (string, "gl") ||
 263       !strcmp (string, "best") ||
 264       !strcmp (string, "color") ||
 265       !strcmp (string, "default"))
 266     v = get_gl_visual (screen);         /* from ../utils/visual-gl.c */
 267
 268   if (string)
 269     free (string);
 270   if (v)
 271     return v;
 272 #endif /* USE_GL */
 273
 274   return get_visual_resource (screen, "visualID", "VisualID", False);
 275 }
 276
 277
 278 /* Notice when the user has requested a different visual or colormap
 279    on a pre-existing window (e.g., "-root -visual truecolor" or
 280    "-window-id 0x2c00001 -install") and complain, since when drawing
 281    on an existing window, we have no choice about these things.
 282  */
 283 static void
 284 visual_warning (Screen *screen, Window window, Visual *visual, Colormap cmap,
 285                 Bool window_p)
 286 {
 287   char *visual_string = get_string_resource ("visualID", "VisualID");
 288   Visual *desired_visual = pick_visual (screen);
 289   char win[100];
 290   char why[100];
 291
 292   if (window == RootWindowOfScreen (screen))
 293     strcpy (win, "root window");
 294   else
 295     sprintf (win, "window 0x%x", (unsigned long) window);
 296
 297   if (window_p)
 298     sprintf (why, "-window-id 0x%x", (unsigned long) window);
 299   else
 300     strcpy (why, "-root");
 301
 302   if (visual_string && *visual_string)
 303     {
 304       char *s;
 305       for (s = visual_string; *s; s++)
 306         if (isupper (*s)) *s = _tolower (*s);
 307
 308       if (!strcmp (visual_string, "default") ||
 309           !strcmp (visual_string, "default") ||
 310           !strcmp (visual_string, "best"))
 311         /* don't warn about these, just silently DWIM. */
 312         ;
 313       else if (visual != desired_visual)
 314         {
 315           fprintf (stderr, "%s: ignoring `-visual %s' because of `%s'.\n",
 316                    progname, visual_string, why);
 317           fprintf (stderr, "%s: using %s's visual 0x%x.\n",
 318                    progname, win, XVisualIDFromVisual (visual));
 319         }
 320       free (visual_string);
 321     }
 322
 323   if (visual == DefaultVisualOfScreen (screen) &&
 324       has_writable_cells (screen, visual) &&
 325       get_boolean_resource ("installColormap", "InstallColormap"))
 326     {
 327       fprintf (stderr, "%s: ignoring `-install' because of `%s'.\n",
 328                progname, why);
 329       fprintf (stderr, "%s: using %s's colormap 0x%x.\n",
 330                progname, win, (unsigned long) cmap);
 331     }
 332
 333 # ifdef USE_GL
 334   if (!validate_gl_visual (stderr, screen, win, visual))
 335     exit (1);
 336 # endif /* USE_GL */
 337 }
 338
 339
 340 int
 341 main (int argc, char **argv)
 342 {
 343   Widget toplevel;
 344   Display *dpy;
 345   Window window;
 346   Screen *screen;
 347   Visual *visual;
 348   Colormap cmap;
 349   Bool root_p;
 350   Window on_window = 0;
 351   XEvent event;
 352   Boolean dont_clear /*, dont_map */;
 353   char version[255];
 354
 355 #ifdef XLOCKMORE
 356   pre_merge_options ();
 357 #endif
 358   merge_options ();
 359
 360 #ifdef __sgi
 361   /* We have to do this on SGI to prevent the background color from being
 362      overridden by the current desktop color scheme (we'd like our backgrounds
 363      to be black, thanks.)  This should be the same as setting the
 364      "*useSchemes: none" resource, but it's not -- if that resource is
 365      present in the `default_defaults' above, it doesn't work, though it
 366      does work when passed as an -xrm arg on the command line.  So screw it,
 367      turn them off from C instead.
 368    */
 369   SgiUseSchemes ("none");
 370 #endif /* __sgi */
 371
 372   toplevel = XtAppInitialize (&app, progclass, merged_options,
 373                               merged_options_size, &argc, argv,
 374                               merged_defaults, 0, 0);
 375   dpy = XtDisplay (toplevel);
 376   screen = XtScreen (toplevel);
 377   db = XtDatabase (dpy);
 378
 379   XtGetApplicationNameAndClass (dpy, &progname, &progclass);
 380
 381   /* half-assed way of avoiding buffer-overrun attacks. */
 382   if (strlen (progname) >= 100) progname[100] = 0;
 383
 384   XSetErrorHandler (screenhack_ehandler);
 385
 386   XA_WM_PROTOCOLS = XInternAtom (dpy, "WM_PROTOCOLS", False);
 387   XA_WM_DELETE_WINDOW = XInternAtom (dpy, "WM_DELETE_WINDOW", False);
 388
 389   {
 390     char *v = (char *) strdup(strchr(screensaver_id, ' '));
 391     char *s1, *s2, *s3, *s4;
 392     s1 = (char *) strchr(v,  ' '); s1++;
 393     s2 = (char *) strchr(s1, ' ');
 394     s3 = (char *) strchr(v,  '('); s3++;
 395     s4 = (char *) strchr(s3, ')');
 396     *s2 = 0;
 397     *s4 = 0;
 398     sprintf (version, "%s: from the XScreenSaver %s distribution (%s.)",
 399              progclass, s1, s3);
 400     free(v);
 401   }
 402
 403   if (argc > 1)
 404     {
 405       const char *s;
 406       int i;
 407       int x = 18;
 408       int end = 78;
 409       Bool help_p = !strcmp(argv[1], "-help");
 410       fprintf (stderr, "%s\n", version);
 411       for (s = progclass; *s; s++) fprintf(stderr, " ");
 412       fprintf (stderr, "  http://www.jwz.org/xscreensaver/\n\n");
 413
 414       if (!help_p)
 415         fprintf(stderr, "Unrecognised option: %s\n", argv[1]);
 416       fprintf (stderr, "Options include: ");
 417       for (i = 0; i < merged_options_size; i++)
 418         {
 419           char *sw = merged_options [i].option;
 420           Bool argp = (merged_options [i].argKind == XrmoptionSepArg);
 421           int size = strlen (sw) + (argp ? 6 : 0) + 2;
 422           if (x + size >= end)
 423             {
 424               fprintf (stderr, "\n\t\t ");
 425               x = 18;
 426             }
 427           x += size;
 428           fprintf (stderr, "%s", sw);
 429           if (argp) fprintf (stderr, " <arg>");
 430           if (i != merged_options_size - 1) fprintf (stderr, ", ");
 431         }
 432       fprintf (stderr, ".\n");
 433       exit (help_p ? 0 : 1);
 434     }
 435
 436   dont_clear = get_boolean_resource ("dontClearRoot", "Boolean");
 437 /*dont_map = get_boolean_resource ("dontMapWindow", "Boolean"); */
 438   mono_p = get_boolean_resource ("mono", "Boolean");
 439   if (CellsOfScreen (DefaultScreenOfDisplay (dpy)) <= 2)
 440     mono_p = True;
 441
 442   root_p = get_boolean_resource ("root", "Boolean");
 443
 444   {
 445     char *s = get_string_resource ("windowID", "WindowID");
 446     if (s && *s)
 447       on_window = get_integer_resource ("windowID", "WindowID");
 448     if (s) free (s);
 449   }
 450
 451   if (on_window)
 452     {
 453       XWindowAttributes xgwa;
 454       window = (Window) on_window;
 455       XtDestroyWidget (toplevel);
 456       XGetWindowAttributes (dpy, window, &xgwa);
 457       cmap = xgwa.colormap;
 458       visual = xgwa.visual;
 459       visual_warning (screen, window, visual, cmap, True);
 460     }
 461   else if (root_p)
 462     {
 463       XWindowAttributes xgwa;
 464       window = RootWindowOfScreen (XtScreen (toplevel));
 465       XtDestroyWidget (toplevel);
 466       XGetWindowAttributes (dpy, window, &xgwa);
 467       cmap = xgwa.colormap;
 468       visual = xgwa.visual;
 469       visual_warning (screen, window, visual, cmap, False);
 470     }
 471   else
 472     {
 473       Boolean def_visual_p;
 474       visual = pick_visual (screen);
 475
 476 # ifdef USE_GL
 477       if (!validate_gl_visual (stderr, screen, "window", visual))
 478         exit (1);
 479 # endif /* USE_GL */
 480
 481       if (toplevel->core.width <= 0)
 482         toplevel->core.width = 600;
 483       if (toplevel->core.height <= 0)
 484         toplevel->core.height = 480;
 485
 486       def_visual_p = (visual == DefaultVisualOfScreen (screen));
 487
 488       if (!def_visual_p)
 489         {
 490           unsigned int bg, bd;
 491           Widget new;
 492
 493           cmap = XCreateColormap (dpy, RootWindowOfScreen(screen),
 494                                   visual, AllocNone);
 495           bg = get_pixel_resource ("background", "Background", dpy, cmap);
 496           bd = get_pixel_resource ("borderColor", "Foreground", dpy, cmap);
 497
 498           new = XtVaAppCreateShell (progname, progclass,
 499                                     topLevelShellWidgetClass, dpy,
 500                                     XtNmappedWhenManaged, False,
 501                                     XtNvisual, visual,
 502                                     XtNdepth, visual_depth (screen, visual),
 503                                     XtNwidth, toplevel->core.width,
 504                                     XtNheight, toplevel->core.height,
 505                                     XtNcolormap, cmap,
 506                                     XtNbackground, (Pixel) bg,
 507                                     XtNborderColor, (Pixel) bd,
 508                                     XtNinput, True,  /* for WM_HINTS */
 509                                     0);
 510           XtDestroyWidget (toplevel);
 511           toplevel = new;
 512           XtRealizeWidget (toplevel);
 513           window = XtWindow (toplevel);
 514         }
 515       else
 516         {
 517           XtVaSetValues (toplevel,
 518                          XtNmappedWhenManaged, False,
 519                          XtNinput, True,  /* for WM_HINTS */
 520                          0);
 521           XtRealizeWidget (toplevel);
 522           window = XtWindow (toplevel);
 523
 524           if (get_boolean_resource ("installColormap", "InstallColormap"))
 525             {
 526               cmap = XCreateColormap (dpy, window,
 527                                    DefaultVisualOfScreen (XtScreen (toplevel)),
 528                                       AllocNone);
 529               XSetWindowColormap (dpy, window, cmap);
 530             }
 531           else
 532             {
 533               cmap = DefaultColormap (dpy, DefaultScreen (dpy));
 534             }
 535         }
 536
 537 /*
 538       if (dont_map)
 539         {
 540           XtVaSetValues (toplevel, XtNmappedWhenManaged, False, 0);
 541           XtRealizeWidget (toplevel);
 542         }
 543       else
 544 */
 545         {
 546           XtPopup (toplevel, XtGrabNone);
 547         }
 548
 549       XtVaSetValues(toplevel, XtNtitle, version, 0);
 550
 551       /* For screenhack_handle_events(): select KeyPress, and
 552          announce that we accept WM_DELETE_WINDOW. */
 553       {
 554         XWindowAttributes xgwa;
 555         XGetWindowAttributes (dpy, window, &xgwa);
 556         XSelectInput (dpy, window,
 557                       xgwa.your_event_mask | KeyPressMask | ButtonPressMask);
 558         XChangeProperty (dpy, window, XA_WM_PROTOCOLS, XA_ATOM, 32,
 559                          PropModeReplace,
 560                          (unsigned char *) &XA_WM_DELETE_WINDOW, 1);
 561       }
 562     }
 563
 564   if (!dont_clear)
 565     {
 566       XSetWindowBackground (dpy, window,
 567                             get_pixel_resource ("background", "Background",
 568                                                 dpy, cmap));
 569       XClearWindow (dpy, window);
 570     }
 571
 572   if (!root_p && !on_window)
 573     /* wait for it to be mapped */
 574     XIfEvent (dpy, &event, MapNotify_event_p, (XPointer) window);
 575
 576   XSync (dpy, False);
 577
 578   /* This is the one and only place that the random-number generator is
 579      seeded in any screenhack.  You do not need to seed the RNG again,
 580      it is done for you before your code is invoked. */
 581 # undef ya_rand_init
 582   ya_rand_init (0);
 583
 584   screenhack (dpy, window); /* doesn't return */
 585   return 0;
 586 }