/* xscreensaver, Copyright (c) 1997, 2005 Jamie Zawinski <jwz@jwz.org>
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation. No representations are made about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*/
/* This is a kludge that lets xscreensaver work with SGI demos that expect
to be run from `haven'. It runs the program given on the command line,
then waits for an X window to be created whose name is that of the
program. Then, it resizes that window to fill the screen. Run it
like this:
xscreensaver-sgigl /usr/demos/bin/ep -S
xscreensaver-sgigl -n ant /usr/demos/General_Demos/ant/RUN
xscreensaver-sgigl -n atlantis /usr/demos/General_Demos/atlantis/RUN
xscreensaver-sgigl -n /usr/demos/General_Demos/powerflip/powerflip \
/usr/demos/General_Demos/powerflip/RUN
Except that doesn't really work. You have to do this instead:
xscreensaver-sgigl -n ant ant.sh
where ant.sh contains
#!/bin/sh
cd /usr/demos/General_Demos/ant
exec ./ant -S
There's no way to make this work with powerflip at all, since it doesn't
take a -S option to run in the foreground.
*/
/* #### Another way to do this would be:
instead of exec'ing the hack, fork it; then wait for that fork to die.
If it dies, but the window ID is still valid, then that means the
sub-process has forked itself (as those fuckwits at SGI are wont to do.)
In that case, this process should go to sleep, and set up a signal handler
that will destroy the X window when it is killed. That way, the caller
is given a foreground pid which, when killed, will cause the hack to die
(by a roundabout mechanism.)
This would all be so much simpler if those assholes would just:
1: get out of the habit of writing programs that magically background
themselves, and
2: give the fucking programs arguments which control the window size
instead of always making 100x100 windows!
I won't even dream of having a "-root" option that understood virtual-roots;
that would just be too outlandish to even dream about.
*/
static char *progname;
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/time.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xmu/Error.h>
#include "vroot.h"
#undef RootWindowOfScreen
#undef RootWindow
#undef DefaultRootWindow
static int
BadWindow_ehandler (Display *dpy, XErrorEvent *error)
{
if (error->error_code == BadWindow ||
error->error_code == BadMatch ||
error->error_code == BadDrawable)
return 0;
else
{
fprintf (stderr, "\nX error in %s:\n", progname);
if (XmuPrintDefaultErrorMessage (dpy, error, stderr))
exit(1);
else
fprintf (stderr, " (nonfatal.)\n");
}
return 0;
}
void
main(int ac, char **av)
{
char buf [512];
pid_t parent, forked;
Display *dpy;
Screen *screen;
char *s;
char *n1 = 0;
char *n2 = 0;
Bool verbose = False;
Window root, vroot;
XSizeHints h;
long ls;
progname = av[0];
s = strrchr(progname, '/');
if (s) progname = s+1;
if (ac < 1)
{
fprintf(stderr,
"usage: %s [ -v ] [ -n window-name ] program arguments...\n",
progname);
exit(1);
}
if (ac > 2 && !strcmp(av[1], "-v"))
{
verbose = True;
av++;
ac--;
}
if (ac > 2 && !strcmp(av[1], "-n"))
{
n2 = av[2];
av += 2;
ac -= 2;
}
n1 = strrchr(av[1], '/');
if (n1) n1++;
else n1 = av[1];
dpy = XOpenDisplay(0);
if (!dpy)
{
fprintf(stderr, "%s: couldn't open display\n", progname);
exit(1);
}
screen = DefaultScreenOfDisplay(dpy);
root = XRootWindowOfScreen (screen);
vroot = VirtualRootWindowOfScreen (screen);
XSelectInput (dpy, root, SubstructureNotifyMask);
if (root != vroot)
XSelectInput (dpy, vroot, SubstructureNotifyMask);
XSetErrorHandler (BadWindow_ehandler);
if (verbose)
fprintf(stderr, "%s: selected SubstructureNotifyMask on 0x%x / 0x%x\n",
progname, root, vroot);
parent = getpid();
if (verbose)
fprintf(stderr, "%s: pid is %d\n", progname, parent);
switch ((int) (forked = fork ()))
{
case -1:
{
sprintf (buf, "%s: couldn't fork", progname);
perror (buf);
exit (1);
break;
}
case 0: /* forked */
{
time_t start = time((time_t) 0);
XEvent event;
if (verbose)
fprintf(stderr, "%s: forked pid is %d\n", progname, getpid());
while (1)
{
XNextEvent(dpy, &event);
if (event.xany.type == CreateNotify)
{
char *name = 0;
Window w = event.xcreatewindow.window;
XSync(dpy, False);
XFetchName(dpy, w, &name);
if (!name)
{
/* Try again to see if the name has been set later... */
XSync(dpy, False);
sleep(1);
XFetchName(dpy, w, &name);
}
if (name &&
((n1 && !strcmp(name, n1)) ||
(n2 && !strcmp(name, n2))))
{
if (verbose)
fprintf(stderr, "%s: resizing 0x%x\n", progname, w);
/* Make sure the window allows itself to be resized. */
XGetWMNormalHints (dpy, w, &h, &ls);
h.flags |= PMaxSize;
h.max_width = WidthOfScreen(screen)+128;
h.max_height = HeightOfScreen(screen)+128;
XSetWMNormalHints (dpy, w, &h);
XMoveResizeWindow(dpy, w, 0, 0,
WidthOfScreen(screen),
HeightOfScreen(screen));
#if 0
if (vroot && vroot != root &&
event.xcreatewindow.parent == root)
{
if (verbose)
fprintf(stderr,
"%s: reparenting 0x%x from 0x%x to 0x%x\n",
progname, w, root, vroot);
XReparentWindow(dpy, w, vroot, 0, 0);
}
#endif
XSync(dpy, False);
fflush(stdout);
fflush(stderr);
exit(0); /* Note that this only exits a child fork. */
}
}
if (start + 5 < time((time_t) 0))
{
fprintf(stderr,
"%s: timed out: no window named \"%s\" has been created\n",
progname, (n2 ? n2 : n1));
fflush(stdout);
fflush(stderr);
kill(parent, SIGTERM);
exit(1);
}
}
break;
}
default: /* foreground */
{
close (ConnectionNumber (dpy)); /* close display fd */
execvp (av[1], av+1); /* shouldn't return. */
sprintf (buf, "%s: execvp(\"%s\") failed", progname, av[1]);
perror (buf);
fflush(stderr);
fflush(stdout);
exit (1);
break;
}
}
}
