/* xscreensaver, Copyright (c) 1992-2018 Jamie Zawinski * * 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 file contains code for running an external program to grab an image onto the given window. The external program in question must take a window ID as its argument, e.g., the "xscreensaver-getimage" program in the hacks/ directory. That program links against utils/grabimage.c, which happens to export the same API as this program (utils/grabclient.c). */ /* This code is a mess. There's two decades of history in this file. There are several distinct paths through this file depending on what platform it's being compiled for: X11 execution path: load_image_async CB load_random_image_x11 fork_exec_cb "xscreensaver-getimage 0xWINDOW 0xPIXMAP" "xscreensaver-getimage-file --name /DIR" draw_colorbars XPutImage XtAppAddInput xscreensaver_getimage_cb ... xscreensaver_getimage_cb get_name_from_xprops get_original_geometry_from_xprops CB name, geom, closure MacOS execution path: load_image_async CB load_random_image_cocoa osx_grab_desktop_image (grabclient-osx.m, MacOS version) copy_framebuffer_to_ximage XPutImage draw_colorbars osx_load_image_file_async open_image_name_pipe "xscreensaver-getimage-file --name /DIR" XtAppAddInput xscreensaver_getimage_file_cb ... xscreensaver_getimage_file_cb osx_load_image_file CB name, geom, closure iOS execution path: load_image_async CB load_random_image_cocoa osx_grab_desktop_image (grabclient-osx.m, iOS version) CGWindowListCreateImage jwxyz_draw_NSImage_or_CGImage draw_colorbars ios_load_random_image ios_load_random_image_cb jwxyz_draw_NSImage_or_CGImage CB name, geom, closure Android execution path: load_image_async CB load_random_image_android jwxyz_load_random_image (jwxyz-android.c) XPutImage draw_colorbars CB name, geom, closure */ #include "utils.h" #include "grabscreen.h" #include "resources.h" #include "yarandom.h" #ifdef HAVE_JWXYZ # include "jwxyz.h" # include "colorbars.h" #else /* !HAVE_COCOA -- real Xlib */ # include "vroot.h" # include # include /* for XtInputId, etc */ #endif /* !HAVE_COCOA */ #include #ifdef HAVE_UNISTD_H # include #endif #ifdef HAVE_SYS_WAIT_H # include /* for waitpid() and associated macros */ #endif extern char *progname; static void print_loading_msg (Screen *, Window); /* Used for pipe callbacks in X11 or OSX mode. X11: this is the xscreensaver_getimage_cb closure, when waiting on the fork of "xscreensaver-getimage" OSX: this is the xscreensaver_getimage_file_cb closure, when waiting on the fork of "xscreensaver-getimage-file" */ typedef struct { void (*callback) (Screen *, Window, Drawable, const char *name, XRectangle *geom, void *closure); Screen *screen; Window window; Drawable drawable; void *closure; XtInputId pipe_id; FILE *pipe; # if !defined(USE_IPHONE) && !defined(HAVE_COCOA) /* Real X11 */ pid_t pid; # endif # if !defined(USE_IPHONE) && defined(HAVE_COCOA) /* Desktop OSX */ char *directory; # endif } xscreensaver_getimage_data; #if !defined(HAVE_COCOA) && !defined(HAVE_ANDROID) /* Real X11 */ static Bool error_handler_hit_p = False; static int ignore_all_errors_ehandler (Display *dpy, XErrorEvent *error) { error_handler_hit_p = True; return 0; } /* Returns True if the given Drawable is a Window; False if it's a Pixmap. */ static Bool drawable_window_p (Display *dpy, Drawable d) { XErrorHandler old_handler; XWindowAttributes xgwa; XSync (dpy, False); old_handler = XSetErrorHandler (ignore_all_errors_ehandler); error_handler_hit_p = False; XGetWindowAttributes (dpy, d, &xgwa); XSync (dpy, False); XSetErrorHandler (old_handler); XSync (dpy, False); if (!error_handler_hit_p) return True; /* It's a Window. */ else return False; /* It's a Pixmap, or an invalid ID. */ } static Bool xscreensaver_window_p (Display *dpy, Window window) { Atom type; int format; unsigned long nitems, bytesafter; unsigned char *version; if (XGetWindowProperty (dpy, window, XInternAtom (dpy, "_SCREENSAVER_VERSION", False), 0, 1, False, XA_STRING, &type, &format, &nitems, &bytesafter, &version) == Success && type != None) return True; return False; } /* XCopyArea seems not to work right on SGI O2s if you draw in SubwindowMode on a window whose depth is not the maximal depth of the screen? Or something. Anyway, things don't work unless we: use SubwindowMode for the real root window (or a legitimate virtual root window); but do not use SubwindowMode for the xscreensaver window. I make no attempt to explain. */ Bool use_subwindow_mode_p (Screen *screen, Window window) { if (window != VirtualRootWindowOfScreen(screen)) return False; else if (xscreensaver_window_p(DisplayOfScreen(screen), window)) return False; else return True; } static void checkerboard (Screen *screen, Drawable drawable) { Display *dpy = DisplayOfScreen (screen); unsigned int x, y; int size = 24; XColor fg, bg; XGCValues gcv; GC gc = XCreateGC (dpy, drawable, 0, &gcv); Colormap cmap; unsigned int win_width, win_height; fg.flags = bg.flags = DoRed|DoGreen|DoBlue; fg.red = fg.green = fg.blue = 0x0000; bg.red = bg.green = bg.blue = 0x4444; fg.pixel = 0; bg.pixel = 1; if (drawable_window_p (dpy, drawable)) { XWindowAttributes xgwa; XGetWindowAttributes (dpy, drawable, &xgwa); win_width = xgwa.width; win_height = xgwa.height; cmap = xgwa.colormap; screen = xgwa.screen; } else /* it's a pixmap */ { XWindowAttributes xgwa; Window root; int x, y; unsigned int bw, d; XGetWindowAttributes (dpy, RootWindowOfScreen (screen), &xgwa); cmap = xgwa.colormap; XGetGeometry (dpy, drawable, &root, &x, &y, &win_width, &win_height, &bw, &d); } /* Allocate black and gray, but don't hold them locked. */ if (XAllocColor (dpy, cmap, &fg)) XFreeColors (dpy, cmap, &fg.pixel, 1, 0); if (XAllocColor (dpy, cmap, &bg)) XFreeColors (dpy, cmap, &bg.pixel, 1, 0); XSetForeground (dpy, gc, bg.pixel); XFillRectangle (dpy, drawable, gc, 0, 0, win_width, win_height); XSetForeground (dpy, gc, fg.pixel); for (y = 0; y < win_height; y += size+size) for (x = 0; x < win_width; x += size+size) { XFillRectangle (dpy, drawable, gc, x, y, size, size); XFillRectangle (dpy, drawable, gc, x+size, y+size, size, size); } XFreeGC (dpy, gc); } /* Read the image's original name off of the window's X properties. Used only when running "real" X11, not jwxyz. */ static char * get_name_from_xprops (Display *dpy, Window window) { Atom type; int format; unsigned long nitems, bytesafter; unsigned char *name = 0; Atom atom = XInternAtom (dpy, XA_XSCREENSAVER_IMAGE_FILENAME, False); if (XGetWindowProperty (dpy, window, atom, 0, 1024, False, XA_STRING, &type, &format, &nitems, &bytesafter, &name) == Success && type != None) return (char *) name; else return 0; } /* Read the image's original geometry off of the window's X properties. Used only when running "real" X11, not jwxyz. */ static Bool get_original_geometry_from_xprops (Display *dpy, Window window, XRectangle *ret) { Atom type; int format; unsigned long nitems, bytesafter; unsigned char *name = 0; Atom atom = XInternAtom (dpy, XA_XSCREENSAVER_IMAGE_GEOMETRY, False); int x, y; unsigned int w, h; if (XGetWindowProperty (dpy, window, atom, 0, 1024, False, XA_STRING, &type, &format, &nitems, &bytesafter, &name) == Success && type != None) { int flags = XParseGeometry ((char *) name, &x, &y, &w, &h); free (name); /* Require all four, and don't allow negative positions. */ if (flags == (XValue|YValue|WidthValue|HeightValue)) { ret->x = x; ret->y = y; ret->width = w; ret->height = h; return True; } else return False; } else return False; } static void hack_subproc_environment (Display *dpy) { /* Store $DISPLAY into the environment, so that the $DISPLAY variable that the spawned processes inherit is what we are actually using. */ const char *odpy = DisplayString (dpy); char *ndpy = (char *) malloc(strlen(odpy) + 20); strcpy (ndpy, "DISPLAY="); strcat (ndpy, odpy); /* Allegedly, BSD 4.3 didn't have putenv(), but nobody runs such systems any more, right? It's not Posix, but everyone seems to have it. */ # ifdef HAVE_PUTENV if (putenv (ndpy)) abort (); # endif /* HAVE_PUTENV */ /* don't free (ndpy) -- some implementations of putenv (BSD 4.4, glibc 2.0) copy the argument, but some (libc4,5, glibc 2.1.2, MacOS) do not. So we must leak it (and/or the previous setting). Yay. */ } /* Spawn a program, and wait for it to finish. If we just use system() for this, then sometimes the subprocess doesn't die when *this* process is sent a TERM signal. Perhaps this is due to the intermediate /bin/sh that system() uses to parse arguments? I'm not sure. But using fork() and execvp() here seems to close the race. Used to execute "xscreensaver-getimage". Used only when running "real" X11, not jwxyz. */ static void exec_simple_command (const char *command) { char *av[1024]; int ac = 0; char *token = strtok (strdup(command), " \t"); while (token) { av[ac++] = token; token = strtok(0, " \t"); } av[ac] = 0; execvp (av[0], av); /* shouldn't return. */ } static void xscreensaver_getimage_cb (XtPointer closure, int *fd, XtIntervalId *id); /* Spawn a program, and run the callback when it finishes. Used to execute "xscreensaver-getimage". Used only when running "real" X11, not jwxyz. */ static void fork_exec_cb (const char *command, Screen *screen, Window window, Drawable drawable, void (*callback) (Screen *, Window, Drawable, const char *name, XRectangle *geom, void *closure), void *closure) { XtAppContext app = XtDisplayToApplicationContext (DisplayOfScreen (screen)); xscreensaver_getimage_data *data; char buf [255]; pid_t forked; FILE *wpipe; int fds [2]; if (pipe (fds)) { sprintf (buf, "%s: creating pipe", progname); perror (buf); exit (1); } data = (xscreensaver_getimage_data *) calloc (1, sizeof(*data)); data->callback = callback; data->closure = closure; data->screen = screen; data->window = window; data->drawable = drawable; data->pipe = fdopen (fds[0], "r"); wpipe = fdopen (fds[1], "w"); /* Is this necessary? */ if (!data->pipe || !wpipe) { sprintf (buf, "%s: fdopen", progname); perror (buf); exit (1); } data->pipe_id = XtAppAddInput (app, fileno (data->pipe), (XtPointer) (XtInputReadMask | XtInputExceptMask), xscreensaver_getimage_cb, (XtPointer) data); forked = fork (); switch ((int) forked) { case -1: sprintf (buf, "%s: couldn't fork", progname); perror (buf); return; case 0: /* child */ fclose (data->pipe); data->pipe = 0; /* clone the write pipe onto stdout so that it gets closed when the fork exits. This will shut down the pipe and signal the parent. */ close (fileno (stdout)); dup2 (fds[1], fileno (stdout)); close (fds[1]); close (fileno (stdin)); /* for kicks */ exec_simple_command (command); exit (1); /* exits child fork */ break; default: /* parent */ fclose (wpipe); data->pid = forked; break; } } /* Called in the parent when the forked process dies. Runs the caller's callback, and cleans up. This runs when "xscreensaver-getimage" exits. Used only when running "real" X11, not jwxyz. */ static void xscreensaver_getimage_cb (XtPointer closure, int *fd, XtIntervalId *id) { xscreensaver_getimage_data *data = (xscreensaver_getimage_data *) closure; Display *dpy = DisplayOfScreen (data->screen); char *name; XRectangle geom = { 0, 0, 0, 0 }; XtRemoveInput (*id); name = get_name_from_xprops (dpy, data->window); get_original_geometry_from_xprops (dpy, data->window, &geom); data->callback (data->screen, data->window, data->drawable, name, &geom, data->closure); if (name) free (name); fclose (data->pipe); if (data->pid) /* reap zombies */ { int status; waitpid (data->pid, &status, 0); data->pid = 0; } memset (data, 0, sizeof (*data)); free (data); } /* Loads an image into the Drawable. When grabbing desktop images, the Window will be unmapped first. Used only when running "real" X11, not jwxyz. */ static void load_random_image_x11 (Screen *screen, Window window, Drawable drawable, void (*callback) (Screen *, Window, Drawable, const char *name, XRectangle *geom, void *closure), void *closure) { Display *dpy = DisplayOfScreen (screen); char *grabber = get_string_resource(dpy, "desktopGrabber", "DesktopGrabber"); char *cmd; char id[200]; if (!grabber || !*grabber) { fprintf (stderr, "%s: resources installed incorrectly: \"desktopGrabber\" is unset!\n", progname); exit (1); } sprintf (id, "0x%lx 0x%lx", (unsigned long) window, (unsigned long) drawable); cmd = (char *) malloc (strlen(grabber) + strlen(id) + 1); /* Needn't worry about buffer overflows here, because the buffer is longer than the length of the format string, and the length of what we're putting into it. So the only way to crash would be if the format string itself was corrupted, but that comes from the resource database, and if hostile forces have access to that, then the game is already over. */ sprintf (cmd, grabber, id); free (grabber); grabber = 0; /* In case "cmd" fails, leave some random image on the screen, not just black or white, so that it's more obvious what went wrong. */ checkerboard (screen, drawable); if (window == drawable) print_loading_msg (screen, window); XSync (dpy, True); hack_subproc_environment (dpy); /* Start the image loading in another fork and return immediately. Invoke the callback function when done. */ fork_exec_cb (cmd, screen, window, drawable, callback, closure); free (cmd); XSync (dpy, True); } #elif defined (HAVE_COCOA) /* OSX or iOS */ # ifndef USE_IPHONE /* HAVE_COCOA && !USE_IPHONE -- desktop OSX */ # define BACKSLASH(c) \ (! ((c >= 'a' && c <= 'z') || \ (c >= 'A' && c <= 'Z') || \ (c >= '0' && c <= '9') || \ c == '.' || c == '_' || c == '-' || c == '+' || c == '/')) /* Gets the name of an image file to load by running xscreensaver-getimage-file at the end of a pipe. This can be very slow! */ static FILE * open_image_name_pipe (const char *dir) { char *s; /* /bin/sh on OS X 10.10 wipes out the PATH. */ const char *path = getenv("PATH"); char *cmd = s = malloc ((strlen(dir) + strlen(path)) * 2 + 100); strcpy (s, "/bin/sh -c 'export PATH="); s += strlen (s); while (*path) { char c = *path++; if (BACKSLASH(c)) *s++ = '\\'; *s++ = c; } strcpy (s, "; "); s += strlen (s); strcpy (s, "xscreensaver-getimage-file --name "); s += strlen (s); while (*dir) { char c = *dir++; if (BACKSLASH(c)) *s++ = '\\'; *s++ = c; } strcpy (s, "'"); s += strlen (s); *s = 0; FILE *pipe = popen (cmd, "r"); free (cmd); return pipe; } static void xscreensaver_getimage_file_cb (XtPointer closure, int *source, XtInputId *id) { /* This is not called from a signal handler, so doing stuff here is fine. */ xscreensaver_getimage_data *clo2 = (xscreensaver_getimage_data *) closure; char buf[10240]; const char *dir = clo2->directory; char *absfile = 0; *buf = 0; fgets (buf, sizeof(buf)-1, clo2->pipe); pclose (clo2->pipe); clo2->pipe = 0; XtRemoveInput (clo2->pipe_id); clo2->pipe_id = 0; /* strip trailing newline */ int L = strlen(buf); while (L > 0 && (buf[L-1] == '\r' || buf[L-1] == '\n')) buf[--L] = 0; Display *dpy = DisplayOfScreen (clo2->screen); XRectangle geom; if (*buf && *buf != '/') /* pathname is relative to dir. */ { absfile = malloc (strlen(dir) + strlen(buf) + 10); strcpy (absfile, dir); if (dir[strlen(dir)-1] != '/') strcat (absfile, "/"); strcat (absfile, buf); } if (! osx_load_image_file (clo2->screen, clo2->window, clo2->drawable, (absfile ? absfile : buf), &geom)) { /* unable to load image - draw colorbars */ XWindowAttributes xgwa; XGetWindowAttributes (dpy, clo2->window, &xgwa); Window r; int x, y; unsigned int w, h, bbw, d; struct stat st; /* Log something to syslog so we can tell the difference between corrupted images and broken symlinks. */ if (!*buf) fprintf (stderr, "%s: no image filename found\n", progname); else if (! stat (buf, &st)) fprintf (stderr, "%s: %s: unparsable\n", progname, buf); else { char buf2[2048]; sprintf (buf2, "%.255s: %.1024s", progname, buf); perror (buf2); } XGetGeometry (dpy, clo2->drawable, &r, &x, &y, &w, &h, &bbw, &d); draw_colorbars (clo2->screen, xgwa.visual, clo2->drawable, xgwa.colormap, 0, 0, w, h, 0, 0); /* #### logo missing */ geom.x = geom.y = 0; geom.width = w; geom.height = h; } /* Take the extension off of the file name. */ /* Duplicated in driver/xscreensaver-getimage.c. */ if (*buf) { char *slash = strrchr (buf, '/'); char *dot = strrchr ((slash ? slash : buf), '.'); if (dot) *dot = 0; /* Replace slashes with newlines */ /* while (dot = strchr(buf, '/')) *dot = '\n'; */ /* Replace slashes with spaces */ /* while ((dot = strchr(buf, '/'))) *dot = ' '; */ } if (absfile) free (absfile); clo2->callback (clo2->screen, clo2->window, clo2->drawable, buf, &geom, clo2->closure); clo2->callback = 0; free (clo2->directory); free (clo2); } # else /* HAVE_COCOA && USE_IPHONE -- iOS */ /* Callback for ios_load_random_image(), called after we have loaded an image from the iOS device's Photo Library. See grabclient-ios.m. */ static void ios_load_random_image_cb (void *uiimage, const char *filename, int width, int height, void *closure) { xscreensaver_getimage_data *clo2 = (xscreensaver_getimage_data *) closure; Display *dpy = DisplayOfScreen (clo2->screen); XRectangle geom; XWindowAttributes xgwa; Window r; int x, y; unsigned int w, h, bbw, d; int rot = 0; XGetWindowAttributes (dpy, clo2->window, &xgwa); XGetGeometry (dpy, clo2->drawable, &r, &x, &y, &w, &h, &bbw, &d); /* If the image is portrait and the window is landscape, or vice versa, rotate the image. The idea is to fill up as many pixels as possible, and assume the user will just rotate their phone until it looks right. This makes "decayscreen", etc. much more easily viewable. */ if (get_boolean_resource (dpy, "rotateImages", "RotateImages")) { if ((width > height) != (w > h)) rot = 5; } if (uiimage) { jwxyz_draw_NSImage_or_CGImage (DisplayOfScreen (clo2->screen), clo2->drawable, True, uiimage, &geom, rot); } else /* Probably means no images in the gallery. */ { draw_colorbars (clo2->screen, xgwa.visual, clo2->drawable, xgwa.colormap, 0, 0, w, h, 0, 0); /* #### logo missing */ geom.x = geom.y = 0; geom.width = w; geom.height = h; filename = 0; } clo2->callback (clo2->screen, clo2->window, clo2->drawable, filename, &geom, clo2->closure); clo2->callback = 0; free (clo2); } # endif /* HAVE_COCOA && USE_IPHONE */ static void osx_load_image_file_async (Screen *screen, Window xwindow, Drawable drawable, const char *dir, void (*callback) (Screen *, Window, Drawable, const char *name, XRectangle *geom, void *closure), void *closure) { xscreensaver_getimage_data *clo2 = (xscreensaver_getimage_data *) calloc (1, sizeof(*clo2)); clo2->screen = screen; clo2->window = xwindow; clo2->drawable = drawable; clo2->callback = callback; clo2->closure = closure; # ifndef USE_IPHONE /* Desktop OSX */ clo2->directory = strdup (dir); clo2->pipe = open_image_name_pipe (dir); clo2->pipe_id = XtAppAddInput (XtDisplayToApplicationContext ( DisplayOfScreen (screen)), fileno (clo2->pipe), (XtPointer) (XtInputReadMask | XtInputExceptMask), xscreensaver_getimage_file_cb, (XtPointer) clo2); # else /* USE_IPHONE */ { XWindowAttributes xgwa; XGetWindowAttributes (DisplayOfScreen (screen), xwindow, &xgwa); ios_load_random_image (ios_load_random_image_cb, clo2, xgwa.width, xgwa.height); } # endif /* USE_IPHONE */ } /* Loads an image into the Drawable, returning once the image is loaded. */ static void load_random_image_cocoa (Screen *screen, Window window, Drawable drawable, void (*callback) (Screen *, Window, Drawable, const char *name, XRectangle *geom, void *closure), void *closure) { Display *dpy = DisplayOfScreen (screen); XWindowAttributes xgwa; Bool deskp = get_boolean_resource (dpy, "grabDesktopImages", "Boolean"); Bool filep = get_boolean_resource (dpy, "chooseRandomImages", "Boolean"); const char *dir = 0; Bool done = False; XRectangle geom; char *name = 0; if (!drawable) abort(); XGetWindowAttributes (dpy, window, &xgwa); { Window r; int x, y; unsigned int w, h, bbw, d; XGetGeometry (dpy, drawable, &r, &x, &y, &w, &h, &bbw, &d); xgwa.width = w; xgwa.height = h; } geom.x = 0; geom.y = 0; geom.width = xgwa.width; geom.height = xgwa.height; # ifndef USE_IPHONE if (filep) dir = get_string_resource (dpy, "imageDirectory", "ImageDirectory"); if (!dir || !*dir) filep = False; # endif /* ! USE_IPHONE */ if (deskp && filep) { deskp = !(random() & 5); /* if both, desktop 1/5th of the time */ filep = !deskp; } if (filep && !done) { osx_load_image_file_async (screen, window, drawable, dir, callback, closure); return; } if (deskp && !done) { if (osx_grab_desktop_image (screen, window, drawable, &geom)) { name = strdup ("desktop"); done = True; } } if (! done) draw_colorbars (screen, xgwa.visual, drawable, xgwa.colormap, 0, 0, xgwa.width, xgwa.height, 0, 0); /* #### logo missing */ /* If we got here, we loaded synchronously, so we're done. */ callback (screen, window, drawable, name, &geom, closure); if (name) free (name); } #elif defined(HAVE_ANDROID) /* Loads an image into the Drawable, returning once the image is loaded. */ static void load_random_image_android (Screen *screen, Window window, Drawable drawable, void (*callback) (Screen *, Window, Drawable, const char *name, XRectangle *geom, void *closure), void *closure) { Display *dpy = DisplayOfScreen (screen); XWindowAttributes xgwa; XRectangle geom; if (!drawable) abort(); XGetWindowAttributes (dpy, window, &xgwa); { Window r; int x, y; unsigned int w, h, bbw, d; XGetGeometry (dpy, drawable, &r, &x, &y, &w, &h, &bbw, &d); xgwa.width = w; xgwa.height = h; } geom.x = 0; geom.y = 0; geom.width = xgwa.width; geom.height = xgwa.height; XGCValues gcv; gcv.foreground = BlackPixelOfScreen (screen); GC gc = XCreateGC (dpy, drawable, GCForeground, &gcv); XFillRectangle (dpy, drawable, gc, 0, 0, xgwa.width, xgwa.height); char *name = jwxyz_draw_random_image (dpy, drawable, gc); if (! name) { draw_colorbars (screen, xgwa.visual, drawable, xgwa.colormap, 0, 0, xgwa.width, xgwa.height, 0, 0); /* #### logo missing */ } XFreeGC (dpy, gc); callback (screen, window, drawable, name, &geom, closure); if (name) free (name); } #endif /* HAVE_ANDROID */ /* Writes the string "Loading..." in the middle of the screen. This will presumably get blown away when the image finally loads, minutes or hours later... This is called by load_image_async_simple() but not by load_image_async(), since it is assumed that hacks that are loading more than one image *at one time* will be doing something more clever than just blocking with a blank screen. */ static void print_loading_msg (Screen *screen, Window window) { Display *dpy = DisplayOfScreen (screen); XWindowAttributes xgwa; XGCValues gcv; XFontStruct *f = 0; GC gc; char *fn = get_string_resource (dpy, "labelFont", "Font"); const char *text = "Loading..."; int w; if (!fn) fn = get_string_resource (dpy, "titleFont", "Font"); if (!fn) fn = get_string_resource (dpy, "font", "Font"); if (!fn) fn = strdup ("-*-times-bold-r-normal-*-180-*"); f = XLoadQueryFont (dpy, fn); if (!f) f = XLoadQueryFont (dpy, "fixed"); if (!f) abort(); free (fn); fn = 0; XGetWindowAttributes (dpy, window, &xgwa); w = XTextWidth (f, text, (int) strlen(text)); gcv.foreground = get_pixel_resource (dpy, xgwa.colormap, "foreground", "Foreground"); gcv.background = get_pixel_resource (dpy, xgwa.colormap, "background", "Background"); gcv.font = f->fid; gc = XCreateGC (dpy, window, GCFont | GCForeground | GCBackground, &gcv); XDrawImageString (dpy, window, gc, (xgwa.width - w) / 2, (xgwa.height - (f->ascent + f->descent)) / 2 + f->ascent, text, (int) strlen(text)); XFreeFont (dpy, f); XFreeGC (dpy, gc); XSync (dpy, False); } /* Loads an image into the Drawable in the background; when the image is fully loaded, runs the callback. When grabbing desktop images, the Window will be unmapped first. */ void load_image_async (Screen *screen, Window window, Drawable drawable, void (*callback) (Screen *, Window, Drawable, const char *name, XRectangle *geom, void *closure), void *closure) { if (!callback) abort(); # if defined(HAVE_COCOA) load_random_image_cocoa (screen, window, drawable, callback, closure); # elif defined(HAVE_ANDROID) load_random_image_android (screen, window, drawable, callback, closure); # else /* real X11 */ load_random_image_x11 (screen, window, drawable, callback, closure); # endif } struct async_load_state { Bool done_p; char *filename; XRectangle geom; }; static void load_image_async_simple_cb (Screen *screen, Window window, Drawable drawable, const char *name, XRectangle *geom, void *closure) { async_load_state *state = (async_load_state *) closure; state->done_p = True; state->filename = (name ? strdup (name) : 0); state->geom = *geom; } async_load_state * load_image_async_simple (async_load_state *state, Screen *screen, Window window, Drawable drawable, char **filename_ret, XRectangle *geometry_ret) { if (state && state->done_p) /* done! */ { if (filename_ret) *filename_ret = state->filename; else if (state->filename) free (state->filename); if (geometry_ret) *geometry_ret = state->geom; free (state); return 0; } else if (! state) /* first time */ { state = (async_load_state *) calloc (1, sizeof(*state)); state->done_p = False; print_loading_msg (screen, window); load_image_async (screen, window, drawable, load_image_async_simple_cb, state); return state; } else /* still waiting */ return state; }