From 0032f9b66d63a4b1c5222edb8603fb60da379fb0 Mon Sep 17 00:00:00 2001 From: marha Date: Fri, 6 Nov 2009 16:19:08 +0000 Subject: Added xwininfo-1.0.5 --- apps/xwininfo/xwininfo.c | 1133 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1133 insertions(+) create mode 100644 apps/xwininfo/xwininfo.c (limited to 'apps/xwininfo/xwininfo.c') diff --git a/apps/xwininfo/xwininfo.c b/apps/xwininfo/xwininfo.c new file mode 100644 index 000000000..838408ab3 --- /dev/null +++ b/apps/xwininfo/xwininfo.c @@ -0,0 +1,1133 @@ +/* $XdotOrg: $ */ +/* $Xorg: xwininfo.c,v 1.4 2001/02/09 02:06:04 xorgcvs Exp $ */ +/* + +Copyright 1987, 1998 The Open Group +Copyright 1999 Sun Microsystems, Inc. + +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 +OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL +INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING +FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, +NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION +WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +Except as contained in this notice, the name of a copyright holder +shall not be used in advertising or otherwise to promote the sale, use +or other dealings in this Software without prior written authorization +of the copyright holder. + +*/ +/* $XFree86: xc/programs/xwininfo/xwininfo.c,v 1.9 2003/09/09 22:08:25 herrb Exp $ */ + + +/* + * 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 "config.h" +#include +#include +#include +#include +#include +#ifndef NO_I18N +#include +#endif +#include +#include + +/* Include routines to handle parsing defaults */ +#include "dsimple.h" + +typedef struct { + long code; + const char *name; +} binding; + +static void scale_init(void); +static char *nscale(int, int, int, char *, size_t); +static char *xscale(int); +static char *yscale(int); +static char *bscale(int); +static int bad_window_handler(Display *, XErrorEvent *); +int main(int, char **); +static const char *LookupL(long, const binding *); +static const char *Lookup(int, const binding *); +static void Display_Window_Id(Window, int); +static void Display_Stats_Info(Window); +static void Display_Bits_Info(Window); +static void Display_Event_Mask(long); +static void Display_Events_Info(Window); +static void Display_Tree_Info(Window, int); +static void display_tree_info_1(Window, int, int); +static void Display_Hints(XSizeHints *); +static void Display_Size_Hints(Window); +static void Display_Window_Shape(Window); +static void Display_WM_Info(Window); + +static char *window_id_format = "0x%lx"; + +#ifndef HAVE_STRLCAT +static size_t strlcat(char *dst, const char *src, size_t dstsize) +{ + size_t sd = strlen(dst); + size_t ss = strlen(src); + size_t s = sd + ss; + + if (s < dstsize) { + strcpy(dst + sd, src); + } else { + strncpy(dst + sd, src, dstsize-sd-1); + dst[dstsize] = '\0'; + } + return s; +} +#endif + +/* + * Report the syntax for calling xwininfo: + */ +void +usage(void) +{ + 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: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)) +static int xp=0, xmm=0; +static int yp=0, ymm=0; +static int bp=0, bmm=0; +static int english = 0, metric = 0; + +static void +scale_init(void) +{ + 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) + +static char * +nscale(int n, int np, int nmm, char *nbuf, size_t nbufsize) +{ + int s; + snprintf(nbuf, nbufsize, "%d", n); + + if (metric||english) { + s = strlcat(nbuf, " (", nbufsize); + + if (metric) { + snprintf(nbuf+s, nbufsize-s, "%.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; + s = strlen(nbuf); + snprintf(nbuf+s, nbufsize-s, "%d %s(?!?)", + mi, (mi==1) ? "mile" : "miles"); + printed_anything = True; + } + if (inr >= YARD) { + yar = inr/YARD; + inr %= YARD; + if (printed_anything) + strlcat(nbuf, ", ", nbufsize); + s = strlen(nbuf); + snprintf(nbuf+s, nbufsize-s, "%d %s", + yar, (yar==1) ? "yard" : "yards"); + printed_anything = True; + } + if (inr >= FOOT) { + ft = inr/FOOT; + inr %= FOOT; + if (printed_anything) + strlcat(nbuf, ", ", nbufsize); + s = strlen(nbuf); + snprintf(nbuf+s, nbufsize-s, "%d %s", + ft, (ft==1) ? "foot" : "feet"); + printed_anything = True; + } + if (!printed_anything || inch_frac != 0.0 || inr != 0) { + if (printed_anything) + strlcat(nbuf, ", ", nbufsize); + s = strlen(nbuf); + snprintf(nbuf+s, nbufsize-s, "%.2f inches", inr+inch_frac); + } + } + strlcat (nbuf, ")", nbufsize); + } + return(nbuf); +} + +static char xbuf[BUFSIZ]; +static char * +xscale(int x) +{ + if(!xp) { + scale_init(); + } + return(nscale(x, xp, xmm, xbuf, sizeof(xbuf))); +} + +static char ybuf[BUFSIZ]; +static char * +yscale(int y) +{ + if(!yp) { + scale_init(); + } + return(nscale(y, yp, ymm, ybuf, sizeof(ybuf))); +} + +static char bbuf[BUFSIZ]; +static char * +bscale(int b) +{ + if(!bp) { + scale_init(); + } + return(nscale(b, bp, bmm, bbuf, sizeof(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 */ +static int +bad_window_handler(Display *disp, XErrorEvent *err) +{ + char badid[20]; + + snprintf(badid, sizeof(badid), window_id_format, err->resourceid); + Fatal_Error("No such window with id %s.", badid); + exit (1); + return 0; +} + + +int +main(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; + +#ifndef NO_I18N + { + char *lc; + lc = setlocale(LC_ALL, ""); + if(!lc) + fprintf(stderr, "can not set locale properly\n"); + } +#endif + + /* 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, !frame); + } + + /* + * 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; + XErrorHandler 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. + */ +static char _lookup_buffer[100]; + +static const char * +LookupL(long code, const binding *table) +{ + const char *name; + + snprintf(_lookup_buffer, sizeof(_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); +} + +static const char * +Lookup(int code, const binding *table) +{ + return LookupL((long)code, table); +} + +/* + * Routine to display a window id in dec/hex with name if window has one + */ + +static void +Display_Window_Id(Window window, Bool newline_wanted) +{ +#ifdef NO_I18N + char *win_name; +#else + XTextProperty tp; +#endif + + printf(window_id_format, window); /* print id # in hex/dec */ + + if (!window) { + printf(" (none)"); + } else { + if (window == RootWindow(dpy, screen)) { + printf(" (the root window)"); + } +#ifdef NO_I18N + 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 + if (!XGetWMName(dpy, window, &tp)) { /* Get window name if any */ + printf(" (has no name)"); + } else if (tp.nitems > 0) { + printf(" \""); + { + int count = 0, i, ret; + char **list = NULL; + ret = XmbTextPropertyToTextList(dpy, &tp, &list, &count); + if((ret == Success || ret > 0) && list != NULL){ + for(i=0; ivisualid); + 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); + + XFree(vinfo); + + /* + * 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 const 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, NULL } }; + +static const binding _backing_store_hint[] = { + { NotUseful, "NotUseful" }, + { WhenMapped, "WhenMapped" }, + { Always, "Always" }, + { 0, NULL } }; + +static const binding _bool[] = { + { 0, "No" }, + { 1, "Yes" }, + { 0, NULL } }; + +static void +Display_Bits_Info(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%lx\n", + win_attributes.backing_planes); + printf(" Backing pixel: %ld\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 const 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, NULL } }; + +static void +Display_Event_Mask(long mask) +{ + long bit, bit_mask; + + for (bit=0, bit_mask=1; bit 0) { + printf(" "); + for (j=0; j= 0; i--) { + printf(" "); + for (j=0; jflags; + + 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 + */ +static void +Display_Size_Hints(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); +} + + +static void +Display_Window_Shape (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 const binding _state_hints[] = { + { DontCareState, "Don't Care State" }, + { NormalState, "Normal State" }, + { ZoomState, "Zoomed State" }, + { IconicState, "Iconic State" }, + { InactiveState, "Inactive State" }, + { 0, NULL } }; + +static void +Display_WM_Info(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)); + + XFree(wmhints); +} -- cgit v1.2.3