![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xwininfo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xwininfo|
Return to xwininfo.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xwininfo |
1.1 root 1: /* Copyright 1987, Massachusetts Institute of Technology */
2:
3: /*
4: * xwininfo.c - MIT Project Athena, X Window system window
5: * information utility.
6: *
7: * This program will report all relavent information
8: * about a specific window.
9: *
10: * Author: Mark Lillibridge, MIT Project Athena
11: * 16-Jun-87
12: */
13:
14: #include <X11/Xlib.h>
15: #include <X11/Xutil.h>
16: #include <stdio.h>
17: #include <strings.h>
18:
19: /* Include routines to handle parsing defaults */
20: #include "dsimple.h"
21:
22: #define TRUE 1
23: #define FALSE 0
24:
25: #define FAILURE 0
26:
27: Window window;
28: static char *window_id_format = " 0x%x";
29:
30: /*
31: * Report the syntax for calling xwininfo:
32: */
33: usage()
34: {
35: fprintf(stderr, "\n");
36: fprintf(stderr, "Usage: %s [-help] %s [-int] ",
37: program_name, SELECT_USAGE);
38: fprintf(stderr, "[host:vs] [-tree] [-stats] [-bits] [-events] [-size] [-wm]\n\n");
39: exit(0);
40: }
41:
42:
43: main(argc, argv)
44: int argc;
45: char **argv;
46: {
47: register int i;
48: int tree, stats, bits, events, wm, size = 0;
49:
50: INIT_NAME;
51:
52: /* Open display, handle command line arguments */
53: Setup_Display_And_Screen(&argc, argv);
54:
55: /* Get window selected on command line, if any */
56: window = Select_Window_Args(&argc, argv);
57:
58: /* Handle our command line arguments */
59: for (i = 1; i < argc; i++) {
60: if (!strcmp(argv[i], "-help"))
61: usage();
62: if (!strcmp(argv[i], "-int")) {
63: window_id_format = " %d";
64: continue;
65: }
66: if (!strcmp(argv[i], "-tree")) {
67: tree = 1;
68: continue;
69: }
70: if (!strcmp(argv[i], "-stats")) {
71: stats = 1;
72: continue;
73: }
74: if (!strcmp(argv[i], "-bits")) {
75: bits = 1;
76: continue;
77: }
78: if (!strcmp(argv[i], "-events")) {
79: events = 1;
80: continue;
81: }
82: if (!strcmp(argv[i], "-wm")) {
83: wm = 1;
84: continue;
85: }
86: if (!strcmp(argv[i], "-size")) {
87: size = 1;
88: continue;
89: }
90: usage();
91: }
92:
93: /* If no window selected on command line, let user pick one the hard way */
94: if (!window) {
95: printf("\nxwininfo ==> Please select the window you wish\n");
96: printf(" ==> information on by clicking the\n");
97: printf(" ==> mouse in that window.\n");
98: window = Select_Window(dpy);
99: }
100:
101: /*
102: * Do the actual displaying as per parameters
103: */
104: if (!(tree || bits || events || wm || size))
105: stats = 1;
106:
107: printf("\nxwininfo ==> Window id:");
108: Display_Window_Id(window);
109: if (tree)
110: Display_Tree_Info(window);
111: if (stats)
112: Display_Stats_Info(window);
113: if (bits)
114: Display_Bits_Info(window);
115: if (events)
116: Display_Events_Info(window);
117: if (wm)
118: Display_WM_Info(window);
119: if (size)
120: Display_Size_Hints(window);
121: printf("\n");
122: }
123:
124:
125: /*
126: * Lookup: lookup a code in a table.
127: */
128: typedef struct {
129: long code;
130: char *name;
131: } binding;
132:
133: static char _lookup_buffer[100];
134:
135: char *Lookup(code, table)
136: long code;
137: binding *table;
138: {
139: char *name;
140:
141: sprintf(_lookup_buffer, "unknown (code = %ld. = 0x%lx)", code, code);
142: name = _lookup_buffer;
143:
144: while (table->name) {
145: if (table->code == code) {
146: name = table->name;
147: break;
148: }
149: table++;
150: }
151:
152: return(name);
153: }
154:
155:
156: /*
157: * Routine to display a window id in dec/hex with name if window has one
158: */
159:
160: Display_Window_Id(window)
161: Window window;
162: {
163: char *win_name;
164:
165: printf(window_id_format, window); /* print id # in hex/dec */
166: if (!window) {
167: printf(" (none)\n");
168: return;
169: }
170: if (!XFetchName(dpy, window, &win_name)) { /* Get window name if any */
171: printf(" (has no name)\n");
172: return;
173: }
174: if (win_name) {
175: printf(" (%s)\n", win_name);
176: free(win_name);
177: } else if (window == RootWindow(dpy, screen))
178: printf(" (the root window)\n");
179: else
180: printf(" (has no name)\n");
181: }
182:
183:
184: /*
185: * Display Stats on window
186: */
187: static binding _window_classes[] = {
188: { InputOutput, "InputOutput" },
189: { InputOnly, "InputOnly" },
190: { 0, 0 } };
191:
192: static binding _map_states[] = {
193: { IsUnmapped, "IsUnMapped" },
194: { IsUnviewable, "IsUnviewable" },
195: { IsViewable, "IsViewable" },
196: { 0, 0 } };
197:
198: Display_Stats_Info(window)
199: Window window;
200: {
201: XWindowAttributes win_attributes;
202:
203: if (!XGetWindowAttributes(dpy, window, &win_attributes))
204: Fatal_Error("Can't get window attributes.");
205:
206: printf("\n ==> Upper left X: %d\n", win_attributes.x);
207: printf(" ==> Upper left Y: %d\n", win_attributes.y);
208: printf(" ==> Width: %d\n", win_attributes.width);
209: printf(" ==> Height: %d\n", win_attributes.height);
210: printf(" ==> Depth: %d\n", win_attributes.depth);
211: printf(" ==> Border width: %d\n", win_attributes.border_width);
212: printf(" ==> Window class: %s\n", Lookup(win_attributes.class,
213: _window_classes));
214: printf(" ==> Window Map State: %s\n",
215: Lookup(win_attributes.map_state, _map_states));
216: }
217:
218:
219: /*
220: * Display bits info:
221: */
222: static binding _gravities[] = {
223: { UnmapGravity, "UnMapGravity" }, /* WARNING: both of these have*/
224: { ForgetGravity, "ForgetGravity" }, /* the same value - see code */
225: { NorthWestGravity, "NorthWestGravity" },
226: { NorthGravity, "NorthGravity" },
227: { NorthEastGravity, "NorthEastGravity" },
228: { WestGravity, "WestGravity" },
229: { CenterGravity, "CenterGravity" },
230: { EastGravity, "EastGravity" },
231: { SouthWestGravity, "SouthWestGravity" },
232: { SouthGravity, "SouthGravity" },
233: { SouthEastGravity, "SouthEastGravity" },
234: { StaticGravity, "StaticGravity" },
235: { 0, 0 } };
236:
237: static binding _backing_store_hint[] = {
238: { NotUseful, "NotUseful" },
239: { WhenMapped, "WhenMapped" },
240: { Always, "Always" },
241: { 0, 0 } };
242:
243: static binding _bool[] = {
244: { 0, "No" },
245: { 1, "Yes" },
246: { 0, 0 } };
247:
248: Display_Bits_Info(window)
249: Window window;
250: {
251: XWindowAttributes win_attributes;
252:
253: if (!XGetWindowAttributes(dpy, window, &win_attributes))
254: Fatal_Error("Can't get window attributes.");
255:
256: printf("\n ==> Bit gravity: %s\n",
257: Lookup(win_attributes.bit_gravity, _gravities+1));
258: printf(" ==> Window gravity: %s\n",
259: Lookup(win_attributes.win_gravity, _gravities));
260: printf(" ==> Backing-store hint: %s\n",
261: Lookup(win_attributes.backing_store, _backing_store_hint));
262: printf(" ==> Backing-planes to be preserved: 0x%x\n",
263: win_attributes.backing_planes);
264: printf(" ==> Backing pixel: %d\n", win_attributes.backing_pixel);
265: printf(" ==> Save-under?: %s\n",
266: Lookup(win_attributes.save_under, _bool));
267: }
268:
269:
270: /*
271: * Routine to display all events in an event mask
272: */
273: static binding _event_mask_names[] = {
274: { KeyPressMask, "KeyPress" },
275: { KeyReleaseMask, "KeyRelease" },
276: { ButtonPressMask, "ButtonPress" },
277: { ButtonReleaseMask, "ButtonRelease" },
278: { EnterWindowMask, "EnterWindow" },
279: { LeaveWindowMask, "LeaveWindow" },
280: { PointerMotionMask, "PointerMotion" },
281: { PointerMotionHintMask, "PointerMotionHint" },
282: { Button1MotionMask, "Button1Motion" },
283: { Button2MotionMask, "Button2Motion" },
284: { Button3MotionMask, "Button3Motion" },
285: { Button4MotionMask, "Button4Motion" },
286: { Button5MotionMask, "Button5Motion" },
287: { ButtonMotionMask, "ButtonMotion" },
288: { KeymapStateMask, "KeymapState" },
289: { ExposureMask, "Exposure" },
290: { VisibilityChangeMask, "VisibilityChange" },
291: { StructureNotifyMask, "StructureNotify" },
292: { ResizeRedirectMask, "ResizeRedirect" },
293: { SubstructureNotifyMask, "SubstructureNotify" },
294: { SubstructureRedirectMask, "SubstructureRedirect" },
295: { FocusChangeMask, "FocusChange" },
296: { PropertyChangeMask, "PropertyChange" },
297: { ColormapChangeMask, "ColormapChange" },
298: { OwnerGrabButtonMask, "OwnerGrabButton" },
299: { 0, 0 } };
300:
301: Display_Event_Mask(mask)
302: long mask;
303: {
304: long bit, bit_mask;
305:
306: for (bit=0, bit_mask=1; bit<sizeof(long)*8; bit++, bit_mask <<= 1)
307: if (mask & bit_mask)
308: printf(" ==> %s\n",
309: Lookup(bit_mask, _event_mask_names));
310: }
311:
312:
313: /*
314: * Display info on events
315: */
316: Display_Events_Info(window)
317: Window window;
318: {
319: XWindowAttributes win_attributes;
320:
321: if (!XGetWindowAttributes(dpy, window, &win_attributes))
322: Fatal_Error("Can't get window attributes.");
323:
324: printf("\n ==> Someone wants these events:\n");
325: Display_Event_Mask(win_attributes.all_event_masks);
326:
327: printf(" ==> Do not prograte these events:\n");
328: Display_Event_Mask(win_attributes.do_not_propagate_mask);
329:
330: printf(" ==> Overide redirection?: %s\n",
331: Lookup(win_attributes.override_redirect, _bool));
332: }
333:
334:
335: /* left out visual stuff */
336: /* left out colormap */
337: /* left out map_installed */
338:
339:
340: /*
341: * Display root, parent, and children window id's of window
342: */
343: Display_Tree_Info(window)
344: Window window;
345: {
346: int i;
347: Window root_win, parent_win;
348: int num_children;
349: Window *child_list;
350:
351: if (!XQueryTree(dpy, window, &root_win, &parent_win, &child_list,
352: &num_children))
353: Fatal_Error("Can't query window tree.");
354:
355: printf("\n ==> Root window id:");
356: Display_Window_Id(root_win);
357: printf(" ==> Parent window id:");
358: Display_Window_Id(parent_win);
359:
360: printf(" ==> Number of children: %d\n", num_children);
361:
362: for (i = num_children - 1; i >= 0; i--) {
363: printf(" ==> Child window id:");
364: Display_Window_Id(child_list[i]);
365: }
366:
367: free(child_list);
368: }
369:
370:
371: /*
372: * Display a set of size hints
373: */
374: Display_Hints(hints)
375: XSizeHints hints;
376: {
377: long flags;
378:
379: flags = hints.flags;
380:
381: if (flags & USPosition)
382: printf(" ==> User supplied location: %d, %d\n",
383: hints.x, hints.y);
384:
385: if (flags & PPosition)
386: printf(" ==> Program supplied location: %d, %d\n",
387: hints.x, hints.y);
388:
389: if (flags & USSize)
390: printf(" ==> User supplied size: %d by %d\n",
391: hints.width, hints.height);
392:
393: if (flags & PSize)
394: printf(" ==> Program supplied size: %d by %d\n",
395: hints.width, hints.height);
396:
397: if (flags & PMinSize)
398: printf(" ==> Program supplied minimum size: %d by %d\n",
399: hints.min_width, hints.min_height);
400:
401: if (flags & PMaxSize)
402: printf(" ==> Program supplied maximum size: %d by %d\n",
403: hints.max_width, hints.max_height);
404:
405: if (flags & PResizeInc) {
406: printf(" ==> Program supplied x resize increment: %d\n",
407: hints.width_inc);
408: printf(" ==> Program supplied y resize increment: %d\n",
409: hints.height_inc);
410: }
411:
412: if (flags & PAspect) {
413: printf(" ==> Program supplied min aspect ratio: %d/%d\n",
414: hints.min_aspect.x, hints.min_aspect.y);
415: printf(" ==> Program supplied max aspect ratio: %d/%d\n",
416: hints.max_aspect.x, hints.max_aspect.y);
417: }
418: }
419:
420:
421: /*
422: * Display Size Hints info
423: */
424: Display_Size_Hints(window)
425: Window window;
426: {
427: XSizeHints hints;
428:
429: if (!XGetNormalHints(dpy, window, &hints))
430: printf("\n ==> No normal window size hints defined\n");
431: else {
432: printf("\n ==> Normal window size hints:\n\n");
433: Display_Hints(hints);
434: }
435:
436: if (!XGetZoomHints(dpy, window, &hints))
437: printf("\n ==> No zoom window size hints defined\n");
438: else {
439: printf("\n ==> Zoom window size hints:\n\n");
440: Display_Hints(hints);
441: }
442: }
443:
444:
445: /*
446: * Display Window Manager Info
447: */
448: static binding _state_hints[] = {
449: { DontCareState, "Don't Care State" },
450: { NormalState, "Normal State" },
451: { ZoomState, "Zoomed State" },
452: { IconicState, "Iconic State" },
453: { InactiveState, "Inactive State" },
454: { 0, 0 } };
455:
456: Display_WM_Info(window)
457: Window window;
458: {
459: XWMHints *wmhints;
460: long flags;
461:
462: wmhints = XGetWMHints(dpy, window);
463: if (!wmhints) {
464: printf("\n ==> No window manager hints defined\n");
465: return;
466: }
467: flags = wmhints->flags;
468:
469: printf("\n ==> Window manager hints:\n\n");
470:
471: if (flags & InputHint)
472: printf(" ==> Application accepts input? %s\n",
473: Lookup(wmhints->input, _bool));
474:
475: if (flags & IconWindowHint) {
476: printf(" ==> Icon window id:");
477: Display_Window_Id(wmhints->icon_window);
478: }
479:
480: if (flags & IconPositionHint)
481: printf(" ==> Initial icon position: %d, %d\n",
482: wmhints->icon_x, wmhints->icon_y);
483:
484: if (flags & StateHint)
485: printf(" ==> Initial state is %s\n",
486: Lookup(wmhints->initial_state, _state_hints));
487: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.