R6.6 is the Xorg base-lineXORG-MAINXORG-STABLE

4 files changed, 1850 insertions, 0 deletions

diff --git a/dsimple.c b/dsimple.c
new file mode 100644
index 0000000..210d121
--- /dev/null
+++ b/dsimple.c
@@ -0,0 +1,523 @@
+/* $Xorg: dsimple.c,v 1.4 2001/02/09 02:05:54 xorgcvs Exp $ */
+/*
+
+Copyright 1993, 1998  The Open Group
+
+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.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#include <X11/Xos.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/cursorfont.h>
+#include <stdio.h>
+/*
+ * Other_stuff.h: Definitions of routines in other_stuff.
+ *
+ * Written by Mark Lillibridge.   Last updated 7/1/87
+ */
+
+unsigned long Resolve_Color();
+Pixmap Bitmap_To_Pixmap();
+Window Select_Window();
+void out();
+void blip();
+Window Window_With_Name();
+void Fatal_Error();
+
+/*
+ * Just_display: A group of routines designed to make the writting of simple
+ *               X11 applications which open a display but do not open
+ *               any windows much faster and easier.  Unless a routine says
+ *               otherwise, it may be assumed to require program_name, dpy,
+ *               and screen already defined on entry.
+ *
+ * Written by Mark Lillibridge.   Last updated 7/1/87
+ */
+
+
+/* This stuff is defined in the calling program by just_display.h */
+extern char *program_name;
+extern Display *dpy;
+extern int screen;
+
+
+/*
+ * Malloc: like malloc but handles out of memory using Fatal_Error.
+ */
+char *Malloc(size)
+     unsigned size;
+{
+	char *data, *malloc();
+
+	if (!(data = malloc(size)))
+	  Fatal_Error("Out of memory!");
+
+	return(data);
+}
+	
+
+/*
+ * Realloc: like Malloc except for realloc, handles NULL using Malloc.
+ */
+char *Realloc(ptr, size)
+        char *ptr;
+        int size;
+{
+	char *new_ptr, *realloc();
+
+	if (!ptr)
+	  return(Malloc(size));
+
+	if (!(new_ptr = realloc(ptr, size)))
+	  Fatal_Error("Out of memory!");
+
+	return(new_ptr);
+}
+
+
+/*
+ * Get_Display_Name (argc, argv) Look for -display, -d, or host:dpy (obselete)
+ * If found, remove it from command line.  Don't go past a lone -.
+ */
+char *Get_Display_Name(pargc, argv)
+    int *pargc;  /* MODIFIED */
+    char **argv; /* MODIFIED */
+{
+    int argc = *pargc;
+    char **pargv = argv+1;
+    char *displayname = NULL;
+    int i;
+
+    for (i = 1; i < argc; i++) {
+	char *arg = argv[i];
+
+	if (!strcmp (arg, "-display") || !strcmp (arg, "-d")) {
+	    if (++i >= argc) usage ();
+
+	    displayname = argv[i];
+	    *pargc -= 2;
+	    continue;
+	}
+	if (!strcmp(arg,"-")) {
+		while (i<argc)
+			*pargv++ = argv[i++];
+		break;
+	}
+	*pargv++ = arg;
+    }
+
+    *pargv = NULL;
+    return (displayname);
+}
+
+
+/*
+ * Open_Display: Routine to open a display with correct error handling.
+ *               Does not require dpy or screen defined on entry.
+ */
+Display *Open_Display(display_name)
+char *display_name;
+{
+	Display *d;
+
+	d = XOpenDisplay(display_name);
+	if (d == NULL) {
+	    fprintf (stderr, "%s:  unable to open display '%s'\n",
+		     program_name, XDisplayName (display_name));
+	    usage ();
+	    /* doesn't return */
+	}
+
+	return(d);
+}
+
+
+/*
+ * Setup_Display_And_Screen: This routine opens up the correct display (i.e.,
+ *                           it calls Get_Display_Name) and then stores a
+ *                           pointer to it in dpy.  The default screen
+ *                           for this display is then stored in screen.
+ *                           Does not require dpy or screen defined.
+ */
+void Setup_Display_And_Screen(argc, argv)
+int *argc;      /* MODIFIED */
+char **argv;    /* MODIFIED */
+{
+	dpy = Open_Display (Get_Display_Name(argc, argv));
+	screen = DefaultScreen(dpy);
+}
+
+
+/*
+ * Open_Font: This routine opens a font with error handling.
+ */
+XFontStruct *Open_Font(name)
+char *name;
+{
+	XFontStruct *font;
+
+	if (!(font=XLoadQueryFont(dpy, name)))
+	  Fatal_Error("Unable to open font %s!", name);
+
+	return(font);
+}
+
+
+/*
+ * Beep: Routine to beep the display.
+ */
+void Beep()
+{
+	XBell(dpy, 50);
+}
+
+
+/*
+ * ReadBitmapFile: same as XReadBitmapFile except it returns the bitmap
+ *                 directly and handles errors using Fatal_Error.
+ */
+static void _bitmap_error(status, filename)
+     int status;
+     char *filename;
+{
+  if (status == BitmapOpenFailed)
+    Fatal_Error("Can't open file %s!", filename);
+  else if (status == BitmapFileInvalid)
+    Fatal_Error("file %s: Bad bitmap format.", filename);
+  else
+    Fatal_Error("Out of memory!");
+}
+
+Pixmap ReadBitmapFile(d, filename, width, height, x_hot, y_hot)
+     Drawable d;
+     char *filename;
+     int *width, *height, *x_hot, *y_hot;
+{
+  Pixmap bitmap;
+  int status;
+
+  status = XReadBitmapFile(dpy, RootWindow(dpy, screen), filename,
+			   (unsigned int *)width, (unsigned int *)height,
+			   &bitmap, x_hot, y_hot);
+  if (status != BitmapSuccess)
+    _bitmap_error(status, filename);
+
+  return(bitmap);
+}
+
+
+/*
+ * WriteBitmapFile: same as XWriteBitmapFile except it handles errors
+ *                  using Fatal_Error.
+ */
+void WriteBitmapFile(filename, bitmap, width, height, x_hot, y_hot)
+     char *filename;
+     Pixmap bitmap;
+     int width, height, x_hot, y_hot;
+{
+  int status;
+
+  status= XWriteBitmapFile(dpy, filename, bitmap, width, height, x_hot,
+			   y_hot);
+  if (status != BitmapSuccess)
+    _bitmap_error(status, filename);
+}
+
+
+/*
+ * Select_Window_Args: a rountine to provide a common interface for
+ *                     applications that need to allow the user to select one
+ *                     window on the screen for special consideration.
+ *                     This routine implements the following command line
+ *                     arguments:
+ *
+ *                       -root            Selects the root window.
+ *                       -id <id>         Selects window with id <id>. <id> may
+ *                                        be either in decimal or hex.
+ *                       -name <name>     Selects the window with name <name>.
+ *
+ *                     Call as Select_Window_Args(&argc, argv) in main before
+ *                     parsing any of your program's command line arguments.
+ *                     Select_Window_Args will remove its arguments so that
+ *                     your program does not have to worry about them.
+ *                     The window returned is the window selected or 0 if
+ *                     none of the above arguments was present.  If 0 is
+ *                     returned, Select_Window should probably be called after
+ *                     all command line arguments, and other setup is done.
+ *                     For examples of usage, see xwininfo, xwd, or xprop.
+ */
+Window Select_Window_Args(rargc, argv)
+     int *rargc;
+     char **argv;
+#define ARGC (*rargc)
+{
+	int nargc=1;
+	int argc;
+	char **nargv;
+	Window w=0;
+
+	nargv = argv+1; argc = ARGC;
+#define OPTION argv[0]
+#define NXTOPTP ++argv, --argc>0
+#define NXTOPT if (++argv, --argc==0) usage()
+#define COPYOPT nargv++[0]=OPTION, nargc++
+
+	while (NXTOPTP) {
+		if (!strcmp(OPTION, "-")) {
+			COPYOPT;
+			while (NXTOPTP)
+			  COPYOPT;
+			break;
+		}
+		if (!strcmp(OPTION, "-root")) {
+			w=RootWindow(dpy, screen);
+			continue;
+		}
+		if (!strcmp(OPTION, "-name")) {
+			NXTOPT;
+			w = Window_With_Name(dpy, RootWindow(dpy, screen),
+					     OPTION);
+			if (!w)
+			  Fatal_Error("No window with name %s exists!",OPTION);
+			continue;
+		}
+		if (!strcmp(OPTION, "-id")) {
+			NXTOPT;
+			w=0;
+			sscanf(OPTION, "0x%lx", &w);
+			if (!w)
+			  sscanf(OPTION, "%ld", &w);
+			if (!w)
+			  Fatal_Error("Invalid window id format: %s.", OPTION);
+			continue;
+		}
+		COPYOPT;
+	}
+	ARGC = nargc;
+	
+	return(w);
+}
+
+/*
+ * Other_stuff: A group of routines which do common X11 tasks.
+ *
+ * Written by Mark Lillibridge.   Last updated 7/1/87
+ */
+
+extern Display *dpy;
+extern int screen;
+
+/*
+ * Resolve_Color: This routine takes a color name and returns the pixel #
+ *                that when used in the window w will be of color name.
+ *                (WARNING:  The colormap of w MAY be modified! )
+ *                If colors are run out of, only the first n colors will be
+ *                as correct as the hardware can make them where n depends
+ *                on the display.  This routine does not require wind to
+ *                be defined.
+ */
+unsigned long Resolve_Color(w, name)
+     Window w;
+     char *name;
+{
+	XColor c;
+	Colormap colormap;
+	XWindowAttributes wind_info;
+
+	/*
+	 * The following is a hack to insure machines without a rgb table
+	 * handle at least white & black right.
+	 */
+	if (!strcmp(name, "white"))
+	  name="#ffffffffffff";
+	if (!strcmp(name, "black"))
+	  name="#000000000000";
+
+	XGetWindowAttributes(dpy, w, &wind_info);
+	colormap = wind_info.colormap;
+
+	if (!XParseColor(dpy, colormap, name, &c))
+	  Fatal_Error("Bad color format '%s'.", name);
+
+	if (!XAllocColor(dpy, colormap, &c))
+	  Fatal_Error("XAllocColor failed!");
+
+	return(c.pixel);
+}
+
+
+/*
+ * Bitmap_To_Pixmap: Convert a bitmap to a 2 colored pixmap.  The colors come
+ *                   from the foreground and background colors of the gc.
+ *                   Width and height are required solely for efficiency.
+ *                   If needed, they can be obtained via. XGetGeometry.
+ */
+Pixmap Bitmap_To_Pixmap(dpy, d, gc, bitmap, width, height)
+     Display *dpy;
+     Drawable d;
+     GC gc;
+     Pixmap bitmap;
+     int width, height;
+{
+  Pixmap pix;
+  int x;
+  unsigned int i, depth;
+  Drawable root;
+
+  if (!XGetGeometry(dpy, d, &root, &x, &x, &i, &i, &i, &depth))
+    return(0);
+
+  pix = XCreatePixmap(dpy, d, width, height, (int)depth);
+
+  XCopyPlane(dpy, bitmap, pix, gc, 0, 0, width, height, 0, 0, 1);
+
+  return(pix);
+}
+
+
+/*
+ * blip: a debugging routine.  Prints Blip! on stderr with flushing. 
+ */
+void blip()
+{
+  outl("blip!");
+}
+
+
+/*
+ * Routine to let user select a window using the mouse
+ */
+
+Window Select_Window(dpy)
+     Display *dpy;
+{
+  int status;
+  Cursor cursor;
+  XEvent event;
+  Window target_win = None, root = RootWindow(dpy,screen);
+  int buttons = 0;
+
+  /* Make the target cursor */
+  cursor = XCreateFontCursor(dpy, XC_crosshair);
+
+  /* Grab the pointer using target cursor, letting it room all over */
+  status = XGrabPointer(dpy, root, False,
+			ButtonPressMask|ButtonReleaseMask, GrabModeSync,
+			GrabModeAsync, root, cursor, CurrentTime);
+  if (status != GrabSuccess) Fatal_Error("Can't grab the mouse.");
+
+  /* Let the user select a window... */
+  while ((target_win == None) || (buttons != 0)) {
+    /* allow one more event */
+    XAllowEvents(dpy, SyncPointer, CurrentTime);
+    XWindowEvent(dpy, root, ButtonPressMask|ButtonReleaseMask, &event);
+    switch (event.type) {
+    case ButtonPress:
+      if (target_win == None) {
+	target_win = event.xbutton.subwindow; /* window selected */
+	if (target_win == None) target_win = root;
+      }
+      buttons++;
+      break;
+    case ButtonRelease:
+      if (buttons > 0) /* there may have been some down before we started */
+	buttons--;
+       break;
+    }
+  } 
+
+  XUngrabPointer(dpy, CurrentTime);      /* Done with pointer */
+
+  return(target_win);
+}
+
+
+/*
+ * Window_With_Name: routine to locate a window with a given name on a display.
+ *                   If no window with the given name is found, 0 is returned.
+ *                   If more than one window has the given name, the first
+ *                   one found will be returned.  Only top and its subwindows
+ *                   are looked at.  Normally, top should be the RootWindow.
+ */
+Window Window_With_Name(dpy, top, name)
+     Display *dpy;
+     Window top;
+     char *name;
+{
+	Window *children, dummy;
+	unsigned int nchildren;
+	int i;
+	Window w=0;
+	char *window_name;
+
+	if (XFetchName(dpy, top, &window_name) && !strcmp(window_name, name))
+	  return(top);
+
+	if (!XQueryTree(dpy, top, &dummy, &dummy, &children, &nchildren))
+	  return(0);
+
+	for (i=0; i<nchildren; i++) {
+		w = Window_With_Name(dpy, children[i], name);
+		if (w)
+		  break;
+	}
+	if (children) XFree ((char *)children);
+	return(w);
+}
+
+/*
+ * outl: a debugging routine.  Flushes stdout then prints a message on stderr
+ *       and flushes stderr.  Used to print messages when past certain points
+ *       in code so we can tell where we are.  Outl may be invoked like
+ *       printf with up to 7 arguments.
+ */
+/* VARARGS1 */
+outl(msg, arg0,arg1,arg2,arg3,arg4,arg5,arg6)
+     char *msg;
+     char *arg0, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6;
+{
+	fflush(stdout);
+	fprintf(stderr, msg, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+	fprintf(stderr, "\n");
+	fflush(stderr);
+}
+
+
+/*
+ * Standard fatal error routine - call like printf but maximum of 7 arguments.
+ * Does not require dpy or screen defined.
+ */
+/* VARARGS1 */
+void Fatal_Error(msg, arg0,arg1,arg2,arg3,arg4,arg5,arg6)
+char *msg;
+char *arg0, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6;
+{
+	fflush(stdout);
+	fflush(stderr);
+	fprintf(stderr, "%s: error: ", program_name);
+	fprintf(stderr, msg, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+	fprintf(stderr, "\n");
+	exit(1);
+}
diff --git a/dsimple.h b/dsimple.h
new file mode 100644
index 0000000..a634848
--- /dev/null
+++ b/dsimple.h
@@ -0,0 +1,81 @@
+/* $Xorg: dsimple.h,v 1.4 2001/02/09 02:05:54 xorgcvs Exp $ */
+/*
+
+Copyright 1993, 1998  The Open Group
+
+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.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+/*
+ * Just_display.h: This file contains the definitions needed to use the
+ *                 functions in just_display.c.  It also declares the global
+ *                 variables dpy, screen, and program_name which are needed to
+ *                 use just_display.c.
+ *
+ * Written by Mark Lillibridge.   Last updated 7/1/87
+ *
+ * Send bugs, etc. to chariot@athena.mit.edu.
+ */
+
+    /* Global variables used by routines in just_display.c */
+
+char *program_name = "unknown_program";       /* Name of this program */
+Display *dpy;                                 /* The current display */
+int screen;                                   /* The current screen */
+
+#define INIT_NAME program_name=argv[0]        /* use this in main to setup
+                                                 program_name */
+
+    /* Declaritions for functions in just_display.c */
+
+void Fatal_Error();
+char *Malloc();
+char *Realloc();
+char *Get_Display_Name();
+Display *Open_Display();
+void Setup_Display_And_Screen();
+XFontStruct *Open_Font();
+void Beep();
+Pixmap ReadBitmapFile();
+void WriteBitmapFile();
+Window Select_Window_Args();
+
+#define X_USAGE "[host:display]"              /* X arguments handled by
+						 Get_Display_Name */
+#define SELECT_USAGE "[{-root|-id <id>|-font <font>|-name <name>}]"
+
+/*
+ * Other_stuff.h: Definitions of routines in other_stuff.
+ *
+ * Written by Mark Lillibridge.   Last updated 7/1/87
+ *
+ * Send bugs, etc. to chariot@athena.mit.edu.
+ */
+
+unsigned long Resolve_Color();
+Pixmap Bitmap_To_Pixmap();
+Window Select_Window();
+void out();
+void blip();
+Window Window_With_Name();
diff --git a/xwininfo.c b/xwininfo.c
new file mode 100644
index 0000000..1e9d6fb
--- /dev/null
+++ b/xwininfo.c
@@ -0,0 +1,1049 @@
+/* $Xorg: xwininfo.c,v 1.4 2001/02/09 02:06:04 xorgcvs Exp $ */
+/*
+
+Copyright 1987, 1998  The Open Group
+
+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.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+
+/*
+ * xwininfo.c	- MIT Project Athena, X Window system window
+ *		  information utility.
+ *
+ *
+ *	This program will report all relevant information
+ *	about a specific window.
+ *
+ *  Author:	Mark Lillibridge, MIT Project Athena
+ *		16-Jun-87
+ */
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/Xos.h>
+#include <X11/extensions/shape.h>
+#include <X11/Xmu/WinUtil.h>
+#include <stdio.h>
+
+/* Include routines to handle parsing defaults */
+#include "dsimple.h"
+
+static char *window_id_format = "0x%lx";
+
+/*
+ * Report the syntax for calling xwininfo:
+ */
+usage()
+{
+    fprintf (stderr,
+	"usage:  %s [-options ...]\n\n", program_name);
+    fprintf (stderr,
+	"where options include:\n");
+    fprintf (stderr,
+	"    -help                print this message\n");
+    fprintf (stderr,
+	"    -display host:dpy    X server to contact\n");
+    fprintf (stderr,
+	"    -root                use the root window\n");
+    fprintf (stderr,
+	"    -id windowid         use the window with the specified id\n");
+    fprintf (stderr,
+	"    -name windowname     use the window with the specified name\n");
+    fprintf (stderr,
+	"    -int                 print window id in decimal\n");
+    fprintf (stderr,
+	"    -children            print parent and child identifiers\n");
+    fprintf (stderr,
+	"    -tree                print children identifiers recursively\n");
+    fprintf (stderr,
+	"    -stats               print window geometry [DEFAULT]\n");
+    fprintf (stderr,
+	"    -bits                print window pixel information\n");
+    fprintf (stderr,
+	"    -events              print events selected for on window\n");
+    fprintf (stderr,
+	"    -size                print size hints\n");
+    fprintf (stderr,
+	"    -wm                  print window manager hints\n");
+    fprintf (stderr,
+	"    -shape               print shape extents\n");
+    fprintf (stderr,
+	"    -frame               don't ignore window manager frames\n");
+    fprintf (stderr,
+	"    -english             print sizes in english units\n");
+    fprintf (stderr,
+	"    -metric              print sizes in metric units\n");
+    fprintf (stderr,
+	"    -all                 -tree, -stats, -bits, -events, -wm, -size, -shape\n");
+    fprintf (stderr,
+	"\n");
+    exit (1);
+}
+
+/*
+ * pixel to inch, metric converter.
+ * Hacked in by Mark W. Eichin <eichin@athena> [eichin:19880619.1509EST]
+ *
+ * Simply put: replace the old numbers with string print calls.
+ * Returning a local string is ok, since we only ever get called to
+ * print one x and one y, so as long as they don't collide, they're
+ * fine. This is not meant to be a general purpose routine.
+ *
+ */
+
+#define getdsp(var,fn) var = fn(dpy, DefaultScreen(dpy))
+int xp=0, xmm=0;
+int yp=0, ymm=0;
+int bp=0, bmm=0;
+int english = 0, metric = 0;
+
+void scale_init()
+{
+  getdsp(yp,  DisplayHeight);
+  getdsp(ymm, DisplayHeightMM);
+  getdsp(xp,  DisplayWidth);
+  getdsp(xmm, DisplayWidthMM);
+  bp  = xp  + yp;
+  bmm = xmm + ymm;
+}
+
+#define MILE (5280*12)
+#define YARD (3*12)
+#define FOOT (12)
+
+char *nscale(n, np, nmm, nbuf)
+     int n, np, nmm;
+     char *nbuf;
+{
+  sprintf(nbuf, "%d", n);
+  if(metric||english) {
+    sprintf(nbuf+strlen(nbuf), " (");
+  }
+  if(metric) {
+    sprintf(nbuf+strlen(nbuf),"%.2f mm%s", ((double) n)*nmm/np, english?"; ":"");
+  }
+  if(english) {
+    double inch_frac;
+    Bool printed_anything = False;
+    int mi, yar, ft, inr;
+
+    inch_frac = ((double) n)*(nmm/25.4)/np;
+    inr = (int)inch_frac;
+    inch_frac -= (double)inr;
+    if(inr>=MILE) {
+      mi = inr/MILE;
+      inr %= MILE;
+      sprintf(nbuf+strlen(nbuf), "%d %s(?!?)",
+	      mi, (mi==1)?"mile":"miles");
+      printed_anything = True;
+    }
+    if(inr>=YARD) {
+      yar = inr/YARD;
+      inr %= YARD;
+      if (printed_anything)
+	  sprintf(nbuf+strlen(nbuf), ", ");
+      sprintf(nbuf+strlen(nbuf), "%d %s",
+	      yar, (yar==1)?"yard":"yards");
+      printed_anything = True;
+    }
+    if(inr>=FOOT) {
+      ft = inr/FOOT;
+      inr  %= FOOT;
+      if (printed_anything)
+	  sprintf(nbuf+strlen(nbuf), ", ");
+      sprintf(nbuf+strlen(nbuf), "%d %s",
+	      ft, (ft==1)?"foot":"feet");
+      printed_anything = True;
+    }
+    if (!printed_anything || inch_frac != 0.0 || inr != 0) {
+      if (printed_anything)
+	  sprintf(nbuf+strlen(nbuf), ", ");
+      sprintf(nbuf+strlen(nbuf), "%.2f inches", inr+inch_frac);
+    }
+  }
+  if (english || metric) strcat (nbuf, ")");
+  return(nbuf);
+}	  
+  
+char xbuf[BUFSIZ];
+char *xscale(x)
+     int x;
+{
+  if(!xp) {
+    scale_init();
+  }
+  return(nscale(x, xp, xmm, xbuf));
+}
+
+char ybuf[BUFSIZ];
+char *yscale(y)
+     int y;
+{
+  if(!yp) {
+    scale_init();
+  }
+  return(nscale(y, yp, ymm, ybuf));
+}
+
+char bbuf[BUFSIZ];
+char *bscale(b)
+     int b;
+{
+  if(!bp) {
+    scale_init();
+  }
+  return(nscale(b, bp, bmm, bbuf));
+}
+
+/* end of pixel to inch, metric converter */
+
+/* This handler is enabled when we are checking
+   to see if the -id the user specified is valid. */
+
+/* ARGSUSED */
+bad_window_handler(disp, err)
+    Display *disp;
+    XErrorEvent *err;
+{
+    char badid[20];
+
+    sprintf(badid, window_id_format, err->resourceid);
+    Fatal_Error("No such window with id %s.", badid);
+    exit (1);
+}
+
+
+main(argc, argv)
+     int argc;
+     char **argv;
+{
+  register int i;
+  int tree = 0, stats = 0, bits = 0, events = 0, wm = 0, size  = 0, shape = 0;
+  int frame = 0, children = 0;
+  Window window;
+
+  INIT_NAME;
+
+  /* Open display, handle command line arguments */
+  Setup_Display_And_Screen(&argc, argv);
+
+  /* Get window selected on command line, if any */
+  window = Select_Window_Args(&argc, argv);
+
+  /* Handle our command line arguments */
+  for (i = 1; i < argc; i++) {
+    if (!strcmp(argv[i], "-help"))
+      usage();
+    if (!strcmp(argv[i], "-int")) {
+      window_id_format = "%ld";
+      continue;
+    }
+    if (!strcmp(argv[i], "-children")) {
+      children = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-tree")) {
+      tree = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-stats")) {
+      stats = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-bits")) {
+      bits = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-events")) {
+      events = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-wm")) {
+      wm = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-frame")) {
+      frame = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-size")) {
+      size = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-shape")) {
+      shape = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-english")) {
+      english = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-metric")) {
+      metric = 1;
+      continue;
+    }
+    if (!strcmp(argv[i], "-all")) {
+      tree = stats = bits = events = wm = size = shape = 1;
+      continue;
+    }
+    usage();
+  }
+
+  /* If no window selected on command line, let user pick one the hard way */
+  if (!window) {
+	  printf("\n");
+	  printf("xwininfo: Please select the window about which you\n");
+	  printf("          would like information by clicking the\n");
+	  printf("          mouse in that window.\n");
+	  window = Select_Window(dpy);
+	  if (window && !frame) {
+	      Window root;
+	      int dummyi;
+	      unsigned int dummy;
+
+	      if (XGetGeometry (dpy, window, &root, &dummyi, &dummyi,
+				&dummy, &dummy, &dummy, &dummy) &&
+		  window != root)
+	        window = XmuClientWindow (dpy, window);
+	  }
+  }
+
+  /*
+   * Do the actual displaying as per parameters
+   */
+  if (!(children || tree || bits || events || wm || size))
+    stats = 1;
+
+  /*
+   * make sure that the window is valid
+   */
+  {
+    Window root;
+    int x, y;
+    unsigned width, height, bw, depth;
+    int (*old_handler)();
+
+    old_handler = XSetErrorHandler(bad_window_handler);
+    XGetGeometry (dpy, window, &root, &x, &y, &width, &height, &bw, &depth);
+    XSync (dpy, False);
+    (void) XSetErrorHandler(old_handler);
+  }
+
+  printf("\nxwininfo: Window id: ");
+  Display_Window_Id(window, True);
+  if (children || tree)
+    Display_Tree_Info(window, tree);
+  if (stats)
+    Display_Stats_Info(window);
+  if (bits)
+    Display_Bits_Info(window);
+  if (events)
+    Display_Events_Info(window);
+  if (wm)
+    Display_WM_Info(window);
+  if (size)
+    Display_Size_Hints(window);
+  if (shape)
+    Display_Window_Shape(window);
+  printf("\n");
+  exit(0);
+}
+
+
+/*
+ * Lookup: lookup a code in a table.
+ */
+typedef struct {
+	long code;
+	char *name;
+} binding;
+
+static char _lookup_buffer[100];
+
+char *LookupL(code, table)
+    long code;
+    binding *table;
+{
+	char *name;
+
+	sprintf(_lookup_buffer, "unknown (code = %ld. = 0x%lx)", code, code);
+	name = _lookup_buffer;
+
+	while (table->name) {
+		if (table->code == code) {
+			name = table->name;
+			break;
+		}
+		table++;
+	}
+
+	return(name);
+}
+
+char *Lookup(code, table)
+    int code;
+    binding *table;
+{
+    return LookupL((long)code, table);
+}
+
+/*
+ * Routine to display a window id in dec/hex with name if window has one
+ */
+
+Display_Window_Id(window, newline_wanted)
+    Window window;
+    Bool newline_wanted;
+{
+    char *win_name;
+    
+    printf(window_id_format, window);         /* print id # in hex/dec */
+
+    if (!window) {
+	printf(" (none)");
+    } else {
+	if (window == RootWindow(dpy, screen)) {
+	    printf(" (the root window)");
+	}
+	if (!XFetchName(dpy, window, &win_name)) { /* Get window name if any */
+	    printf(" (has no name)");
+	} else if (win_name) {
+	    printf(" \"%s\"", win_name);
+	    XFree(win_name);
+	} else
+	    printf(" (has no name)");
+    }
+
+    if (newline_wanted)
+	printf("\n");
+
+    return;
+}
+
+
+/*
+ * Display Stats on window
+ */
+static binding _window_classes[] = {
+	{ InputOutput, "InputOutput" },
+	{ InputOnly, "InputOnly" },
+        { 0, 0 } };
+
+static binding _map_states[] = {
+	{ IsUnmapped, "IsUnMapped" },
+	{ IsUnviewable, "IsUnviewable" },
+	{ IsViewable, "IsViewable" },
+	{ 0, 0 } };
+
+static binding _backing_store_states[] = {
+	{ NotUseful, "NotUseful" },
+	{ WhenMapped, "WhenMapped" },
+	{ Always, "Always" },
+	{ 0, 0 } };
+
+static binding _bit_gravity_states[] = {
+	{ ForgetGravity, "ForgetGravity" },
+	{ NorthWestGravity, "NorthWestGravity" },
+	{ NorthGravity, "NorthGravity" },
+	{ NorthEastGravity, "NorthEastGravity" },
+	{ WestGravity, "WestGravity" },
+	{ CenterGravity, "CenterGravity" },
+	{ EastGravity, "EastGravity" },
+	{ SouthWestGravity, "SouthWestGravity" },
+	{ SouthGravity, "SouthGravity" },
+	{ SouthEastGravity, "SouthEastGravity" },
+	{ StaticGravity, "StaticGravity" },
+	{ 0, 0 }};
+
+static binding _window_gravity_states[] = {
+	{ UnmapGravity, "UnmapGravity" },
+	{ NorthWestGravity, "NorthWestGravity" },
+	{ NorthGravity, "NorthGravity" },
+	{ NorthEastGravity, "NorthEastGravity" },
+	{ WestGravity, "WestGravity" },
+	{ CenterGravity, "CenterGravity" },
+	{ EastGravity, "EastGravity" },
+	{ SouthWestGravity, "SouthWestGravity" },
+	{ SouthGravity, "SouthGravity" },
+	{ SouthEastGravity, "SouthEastGravity" },
+	{ StaticGravity, "StaticGravity" },
+	{ 0, 0 }};
+
+static binding _visual_classes[] = {
+	{ StaticGray, "StaticGray" },
+	{ GrayScale, "GrayScale" },
+	{ StaticColor, "StaticColor" },
+	{ PseudoColor, "PseudoColor" },
+	{ TrueColor, "TrueColor" },
+	{ DirectColor, "DirectColor" },
+	{ 0, 0 }};
+
+Display_Stats_Info(window)
+     Window window;
+{
+  XWindowAttributes win_attributes;
+  XVisualInfo vistemplate, *vinfo;
+  XSizeHints hints;
+  int dw = DisplayWidth (dpy, screen), dh = DisplayHeight (dpy, screen);
+  int rx, ry, xright, ybelow;
+  int showright = 0, showbelow = 0;
+  Status status;
+  Window wmframe;
+  int junk;
+  long longjunk;
+  Window junkwin;
+
+  if (!XGetWindowAttributes(dpy, window, &win_attributes))
+    Fatal_Error("Can't get window attributes.");
+  vistemplate.visualid = XVisualIDFromVisual(win_attributes.visual);
+  vinfo = XGetVisualInfo(dpy, VisualIDMask, &vistemplate, &junk);
+
+  (void) XTranslateCoordinates (dpy, window, win_attributes.root, 
+				-win_attributes.border_width,
+				-win_attributes.border_width,
+				&rx, &ry, &junkwin);
+				
+  xright = (dw - rx - win_attributes.border_width * 2 -
+	    win_attributes.width);
+  ybelow = (dh - ry - win_attributes.border_width * 2 -
+	    win_attributes.height);
+
+  printf("\n");
+  printf("  Absolute upper-left X:  %s\n", xscale(rx));
+  printf("  Absolute upper-left Y:  %s\n", yscale(ry));
+  printf("  Relative upper-left X:  %s\n", xscale(win_attributes.x));
+  printf("  Relative upper-left Y:  %s\n", yscale(win_attributes.y));
+  printf("  Width: %s\n", xscale(win_attributes.width));
+  printf("  Height: %s\n", yscale(win_attributes.height));
+  printf("  Depth: %d\n", win_attributes.depth);
+  printf("  Visual Class: %s\n", Lookup(vinfo->class, _visual_classes));
+  printf("  Border width: %s\n", bscale(win_attributes.border_width));
+  printf("  Class: %s\n",
+  	 Lookup(win_attributes.class, _window_classes));
+  printf("  Colormap: 0x%lx (%sinstalled)\n", 
+	 win_attributes.colormap, win_attributes.map_installed ? "" : "not ");
+  printf("  Bit Gravity State: %s\n",
+  	 Lookup(win_attributes.bit_gravity, _bit_gravity_states));
+  printf("  Window Gravity State: %s\n",
+  	 Lookup(win_attributes.win_gravity, _window_gravity_states));
+  printf("  Backing Store State: %s\n",
+  	 Lookup(win_attributes.backing_store, _backing_store_states));
+  printf("  Save Under State: %s\n",
+  	 win_attributes.save_under ? "yes" : "no");
+  printf("  Map State: %s\n",
+	 Lookup(win_attributes.map_state, _map_states));
+  printf("  Override Redirect State: %s\n",
+  	 win_attributes.override_redirect ? "yes" : "no");
+  printf("  Corners:  +%d+%d  -%d+%d  -%d-%d  +%d-%d\n",
+	 rx, ry, xright, ry, xright, ybelow, rx, ybelow);
+
+  /*
+   * compute geometry string that would recreate window
+   */
+  printf("  -geometry ");
+
+  /* compute size in appropriate units */
+  status = XGetWMNormalHints(dpy, window, &hints, &longjunk);
+  if (status  &&  hints.flags & PResizeInc  &&
+              hints.width_inc != 0  &&  hints.height_inc != 0) {
+      if (hints.flags & (PBaseSize|PMinSize)) {
+	  if (hints.flags & PBaseSize) {
+	      win_attributes.width -= hints.base_width;
+	      win_attributes.height -= hints.base_height;
+	  } else {
+	      /* ICCCM says MinSize is default for BaseSize */
+	      win_attributes.width -= hints.min_width;
+	      win_attributes.height -= hints.min_height;
+	  }
+      }
+      printf("%dx%d", win_attributes.width/hints.width_inc,
+	     win_attributes.height/hints.height_inc);
+  } else
+      printf("%dx%d", win_attributes.width, win_attributes.height);
+
+  if (!(hints.flags&PWinGravity))
+      hints.win_gravity = NorthWestGravity; /* per ICCCM */
+  /* find our window manager frame, if any */
+  wmframe = window;
+  while (True) {
+      Window root, parent;
+      Window *childlist;
+      unsigned int ujunk;
+
+      status = XQueryTree(dpy, wmframe, &root, &parent, &childlist, &ujunk);
+      if (parent == root || !parent || !status)
+	  break;
+      wmframe = parent;
+      if (status && childlist)
+	  XFree((char *)childlist);
+  }
+  if (wmframe != window) {
+      /* WM reparented, so find edges of the frame */
+      /* Only works for ICCCM-compliant WMs, and then only if the
+         window has corner gravity.  We would need to know the original width
+	 of the window to correctly handle the other gravities. */
+
+      XWindowAttributes frame_attr;
+
+      if (!XGetWindowAttributes(dpy, wmframe, &frame_attr))
+	  Fatal_Error("Can't get frame attributes.");
+      switch (hints.win_gravity) {
+	case NorthWestGravity: case SouthWestGravity:
+	case NorthEastGravity: case SouthEastGravity:
+	case WestGravity:
+	  rx = frame_attr.x;
+      }
+      switch (hints.win_gravity) {
+	case NorthWestGravity: case SouthWestGravity:
+	case NorthEastGravity: case SouthEastGravity:
+	case EastGravity:
+	  xright = dw - frame_attr.x - frame_attr.width -
+	      2*frame_attr.border_width;
+      }
+      switch (hints.win_gravity) {
+	case NorthWestGravity: case SouthWestGravity:
+	case NorthEastGravity: case SouthEastGravity:
+	case NorthGravity:
+	  ry = frame_attr.y;
+      }
+      switch (hints.win_gravity) {
+	case NorthWestGravity: case SouthWestGravity:
+	case NorthEastGravity: case SouthEastGravity:
+	case SouthGravity:
+	  ybelow = dh - frame_attr.y - frame_attr.height -
+	      2*frame_attr.border_width;
+      }
+  }
+  /* If edge gravity, offer a corner on that edge (because the application
+     programmer cares about that edge), otherwise offer upper left unless
+     some other corner is close to an edge of the screen.
+     (For corner gravity, assume gravity was set by XWMGeometry.
+     For CenterGravity, it doesn't matter.) */
+  if (hints.win_gravity == EastGravity  ||
+      (abs(xright) <= 100  &&  abs(xright) < abs(rx)
+        &&  hints.win_gravity != WestGravity))
+      showright = 1;
+  if (hints.win_gravity == SouthGravity  ||
+      (abs(ybelow) <= 100  &&  abs(ybelow) < abs(ry)
+        &&  hints.win_gravity != NorthGravity))
+      showbelow = 1;
+  
+  if (showright)
+      printf("-%d", xright);
+  else
+      printf("+%d", rx);
+  if (showbelow)
+      printf("-%d", ybelow);
+  else
+      printf("+%d", ry);
+  printf("\n");
+}
+
+
+/*
+ * Display bits info:
+ */
+static binding _gravities[] = {
+	{ UnmapGravity, "UnMapGravity" },      /* WARNING: both of these have*/
+	{ ForgetGravity, "ForgetGravity" },    /* the same value - see code */
+	{ NorthWestGravity, "NorthWestGravity" },
+	{ NorthGravity, "NorthGravity" },
+	{ NorthEastGravity, "NorthEastGravity" },
+	{ WestGravity, "WestGravity" },
+	{ CenterGravity, "CenterGravity" },
+	{ EastGravity, "EastGravity" },
+	{ SouthWestGravity, "SouthWestGravity" },
+	{ SouthGravity, "SouthGravity" },
+	{ SouthEastGravity, "SouthEastGravity" },
+	{ StaticGravity, "StaticGravity" },
+	{ 0, 0 } };
+
+static binding _backing_store_hint[] = {
+	{ NotUseful, "NotUseful" },
+	{ WhenMapped, "WhenMapped" },
+	{ Always, "Always" },
+	{ 0, 0 } };
+
+static binding _bool[] = {
+	{ 0, "No" },
+	{ 1, "Yes" },
+	{ 0, 0 } };
+
+Display_Bits_Info(window)
+     Window window;
+{
+  XWindowAttributes win_attributes;
+
+  if (!XGetWindowAttributes(dpy, window, &win_attributes))
+    Fatal_Error("Can't get window attributes.");
+
+  printf("\n");
+  printf("  Bit gravity: %s\n",
+	 Lookup(win_attributes.bit_gravity, _gravities+1));
+  printf("  Window gravity: %s\n",
+	 Lookup(win_attributes.win_gravity, _gravities));
+  printf("  Backing-store hint: %s\n",
+	 Lookup(win_attributes.backing_store, _backing_store_hint));
+  printf("  Backing-planes to be preserved: 0x%x\n",
+	 win_attributes.backing_planes);
+  printf("  Backing pixel: %d\n", win_attributes.backing_pixel);
+  printf("  Save-unders: %s\n",
+	 Lookup(win_attributes.save_under, _bool));
+}
+
+
+/*
+ * Routine to display all events in an event mask
+ */
+static binding _event_mask_names[] = {
+	{ KeyPressMask, "KeyPress" },
+	{ KeyReleaseMask, "KeyRelease" },
+	{ ButtonPressMask, "ButtonPress" },
+	{ ButtonReleaseMask, "ButtonRelease" },
+	{ EnterWindowMask, "EnterWindow" },
+	{ LeaveWindowMask, "LeaveWindow" },
+	{ PointerMotionMask, "PointerMotion" },
+	{ PointerMotionHintMask, "PointerMotionHint" },
+	{ Button1MotionMask, "Button1Motion" },
+	{ Button2MotionMask, "Button2Motion" },
+	{ Button3MotionMask, "Button3Motion" },
+	{ Button4MotionMask, "Button4Motion" },
+	{ Button5MotionMask, "Button5Motion" },
+	{ ButtonMotionMask, "ButtonMotion" },
+	{ KeymapStateMask, "KeymapState" },
+	{ ExposureMask, "Exposure" },
+	{ VisibilityChangeMask, "VisibilityChange" },
+	{ StructureNotifyMask, "StructureNotify" },
+	{ ResizeRedirectMask, "ResizeRedirect" },
+	{ SubstructureNotifyMask, "SubstructureNotify" },
+	{ SubstructureRedirectMask, "SubstructureRedirect" },
+	{ FocusChangeMask, "FocusChange" },
+	{ PropertyChangeMask, "PropertyChange" },
+	{ ColormapChangeMask, "ColormapChange" },
+	{ OwnerGrabButtonMask, "OwnerGrabButton" },
+	{ 0, 0 } };
+
+Display_Event_Mask(mask)
+     long mask;
+{
+  long bit, bit_mask;
+
+  for (bit=0, bit_mask=1; bit<sizeof(long)*8; bit++, bit_mask <<= 1)
+    if (mask & bit_mask)
+      printf("      %s\n",
+	     LookupL(bit_mask, _event_mask_names));
+}
+
+
+/*
+ * Display info on events
+ */
+Display_Events_Info(window)
+     Window window;
+{
+  XWindowAttributes win_attributes;
+
+  if (!XGetWindowAttributes(dpy, window, &win_attributes))
+    Fatal_Error("Can't get window attributes.");
+
+  printf("\n");
+  printf("  Someone wants these events:\n");
+  Display_Event_Mask(win_attributes.all_event_masks);
+
+  printf("  Do not propagate these events:\n");
+  Display_Event_Mask(win_attributes.do_not_propagate_mask);
+
+  printf("  Override redirection?: %s\n",
+	 Lookup(win_attributes.override_redirect, _bool));
+}
+
+
+  /* left out visual stuff */
+  /* left out colormap */
+  /* left out map_installed */
+
+
+/*
+ * Display root, parent, and (recursively) children information
+ */
+Display_Tree_Info(window, recurse)
+     Window window;
+     int recurse;		/* true if should show children's children */
+{
+    display_tree_info_1(window, recurse, 0);
+}
+
+display_tree_info_1(window, recurse, level)
+     Window window;
+     int recurse;
+     int level;			/* recursion level */
+{
+  int i, j;
+  int rel_x, rel_y, abs_x, abs_y;
+  unsigned int width, height, border, depth;
+  Window root_win, parent_win;
+  unsigned int num_children;
+  Window *child_list;
+  XClassHint classhint;
+
+  if (!XQueryTree(dpy, window, &root_win, &parent_win, &child_list,
+		  &num_children))
+    Fatal_Error("Can't query window tree.");
+
+  if (level == 0) {
+    printf("\n");
+    printf("  Root window id: ");
+    Display_Window_Id(root_win, True);
+    printf("  Parent window id: ");
+    Display_Window_Id(parent_win, True);
+  }
+
+  if (level == 0  ||  num_children > 0) {
+    printf("     ");
+    for (j=0; j<level; j++) printf("   ");
+    printf("%d child%s%s\n", num_children, num_children == 1 ? "" : "ren",
+	   num_children ? ":" : ".");
+  }
+
+  for (i = (int)num_children - 1; i >= 0; i--) {
+    printf("     ");
+    for (j=0; j<level; j++) printf("   ");
+    Display_Window_Id(child_list[i], False);
+    printf(": (");
+    if(XGetClassHint(dpy, child_list[i], &classhint)) {
+	if(classhint.res_name) {
+	    printf("\"%s\" ", classhint.res_name);
+	    XFree(classhint.res_name);
+	} else
+	    printf("(none) ");
+	if(classhint.res_class) {
+	    printf("\"%s\") ", classhint.res_class);
+	    XFree(classhint.res_class);
+	} else
+	    printf("(none)) ");
+    } else
+	printf(") ");
+
+    if (XGetGeometry(dpy, child_list[i], &root_win,
+		     &rel_x, &rel_y, &width, &height, &border, &depth)) {
+	Window child;
+
+	printf (" %ux%u+%d+%d", width, height, rel_x, rel_y);
+	if (XTranslateCoordinates (dpy, child_list[i], root_win,
+				   0 ,0, &abs_x, &abs_y, &child)) {
+	    printf ("  +%d+%d", abs_x - border, abs_y - border);
+	}
+    }
+    printf("\n");
+    
+    if (recurse)
+	display_tree_info_1(child_list[i], 1, level+1);
+  }
+
+  if (child_list) XFree((char *)child_list);
+}
+
+
+/*
+ * Display a set of size hints
+ */
+Display_Hints(hints)
+     XSizeHints *hints;
+{
+	long flags;
+
+	flags = hints->flags;
+	
+	if (flags & USPosition)
+	  printf("      User supplied location: %s, %s\n",
+		 xscale(hints->x), yscale(hints->y));
+
+	if (flags & PPosition)
+	  printf("      Program supplied location: %s, %s\n",
+		 xscale(hints->x), yscale(hints->y));
+
+	if (flags & USSize) {
+	  printf("      User supplied size: %s by %s\n",
+		 xscale(hints->width), yscale(hints->height));
+	}
+
+	if (flags & PSize)
+	  printf("      Program supplied size: %s by %s\n",
+		 xscale(hints->width), yscale(hints->height));
+
+	if (flags & PMinSize)
+	  printf("      Program supplied minimum size: %s by %s\n",
+		 xscale(hints->min_width), yscale(hints->min_height));
+
+	if (flags & PMaxSize)
+	  printf("      Program supplied maximum size: %s by %s\n",
+		 xscale(hints->max_width), yscale(hints->max_height));
+
+	if (flags & PBaseSize) {
+	  printf("      Program supplied base size: %s by %s\n",
+		 xscale(hints->base_width), yscale(hints->base_height));
+	}
+
+	if (flags & PResizeInc) {
+	  printf("      Program supplied x resize increment: %s\n",
+		 xscale(hints->width_inc));
+	  printf("      Program supplied y resize increment: %s\n",
+		 yscale(hints->height_inc));
+	  if (hints->width_inc != 0 && hints->height_inc != 0) {
+	      if (flags & USSize)
+		  printf("      User supplied size in resize increments:  %s by %s\n",
+			 (xscale(hints->width / hints->width_inc)), 
+			 (yscale(hints->height / hints->height_inc)));
+	      if (flags & PSize)
+		  printf("      Program supplied size in resize increments:  %s by %s\n",
+			 (xscale(hints->width / hints->width_inc)), 
+			 (yscale(hints->height / hints->height_inc)));
+	      if (flags & PMinSize)
+		  printf("      Program supplied minimum size in resize increments: %s by %s\n",
+			 xscale(hints->min_width / hints->width_inc), yscale(hints->min_height / hints->height_inc));
+	      if (flags & PBaseSize)
+		  printf("      Program supplied base size in resize increments:  %s by %s\n",
+			 (xscale(hints->base_width / hints->width_inc)), 
+			 (yscale(hints->base_height / hints->height_inc)));
+	  }
+        }
+
+	if (flags & PAspect) {
+	  printf("      Program supplied min aspect ratio: %s/%s\n",
+		 xscale(hints->min_aspect.x), yscale(hints->min_aspect.y));
+	  printf("      Program supplied max aspect ratio: %s/%s\n",
+		 xscale(hints->max_aspect.x), yscale(hints->max_aspect.y));
+        }
+
+	if (flags & PWinGravity) {
+	  printf("      Program supplied window gravity: %s\n",
+		 Lookup(hints->win_gravity, _gravities));
+	}
+}
+
+
+/*
+ * Display Size Hints info
+ */
+Display_Size_Hints(window)
+     Window window;
+{
+	XSizeHints *hints = XAllocSizeHints();
+	long supplied;
+
+	printf("\n");
+	if (!XGetWMNormalHints(dpy, window, hints, &supplied))
+	    printf("  No normal window size hints defined\n");
+	else {
+	    printf("  Normal window size hints:\n");
+	    hints->flags &= supplied;
+	    Display_Hints(hints);
+	}
+
+	if (!XGetWMSizeHints(dpy, window, hints, &supplied, XA_WM_ZOOM_HINTS))
+	    printf("  No zoom window size hints defined\n");
+	else {
+	    printf("  Zoom window size hints:\n");
+	    hints->flags &= supplied;
+	    Display_Hints(hints);
+	}
+	XFree((char *)hints);
+}
+
+
+Display_Window_Shape (window)
+    Window  window;
+{
+    Bool    ws, bs;
+    int	    xws, yws, xbs, ybs;
+    unsigned int wws, hws, wbs, hbs;
+
+    if (!XShapeQueryExtension (dpy, &bs, &ws))
+	return;
+
+    printf("\n");
+    XShapeQueryExtents (dpy, window, &ws, &xws, &yws, &wws, &hws,
+				     &bs, &xbs, &ybs, &wbs, &hbs);
+    if (!ws)
+	  printf("  No window shape defined\n");
+    else {
+	  printf("  Window shape extents:  %sx%s",
+		 xscale(wws), yscale(hws));
+	  printf("+%s+%s\n", xscale(xws), yscale(yws));
+    }
+    if (!bs)
+	  printf("  No border shape defined\n");
+    else {
+	  printf("  Border shape extents:  %sx%s",
+		 xscale(wbs), yscale(hbs));
+	  printf("+%s+%s\n", xscale(xbs), yscale(ybs));
+    }
+}
+
+/*
+ * Display Window Manager Info
+ */
+static binding _state_hints[] = {
+	{ DontCareState, "Don't Care State" },
+	{ NormalState, "Normal State" },
+	{ ZoomState, "Zoomed State" },
+	{ IconicState, "Iconic State" },
+	{ InactiveState, "Inactive State" },
+	{ 0, 0 } };
+
+Display_WM_Info(window)
+     Window window;
+{
+        XWMHints *wmhints;
+	long flags;
+
+	wmhints = XGetWMHints(dpy, window);
+	printf("\n");
+	if (!wmhints) {
+		printf("  No window manager hints defined\n");
+		return;
+	}
+	flags = wmhints->flags;
+
+	printf("  Window manager hints:\n");
+
+	if (flags & InputHint)
+	  printf("      Client accepts input or input focus: %s\n",
+		 Lookup(wmhints->input, _bool));
+
+	if (flags & IconWindowHint) {
+		printf("      Icon window id: ");
+		Display_Window_Id(wmhints->icon_window, True);
+	}
+
+	if (flags & IconPositionHint)
+	  printf("      Initial icon position: %s, %s\n",
+		 xscale(wmhints->icon_x), yscale(wmhints->icon_y));
+
+	if (flags & StateHint)
+	  printf("      Initial state is %s\n",
+		 Lookup(wmhints->initial_state, _state_hints));
+}
diff --git a/xwininfo.man b/xwininfo.man
new file mode 100644
index 0000000..e49552d
--- /dev/null
+++ b/xwininfo.man
@@ -0,0 +1,197 @@
+.\" $Xorg: xwininfo.man,v 1.4 2001/02/09 02:06:04 xorgcvs Exp $
+.\" Copyright 1988, 1998  The Open Group
+.\" 
+.\" 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.
+.\" 
+.\" The above copyright notice and this permission notice shall be included
+.\" in all copies or substantial portions of the Software.
+.\" 
+.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+.\" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+.\" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+.\" IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+.\" OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+.\" ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+.\" OTHER DEALINGS IN THE SOFTWARE.
+.\" 
+.\" Except as contained in this notice, the name of The Open Group shall
+.\" not be used in advertising or otherwise to promote the sale, use or
+.\" other dealings in this Software without prior written authorization
+.\" from The Open Group.
+.TH XWININFO 1 "Release 6.4" "X Version 11"
+.SH NAME
+xwininfo \- window information utility for X
+.SH SYNOPSIS
+.B "xwininfo"
+[\-help] [\-id \fIid\fP] [\-root] [\-name \fIname\fP] [\-int]
+[\-children] [\-tree] [\-stats] [\-bits] [\-events] [\-size] [\-wm] [\-shape]
+[\-frame] [\-all]
+[\-english] [\-metric]
+[\-display \fIdisplay\fP]
+.SH DESCRIPTION
+.PP
+.I Xwininfo
+is a utility for displaying information about windows.
+Various information is displayed depending on which options are selected.
+If no options are chosen, \fB\-stats\fP is assumed.
+.PP
+The user has the option of selecting the target window with
+the mouse (by clicking any mouse button in the desired window) or by
+specifying its window id on the command line with the \fB\-id\fP option.
+Or instead of specifying
+the window by its id number, the \fB\-name\fP option may be used to specify
+which window is desired by name.
+There is also a special \fB\-root\fP option to quickly obtain information
+on the screen's root window.
+.SH OPTIONS
+.PP
+.TP 8
+.B "\-help"
+Print out the `Usage:' command syntax summary.
+.PP
+.TP 8
+.B "\-id \fIid\fP"
+This option allows the user to specify a target window \fIid\fP on the
+command line rather than using the mouse to select the target window.
+This is very useful in debugging X applications where the target
+window is not mapped to the screen or where the use of the mouse might
+be impossible or interfere with the application.
+.PP
+.TP 8
+.B "\-name \fIname\fP"
+This option allows the user to specify that the window named \fIname\fP
+is the target window on the command line rather than using the mouse to
+select the target window.
+.PP
+.TP 8
+.B "\-root"
+This option specifies that X's root window is the target window.
+This is useful in situations where the root window is completely obscured.
+.PP
+.TP 8
+.B "\-int"
+This option specifies that all X window ids should be displayed as
+integer values.  The default is to display them as hexadecimal values.
+.PP
+.TP 8
+.B \-children
+This option causes the root, parent, and children windows' ids and names of
+the selected window to be displayed.
+.PP
+.TP 8
+.B \-tree
+This option is like \fB\-children\fP but displays all children recursively.
+.PP
+.TP 8
+.B \-stats
+This option causes the display of various attributes pertaining to 
+the location and appearance of the selected window.
+Information displayed includes the location of the window,
+its width and height, its depth, border width, class, colormap id if any,
+map state, backing-store hint, and location of the corners.
+.PP
+.TP 8
+.B \-bits
+This option causes the display of various attributes pertaining to
+the selected window's raw bits and how the selected window is to be stored.
+Displayed information includes the selected window's bit gravity,
+window gravity, backing-store hint, backing-planes value, backing pixel,
+and whether or not the window has save-under set.
+.PP
+.TP 8
+.B \-events
+This option causes the selected window's event masks to be displayed.
+Both the event mask of events wanted by some client and the event mask of
+events not to propagate are displayed.
+.PP
+.TP 8
+.B \-size
+This option causes the selected window's sizing hints to be displayed.
+Displayed information includes: for both the normal size hints and the
+zoom size hints, the user supplied location if any; the program supplied
+location if any; the user supplied size if any; the program supplied size if
+any; the minimum size if any; the maximum size if any; the resize increments
+if any; and the minimum and maximum aspect ratios if any.
+.PP
+.TP 8
+.B \-wm
+This option causes the selected window's window manager hints to be
+displayed.  Information displayed may include whether or not the application
+accepts input, what the window's icon window # and name is, where the window's
+icon should go, and what the window's initial state should be.
+.PP
+.TP 8 
+.B \-shape
+This option causes the selected window's window and border shape extents to
+be displayed.
+.TP 8
+.B \-frame
+This option causes window manager frames to be considered when manually 
+selecting windows.
+.PP
+.TP 8
+.B \-metric
+This option causes all individual height, width, and x and y positions to be
+displayed in millimeters as well as number of pixels, based on what the
+server thinks the resolution is. Geometry specifications that are in
+\fB+x+y\fP form are not changed.
+.TP 8
+.B \-english
+This option causes all individual height, width, and x and y positions to be
+displayed in inches (and feet, yards, and miles if necessary) as well as
+number of pixels. \fB\-metric\fP and \fB\-english\fP may both be enabled at the
+same time. 
+.PP
+.TP 8
+.B \-all
+This option is a quick way to ask for all information possible.
+.PP
+.TP 8
+.B \-display \fIdisplay\fP
+This option allows you to specify the server to connect to; see \fIX(1)\fP.
+.SH EXAMPLE
+.PP
+The following is a sample summary taken with no options specified:
+
+xwininfo: Window id: 0x60000f "xterm"
+
+  Absolute upper-left X: 2
+  Absolute upper-left Y: 85
+  Relative upper-left X:  0
+  Relative upper-left Y:  25
+  Width: 579
+  Height: 316
+  Depth: 8
+  Visual Class: PseudoColor
+  Border width: 0
+  Class: InputOutput
+  Colormap: 0x27 (installed)
+  Bit Gravity State: NorthWestGravity
+  Window Gravity State: NorthWestGravity
+  Backing Store State: NotUseful
+  Save Under State: no
+  Map State: IsViewable
+  Override Redirect State: no
+  Corners:  +2+85  -699+85  -699-6.4  +2-623
+  -geometry 80x24+0+58
+
+.SH ENVIRONMENT
+.PP
+.TP 8
+.B DISPLAY
+To get the default host and display number.
+.SH SEE ALSO
+X(1), xprop(1)
+.SH BUGS
+Using \fB\-stats \-bits\fP shows some redundant information.
+.PP
+The -geometry string displayed must make assumptions about the
+window's border width and the behavior of the application and the
+window manager.  As a result, the location given is not always
+correct.
+.SH AUTHOR
+Mark Lillibridge, MIT Project Athena