xqueryptr.c: Add new program to interrogate the pointer position.

[xtoys] / xrepaint.c

/* -*-c-*-
 *
 * Redraw the screen in case it's been trashed somehow
 *
 * (c) 2016 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the Edgeware X tools collection.
 *
 * X tools is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * X tools is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with X tools; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

#include <X11/Xlib.h>

#include <mLib/alloc.h>
#include <mLib/mdwopt.h>
#include <mLib/quis.h>
#include <mLib/report.h>

/*----- Global variables --------------------------------------------------*/

static Display *dpy;

/*----- Main code ---------------------------------------------------------*/

static void version(FILE *fp)
  { pquis(fp, "$ (xtoys version " VERSION ")\n"); }

static void usage(FILE *fp)
  { pquis(fp, "Usage: $ [-as] [-d display]\n"); }

static void help(FILE *fp)
{
  version(fp);
  fputc('\n', fp);
  usage(stdout);
  fputs("\n\
Repaint the X display (or just one screen).\n\
\n\
Options:\n\
\n\
-h, --help		Display this help text\n\
-u, --usage		Display a short usage summary\n\
-v, --version		Display the program's version number\n\
\n\
-a, --all		Repaint all of the screens on the display\n\
-d, --display=DISPLAY	Choose X display to connect to\n\
-s, --screen		Only repaint the selected screen\n",
	fp);
}

static Window cover_screen(Screen *sc)
{
  /* Make, map, and return a window completely covering the screen SC. */

  Window w;
  XSetWindowAttributes attr;

  attr.background_pixel = 0;
  attr.event_mask =
    StructureNotifyMask | VisibilityChangeMask | ExposureMask |
    KeyPressMask | ButtonPressMask;
  attr.override_redirect = True;
  w = XCreateWindow(dpy, RootWindowOfScreen(sc),
		    0, 0, WidthOfScreen(sc), HeightOfScreen(sc),
		    0, CopyFromParent, InputOutput,
		    DefaultVisualOfScreen(sc),
		    CWBackPixel | CWEventMask | CWOverrideRedirect, &attr);
  XMapWindow(dpy, w);
  return (w);
}

int main(int argc, char *argv[])
{
  const char *display = 0;
  unsigned f = 0;
  struct timeval tv;
  XEvent ev;
  Window *win, w;
  int i, n;

#define f_only 1u
#define f_bogus 2u

  /* Parse command line options. */
  ego(argv[0]);
  for (;;) {
    static struct option opt[] = {
      { "help",		0,		0,	'h' },
      { "usage",	0,		0,	'u' },
      { "version",	0,		0,	'v' },
      { "all",		0,		0,	'a' },
      { "display",	OPTF_ARGREQ,	0,	'd' },
      { "screen",	0,		0,	's' },
      {	0,		0,		0,	0 }
    };
    int i = getopt_long(argc, argv, "huv" "ad:s", opt, 0);
    if (i < 0) break;
    switch (i) {
      case 'h':	help(stdout); exit(0); break;
      case 'u':	usage(stdout); exit(0);	break;
      case 'v': version(stdout); exit(0); break;
      case 'a': f &= ~f_only; break;
      case 'd': display = optarg; break;
      case 's': f |= f_only; break;
      default: f |= f_bogus; break;
    }
  }
  if (optind < argc) f |= f_bogus;
  if (f & f_bogus) { usage(stderr); exit(EXIT_FAILURE); }

  /* Open the display. */
  dpy = XOpenDisplay(display);
  if (!dpy) { die(EXIT_FAILURE, "couldn't open display"); }

  /* Annoyingly, `XClearWindow' uses `ClipByChildren' semantics, and there's
   * no way to change that.  The best idea I can come up with is to drop
   * windows over the top of each screen and take them away again.  The
   * latter part is easy because they'll disappear when we close the
   * display.
   *
   * Start by making and mapping the windows.
   */
  n = f&f_only ? 1 : ScreenCount(dpy);
  win = xmalloc(n*sizeof(Window));
  if (f&f_only)
    win[0] = cover_screen(DefaultScreenOfDisplay(dpy));
  else for (i = 0; i < n; i++)
    win[i] = cover_screen(ScreenOfDisplay(dpy, i));

  /* Now we wait until they're all obviously mapped. */
  while (n) {
    XNextEvent(dpy, &ev);
    switch (ev.type) {
      case MapNotify:
	w = ev.xmap.window; goto window_visible;
      case VisibilityNotify: case Expose: case KeyPress: case ButtonPress:
	w = ev.xany.window; goto window_visible;
      window_visible:
	for (i = 0; i < n; i++)
	  if (w == win[i]) { win[i] = win[--n]; break; }
	break;
    }
  }

  /* Finally, we must wait for a bit longer.  This is an awful hack. */
  tv.tv_sec = 0; tv.tv_usec = 50*1000;
  select(0, 0, 0, 0, &tv);

  /* All done. */
  XCloseDisplay(dpy);
  return (0);
}

/*----- That's all, folks -------------------------------------------------*/