2 * $Xorg: xdpyinfo.c,v 1.5 2001/02/09 02:05:41 xorgcvs Exp $
4 * xdpyinfo - print information about X display connection
7 Copyright 1988, 1998 The Open Group
8 Copyright 2005 Hitachi, Ltd.
10 Permission to use, copy, modify, distribute, and sell this software and its
11 documentation for any purpose is hereby granted without fee, provided that
12 the above copyright notice appear in all copies and that both that
13 copyright notice and this permission notice appear in supporting
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 Except as contained in this notice, the name of The Open Group shall not be
27 used in advertising or otherwise to promote the sale, use or other dealings
28 in this Software without prior written authorization from The Open Group.
30 * Author: Jim Fulton, MIT X Consortium
33 /* $XFree86: xc/programs/xdpyinfo/xdpyinfo.c,v 3.29 2003/04/14 20:38:10 herrb Exp $ */
37 # if HAVE_X11_EXTENSIONS_MULTIBUF_H
41 # if HAVE_X11_EXTENSIONS_XSHM_H
45 # if HAVE_X11_EXTENSIONS_XKB_H && HAVE_X11_XKBLIB_H
49 # if HAVE_X11_EXTENSIONS_XF86VMODE_H && \
50 (HAVE_X11_EXTENSIONS_XF86VMSTR_H || HAVE_X11_EXTENSIONS_XF86VMPROTO_H)
54 # if (HAVE_X11_EXTENSIONS_XXF86DGA_H && HAVE_X11_EXTENSIONS_XF86DGAPROTO_H) \
55 || (HAVE_X11_EXTENSIONS_XF86DGA_H && HAVE_X11_EXTENSIONS_XF86DGASTR_H)
59 # if HAVE_X11_EXTENSIONS_XF86MISC_H && HAVE_X11_EXTENSIONS_XF86MSCSTR_H
63 # if HAVE_X11_EXTENSIONS_XINPUT_H
67 # if HAVE_X11_EXTENSIONS_XRENDER_H
71 # if HAVE_X11_EXTENSIONS_XCOMPOSITE_H
75 # if HAVE_X11_EXTENSIONS_XINERAMA_H
79 # if HAVE_X11_EXTENSIONS_DMXEXT_H
86 #include <X11/Xutil.h>
88 #include <X11/extensions/multibuf.h>
90 #include <X11/extensions/XTest.h>
91 #include <X11/extensions/sync.h>
92 #include <X11/Xproto.h>
93 #include <X11/extensions/Xdbe.h>
94 #include <X11/extensions/record.h>
95 #include <X11/extensions/shape.h>
97 #include <X11/extensions/XShm.h>
100 #include <X11/extensions/XKB.h>
101 #include <X11/XKBlib.h>
104 #include <X11/extensions/xf86vmode.h>
105 # if HAVE_X11_EXTENSIONS_XF86VMPROTO_H /* xf86vidmodeproto 2.2.99.1 & later */
106 # include <X11/extensions/xf86vmproto.h>
108 # include <X11/extensions/xf86vmstr.h>
112 # if HAVE_X11_EXTENSIONS_XXF86DGA_H && HAVE_X11_EXTENSIONS_XF86DGAPROTO_H
113 # include <X11/extensions/Xxf86dga.h>
114 # include <X11/extensions/xf86dgaproto.h>
116 # include <X11/extensions/xf86dga.h>
117 # include <X11/extensions/xf86dgastr.h>
121 #include <X11/extensions/xf86misc.h>
122 #include <X11/extensions/xf86mscstr.h>
125 #include <X11/extensions/XInput.h>
128 #include <X11/extensions/Xrender.h>
131 #include <X11/extensions/Xcomposite.h>
134 #include <X11/extensions/Xinerama.h>
137 #include <X11/extensions/dmxext.h>
143 /* Turn a NULL pointer string into an empty string */
144 #define NULLSTR(x) (((x)!=NULL)?(x):(""))
146 static char *ProgramName;
147 static Bool queryExtensions = False;
150 silent_errors(Display *dpy, XErrorEvent *ev)
155 static int (*old_handler)(Display *, XErrorEvent *) = NULL;
157 static int print_event_mask(char *buf, int lastcol, int indent, long mask);
159 static int StrCmp(const void *a, const void *b)
161 return strcmp(*(char **)a, *(char **)b);
165 print_extension_info(Display *dpy)
168 char **extlist = XListExtensions (dpy, &n);
170 printf ("number of extensions: %d\n", n);
174 int opcode, event, error;
176 qsort(extlist, n, sizeof(char *), StrCmp);
177 for (i = 0; i < n; i++) {
178 if (!queryExtensions) {
179 printf (" %s\n", extlist[i]);
182 XQueryExtension(dpy, extlist[i], &opcode, &event, &error);
183 printf (" %s (opcode: %d", extlist[i], opcode);
185 printf (", base event: %d", event);
187 printf (", base error: %d", error);
190 /* do not free, Xlib can depend on contents being unaltered */
191 /* XFreeExtensionList (extlist); */
196 print_display_info(Display *dpy)
200 int minkeycode, maxkeycode;
203 XPixmapFormatValues *pmf;
207 printf ("name of display: %s\n", DisplayString (dpy));
208 printf ("version number: %d.%d\n",
209 ProtocolVersion (dpy), ProtocolRevision (dpy));
210 printf ("vendor string: %s\n", ServerVendor (dpy));
211 printf ("vendor release number: %d\n", VendorRelease (dpy));
213 if (strstr(ServerVendor (dpy), "XFree86")) {
214 int vendrel = VendorRelease(dpy);
216 printf("XFree86 version: ");
219 * vendrel was set incorrectly for 3.3.4 and 3.3.5, so handle
222 printf("%d.%d.%d", vendrel / 100,
225 } else if (vendrel < 3900) {
226 /* 3.3.x versions, other than the exceptions handled above */
227 printf("%d.%d", vendrel / 1000,
228 (vendrel / 100) % 10);
229 if (((vendrel / 10) % 10) || (vendrel % 10)) {
230 printf(".%d", (vendrel / 10) % 10);
232 printf(".%d", vendrel % 10);
235 } else if (vendrel < 40000000) {
237 printf("%d.%d", vendrel / 1000,
238 (vendrel / 10) % 10);
240 printf(".%d", vendrel % 10);
244 printf("%d.%d.%d", vendrel / 10000000,
245 (vendrel / 100000) % 100,
246 (vendrel / 1000) % 100);
247 if (vendrel % 1000) {
248 printf(".%d", vendrel % 1000);
254 if (strstr(ServerVendor (dpy), "X.Org")) {
255 int vendrel = VendorRelease(dpy);
257 printf("X.Org version: ");
258 printf("%d.%d.%d", vendrel / 10000000,
259 (vendrel / 100000) % 100,
260 (vendrel / 1000) % 100);
262 printf(".%d", vendrel % 1000);
266 if (strstr(ServerVendor (dpy), "DMX")) {
267 int vendrel = VendorRelease(dpy);
268 int major, minor, year, month, day;
270 major = vendrel / 100000000;
271 vendrel -= major * 100000000;
272 minor = vendrel / 1000000;
273 vendrel -= minor * 1000000;
274 year = vendrel / 10000;
275 vendrel -= year * 10000;
276 month = vendrel / 100;
277 vendrel -= month * 100;
280 /* Add other epoch tests here */
281 if (major > 0 && minor > 0) year += 2000;
283 /* Do some sanity tests in case there is
284 * another server with the same vendor
285 * string. That server could easily use
286 * values < 100000000, which would have
287 * the effect of keeping our major
289 if (major > 0 && major <= 20
290 && minor >= 0 && minor <= 99
292 && month >= 1 && month <= 12
293 && day >= 1 && day <= 31)
294 printf("DMX version: %d.%d.%04d%02d%02d\n",
295 major, minor, year, month, day);
298 req_size = XExtendedMaxRequestSize (dpy);
299 if (!req_size) req_size = XMaxRequestSize (dpy);
300 printf ("maximum request size: %ld bytes\n", req_size * 4);
301 printf ("motion buffer size: %ld\n", XDisplayMotionBufferSize (dpy));
303 switch (BitmapBitOrder (dpy)) {
304 case LSBFirst: cp = "LSBFirst"; break;
305 case MSBFirst: cp = "MSBFirst"; break;
307 sprintf (dummybuf, "unknown order %d", BitmapBitOrder (dpy));
311 printf ("bitmap unit, bit order, padding: %d, %s, %d\n",
312 BitmapUnit (dpy), cp, BitmapPad (dpy));
314 switch (ImageByteOrder (dpy)) {
315 case LSBFirst: cp = "LSBFirst"; break;
316 case MSBFirst: cp = "MSBFirst"; break;
318 sprintf (dummybuf, "unknown order %d", ImageByteOrder (dpy));
322 printf ("image byte order: %s\n", cp);
324 pmf = XListPixmapFormats (dpy, &n);
325 printf ("number of supported pixmap formats: %d\n", n);
327 printf ("supported pixmap formats:\n");
328 for (i = 0; i < n; i++) {
329 printf (" depth %d, bits_per_pixel %d, scanline_pad %d\n",
330 pmf[i].depth, pmf[i].bits_per_pixel, pmf[i].scanline_pad);
332 XFree ((char *) pmf);
337 * when we get interfaces to the PixmapFormat stuff, insert code here
340 XDisplayKeycodes (dpy, &minkeycode, &maxkeycode);
341 printf ("keycode range: minimum %d, maximum %d\n",
342 minkeycode, maxkeycode);
344 XGetInputFocus (dpy, &focuswin, &focusrevert);
348 printf ("PointerRoot\n");
354 printf("window 0x%lx, revert to ", focuswin);
355 switch (focusrevert) {
362 case RevertToPointerRoot:
363 printf ("PointerRoot\n");
365 default: /* should not happen */
366 printf ("%d\n", focusrevert);
372 print_extension_info (dpy);
374 printf ("default screen number: %d\n", DefaultScreen (dpy));
375 printf ("number of screens: %d\n", ScreenCount (dpy));
379 print_visual_info(XVisualInfo *vip)
381 char errorbuf[40]; /* for sprintfing into */
382 char *class = NULL; /* for printing */
384 switch (vip->class) {
385 case StaticGray: class = "StaticGray"; break;
386 case GrayScale: class = "GrayScale"; break;
387 case StaticColor: class = "StaticColor"; break;
388 case PseudoColor: class = "PseudoColor"; break;
389 case TrueColor: class = "TrueColor"; break;
390 case DirectColor: class = "DirectColor"; break;
392 sprintf (errorbuf, "unknown class %d", vip->class);
397 printf (" visual:\n");
398 printf (" visual id: 0x%lx\n", vip->visualid);
399 printf (" class: %s\n", class);
400 printf (" depth: %d plane%s\n", vip->depth,
401 vip->depth == 1 ? "" : "s");
402 if (vip->class == TrueColor || vip->class == DirectColor)
403 printf (" available colormap entries: %d per subfield\n",
406 printf (" available colormap entries: %d\n",
408 printf (" red, green, blue masks: 0x%lx, 0x%lx, 0x%lx\n",
409 vip->red_mask, vip->green_mask, vip->blue_mask);
410 printf (" significant bits in color specification: %d bits\n",
414 /* xc/programs/twm/twm.c has a copy of |hasExtension()|, please
415 * keep both versions in sync... */
417 Bool hasExtension(Display *dpy, char *extname)
422 extensions = XListExtensions(dpy, &num_extensions);
423 for (i = 0; i < num_extensions &&
424 (strcmp(extensions[i], extname) != 0); i++);
425 XFreeExtensionList(extensions);
426 return i != num_extensions;
430 print_screen_info(Display *dpy, int scr)
432 Screen *s = ScreenOfDisplay (dpy, scr); /* opaque structure */
433 XVisualInfo viproto; /* fill in for getting info */
434 XVisualInfo *vip; /* returned info */
435 int nvi; /* number of elements returned */
436 int i; /* temp variable: iterator */
437 char eventbuf[80]; /* want 79 chars per line + nul */
438 static char *yes = "YES", *no = "NO", *when = "WHEN MAPPED";
440 int ndepths = 0, *depths = NULL;
441 unsigned int width, height;
444 * there are 2.54 centimeters to an inch; so there are 25.4 millimeters.
446 * dpi = N pixels / (M millimeters / (25.4 millimeters / 1 inch))
447 * = N pixels / (M inch / 25.4)
448 * = N * 25.4 pixels / M inch
451 xres = ((((double) DisplayWidth(dpy,scr)) * 25.4) /
452 ((double) DisplayWidthMM(dpy,scr)));
453 yres = ((((double) DisplayHeight(dpy,scr)) * 25.4) /
454 ((double) DisplayHeightMM(dpy,scr)));
457 printf ("screen #%d:\n", scr);
458 printf (" dimensions: %dx%d pixels (%dx%d millimeters)\n",
459 XDisplayWidth (dpy, scr), XDisplayHeight (dpy, scr),
460 XDisplayWidthMM(dpy, scr), XDisplayHeightMM (dpy, scr));
461 printf (" resolution: %dx%d dots per inch\n",
462 (int) (xres + 0.5), (int) (yres + 0.5));
463 depths = XListDepths (dpy, scr, &ndepths);
464 if (!depths) ndepths = 0;
465 printf (" depths (%d): ", ndepths);
466 for (i = 0; i < ndepths; i++) {
467 printf ("%d", depths[i]);
468 if (i < ndepths - 1) {
474 if (depths) XFree ((char *) depths);
475 printf (" root window id: 0x%lx\n", RootWindow (dpy, scr));
476 printf (" depth of root window: %d plane%s\n",
477 DisplayPlanes (dpy, scr),
478 DisplayPlanes (dpy, scr) == 1 ? "" : "s");
479 printf (" number of colormaps: minimum %d, maximum %d\n",
480 MinCmapsOfScreen(s), MaxCmapsOfScreen(s));
481 printf (" default colormap: 0x%lx\n", DefaultColormap (dpy, scr));
482 printf (" default number of colormap cells: %d\n",
483 DisplayCells (dpy, scr));
484 printf (" preallocated pixels: black %ld, white %ld\n",
485 BlackPixel (dpy, scr), WhitePixel (dpy, scr));
486 printf (" options: backing-store %s, save-unders %s\n",
487 (DoesBackingStore (s) == NotUseful) ? no :
488 ((DoesBackingStore (s) == Always) ? yes : when),
489 DoesSaveUnders (s) ? yes : no);
490 XQueryBestSize (dpy, CursorShape, RootWindow (dpy, scr), 65535, 65535,
492 if (width == 65535 && height == 65535)
493 printf (" largest cursor: unlimited\n");
495 printf (" largest cursor: %dx%d\n", width, height);
496 printf (" current input event mask: 0x%lx\n", EventMaskOfScreen (s));
497 (void) print_event_mask (eventbuf, 79, 4, EventMaskOfScreen (s));
500 viproto.screen = scr;
501 vip = XGetVisualInfo (dpy, VisualScreenMask, &viproto, &nvi);
502 printf (" number of visuals: %d\n", nvi);
503 printf (" default visual id: 0x%lx\n",
504 XVisualIDFromVisual (DefaultVisual (dpy, scr)));
505 for (i = 0; i < nvi; i++) {
506 print_visual_info (vip+i);
508 if (vip) XFree ((char *) vip);
512 * The following routine prints out an event mask, wrapping events at nice
516 #define MASK_NAME_WIDTH 25
518 static struct _event_table {
522 { "KeyPressMask ", KeyPressMask },
523 { "KeyReleaseMask ", KeyReleaseMask },
524 { "ButtonPressMask ", ButtonPressMask },
525 { "ButtonReleaseMask ", ButtonReleaseMask },
526 { "EnterWindowMask ", EnterWindowMask },
527 { "LeaveWindowMask ", LeaveWindowMask },
528 { "PointerMotionMask ", PointerMotionMask },
529 { "PointerMotionHintMask ", PointerMotionHintMask },
530 { "Button1MotionMask ", Button1MotionMask },
531 { "Button2MotionMask ", Button2MotionMask },
532 { "Button3MotionMask ", Button3MotionMask },
533 { "Button4MotionMask ", Button4MotionMask },
534 { "Button5MotionMask ", Button5MotionMask },
535 { "ButtonMotionMask ", ButtonMotionMask },
536 { "KeymapStateMask ", KeymapStateMask },
537 { "ExposureMask ", ExposureMask },
538 { "VisibilityChangeMask ", VisibilityChangeMask },
539 { "StructureNotifyMask ", StructureNotifyMask },
540 { "ResizeRedirectMask ", ResizeRedirectMask },
541 { "SubstructureNotifyMask ", SubstructureNotifyMask },
542 { "SubstructureRedirectMask ", SubstructureRedirectMask },
543 { "FocusChangeMask ", FocusChangeMask },
544 { "PropertyChangeMask ", PropertyChangeMask },
545 { "ColormapChangeMask ", ColormapChangeMask },
546 { "OwnerGrabButtonMask ", OwnerGrabButtonMask },
550 print_event_mask(char *buf, /* string to write into */
551 int lastcol, /* strlen(buf)+1 */
552 int indent, /* amount by which to indent */
553 long mask) /* event mask */
555 struct _event_table *etp;
559 buf[0] = buf[lastcol] = '\0'; /* just in case */
561 #define INDENT() { register int i; len = indent; \
562 for (i = 0; i < indent; i++) buf[i] = ' '; }
566 for (etp = event_table; etp->name; etp++) {
567 if (mask & etp->value) {
568 if (len + MASK_NAME_WIDTH > lastcol) {
572 strcpy (buf+len, etp->name);
573 len += MASK_NAME_WIDTH;
578 if (bitsfound) puts (buf);
586 print_standard_extension_info(Display *dpy, char *extname,
587 int majorrev, int minorrev)
589 int opcode, event, error;
591 printf("%s version %d.%d ", extname, majorrev, minorrev);
593 XQueryExtension(dpy, extname, &opcode, &event, &error);
594 printf ("opcode: %d", opcode);
596 printf (", base event: %d", event);
598 printf (", base error: %d", error);
604 print_multibuf_info(Display *dpy, char *extname)
606 int i, j; /* temp variable: iterator */
607 int nmono, nstereo; /* count */
608 XmbufBufferInfo *mono_info = NULL, *stereo_info = NULL; /* arrays */
610 " visual id, max buffers, depth: 0x%lx, %d, %d\n";
612 int majorrev, minorrev;
614 if (!XmbufGetVersion(dpy, &majorrev, &minorrev))
617 print_standard_extension_info(dpy, extname, majorrev, minorrev);
619 for (i = 0; i < ScreenCount (dpy); i++)
621 if (!XmbufGetScreenInfo (dpy, RootWindow(dpy, scr), &nmono, &mono_info,
622 &nstereo, &stereo_info)) {
624 "%s: unable to get multibuffer info for screen %d\n",
627 printf (" screen %d number of mono multibuffer types: %d\n", i, nmono);
628 for (j = 0; j < nmono; j++) {
629 printf (fmt, mono_info[j].visualid, mono_info[j].max_buffers,
632 printf (" number of stereo multibuffer types: %d\n", nstereo);
633 for (j = 0; j < nstereo; j++) {
634 printf (fmt, stereo_info[j].visualid,
635 stereo_info[j].max_buffers, stereo_info[j].depth);
637 if (mono_info) XFree ((char *) mono_info);
638 if (stereo_info) XFree ((char *) stereo_info);
642 } /* end print_multibuf_info */
646 print_xtest_info(Display *dpy, char *extname)
648 int majorrev, minorrev, foo;
650 if (!XTestQueryExtension(dpy, &foo, &foo, &majorrev, &minorrev))
652 print_standard_extension_info(dpy, extname, majorrev, minorrev);
657 print_sync_info(Display *dpy, char *extname)
659 int majorrev, minorrev;
660 XSyncSystemCounter *syscounters;
663 if (!XSyncInitialize(dpy, &majorrev, &minorrev))
665 print_standard_extension_info(dpy, extname, majorrev, minorrev);
667 syscounters = XSyncListSystemCounters(dpy, &ncounters);
668 printf(" system counters: %d\n", ncounters);
669 for (i = 0; i < ncounters; i++)
671 printf(" %s id: 0x%08x resolution_lo: %d resolution_hi: %d\n",
672 syscounters[i].name, (unsigned int)syscounters[i].counter,
673 XSyncValueLow32(syscounters[i].resolution),
674 XSyncValueHigh32(syscounters[i].resolution));
676 XSyncFreeSystemCounterList(syscounters);
681 print_shape_info(Display *dpy, char *extname)
683 int majorrev, minorrev;
685 if (!XShapeQueryVersion(dpy, &majorrev, &minorrev))
687 print_standard_extension_info(dpy, extname, majorrev, minorrev);
693 print_dga_info(Display *dpy, char *extname)
696 int majorrev, minorrev, width, bank, ram, flags;
698 if (!XF86DGAQueryVersion(dpy, &majorrev, &minorrev))
700 print_standard_extension_info(dpy, extname, majorrev, minorrev);
702 if (!XF86DGAQueryDirectVideo(dpy, DefaultScreen(dpy), &flags)
703 || ! (flags & XF86DGADirectPresent) )
705 printf(" DGA not available on screen %d.\n", DefaultScreen(dpy));
709 old_handler = XSetErrorHandler(silent_errors);
711 if (!XF86DGAGetVideoLL(dpy, DefaultScreen(dpy), &offset,
712 &width, &bank, &ram))
714 printf(" Base address = 0x%X, Width = %d, Bank size = %d,"
715 " RAM size = %dk\n", offset, width, bank, ram);
717 XSetErrorHandler(old_handler);
724 #define V_PHSYNC 0x001
725 #define V_NHSYNC 0x002
726 #define V_PVSYNC 0x004
727 #define V_NVSYNC 0x008
728 #define V_INTERLACE 0x010
729 #define V_DBLSCAN 0x020
730 #define V_CSYNC 0x040
731 #define V_PCSYNC 0x080
732 #define V_NCSYNC 0x100
735 print_XF86VidMode_modeline(
736 unsigned int dotclock,
737 unsigned short hdisplay,
738 unsigned short hsyncstart,
739 unsigned short hsyncend,
740 unsigned short htotal,
741 unsigned short vdisplay,
742 unsigned short vsyncstart,
743 unsigned short vsyncend,
744 unsigned short vtotal,
747 printf(" %6.2f %4d %4d %4d %4d %4d %4d %4d %4d ",
748 (float)dotclock/1000.0,
749 hdisplay, hsyncstart, hsyncend, htotal,
750 vdisplay, vsyncstart, vsyncend, vtotal);
751 if (flags & V_PHSYNC) printf(" +hsync");
752 if (flags & V_NHSYNC) printf(" -hsync");
753 if (flags & V_PVSYNC) printf(" +vsync");
754 if (flags & V_NVSYNC) printf(" -vsync");
755 if (flags & V_INTERLACE) printf(" interlace");
756 if (flags & V_CSYNC) printf(" composite");
757 if (flags & V_PCSYNC) printf(" +csync");
758 if (flags & V_NCSYNC) printf(" -csync");
759 if (flags & V_DBLSCAN) printf(" doublescan");
764 print_XF86VidMode_info(Display *dpy, char *extname)
766 int majorrev, minorrev, modecount, dotclock, i;
767 XF86VidModeMonitor monitor;
768 XF86VidModeModeLine modeline;
769 XF86VidModeModeInfo **modelines;
771 if (!XF86VidModeQueryVersion(dpy, &majorrev, &minorrev))
773 print_standard_extension_info(dpy, extname, majorrev, minorrev);
775 if (XF86VidModeGetMonitor(dpy, DefaultScreen(dpy), &monitor)) {
776 printf(" Monitor Information:\n");
777 printf(" Vendor: %s, Model: %s\n",
778 monitor.vendor == NULL ? "" : monitor.vendor,
779 monitor.model == NULL ? "" : monitor.model);
780 printf(" Num hsync: %d, Num vsync: %d\n",
781 monitor.nhsync, monitor.nvsync);
782 for (i = 0; i < monitor.nhsync; i++) {
783 printf(" hsync range %d: %6.2f - %6.2f\n", i,
784 monitor.hsync[i].lo, monitor.hsync[i].hi);
786 for (i = 0; i < monitor.nvsync; i++) {
787 printf(" vsync range %d: %6.2f - %6.2f\n", i,
788 monitor.vsync[i].lo, monitor.vsync[i].hi);
790 XFree(monitor.vendor);
791 XFree(monitor.model);
792 XFree(monitor.hsync);
793 XFree(monitor.vsync);
795 printf(" Monitor Information not available\n");
798 if ((majorrev > 0) || (majorrev == 0 && minorrev > 5)) {
799 if (XF86VidModeGetAllModeLines(dpy, DefaultScreen(dpy), &modecount,
801 printf(" Available Video Mode Settings:\n");
802 printf(" Clock Hdsp Hbeg Hend Httl Vdsp Vbeg Vend Vttl Flags\n");
803 for (i = 0; i < modecount; i++) {
804 print_XF86VidMode_modeline
805 (modelines[i]->dotclock, modelines[i]->hdisplay,
806 modelines[i]->hsyncstart, modelines[i]->hsyncend,
807 modelines[i]->htotal, modelines[i]->vdisplay,
808 modelines[i]->vsyncstart, modelines[i]->vsyncend,
809 modelines[i]->vtotal, modelines[i]->flags);
813 printf(" Available Video Mode Settings not available\n");
816 if (XF86VidModeGetModeLine(dpy, DefaultScreen(dpy),
817 &dotclock, &modeline)) {
818 printf(" Current Video Mode Setting:\n");
819 print_XF86VidMode_modeline(dotclock,
820 modeline.hdisplay, modeline.hsyncstart,
821 modeline.hsyncend, modeline.htotal,
822 modeline.vdisplay, modeline.vsyncstart,
823 modeline.vsyncend, modeline.vtotal,
826 printf(" Current Video Mode Setting not available\n");
836 static char *kbdtable[] = { "Unknown", "84-key", "101-key", "Other", "Xqueue" };
837 static char *msetable[] = { "None", "Microsoft", "MouseSystems", "MMSeries",
838 "Logitech", "BusMouse", "Mouseman", "PS/2", "MMHitTab",
839 "GlidePoint", "IntelliMouse", "ThinkingMouse",
840 "IMPS/2", "ThinkingMousePS/2", "MouseManPlusPS/2",
841 "GlidePointPS/2", "NetMousePS/2", "NetScrollPS/2",
842 "SysMouse", "Auto" };
843 static char *flgtable[] = { "None", "ClearDTR", "ClearRTS",
844 "ClearDTR and ClearRTS" };
847 print_XF86Misc_info(Display *dpy, char *extname)
849 int majorrev, minorrev;
850 XF86MiscMouseSettings mouseinfo;
851 XF86MiscKbdSettings kbdinfo;
853 if (!XF86MiscQueryVersion(dpy, &majorrev, &minorrev))
855 print_standard_extension_info(dpy, extname, majorrev, minorrev);
857 old_handler = XSetErrorHandler(silent_errors);
859 if ((majorrev > 0) || (majorrev == 0 && minorrev > 0)) {
860 if (!XF86MiscGetKbdSettings(dpy, &kbdinfo))
862 printf(" Keyboard Settings- Type: %s, Rate: %d, Delay: %d, ServerNumLock: %s\n",
863 kbdtable[kbdinfo.type], kbdinfo.rate, kbdinfo.delay,
864 (kbdinfo.servnumlock? "yes": "no"));
866 if (!XF86MiscGetMouseSettings(dpy, &mouseinfo))
868 printf(" Mouse Settings- Device: %s, Type: ",
869 strlen(mouseinfo.device) == 0 ? "None": mouseinfo.device);
870 XFree(mouseinfo.device);
871 if (mouseinfo.type == MTYPE_XQUEUE)
873 else if (mouseinfo.type == MTYPE_OSMOUSE)
875 else if (mouseinfo.type <= MTYPE_AUTOMOUSE)
876 printf("%s\n", msetable[mouseinfo.type+1]);
879 printf(" BaudRate: %d, SampleRate: %d, Resolution: %d\n",
880 mouseinfo.baudrate, mouseinfo.samplerate, mouseinfo.resolution);
881 printf(" Emulate3Buttons: %s, Emulate3Timeout: %d ms\n",
882 mouseinfo.emulate3buttons? "yes": "no", mouseinfo.emulate3timeout);
883 printf(" ChordMiddle: %s, Flags: %s\n",
884 mouseinfo.chordmiddle? "yes": "no",
885 flgtable[(mouseinfo.flags & MF_CLEAR_DTR? 1: 0)
886 +(mouseinfo.flags & MF_CLEAR_RTS? 1: 0)] );
887 printf(" Buttons: %d\n", mouseinfo.buttons);
890 XSetErrorHandler(old_handler);
898 print_mitshm_info(Display *dpy, char *extname)
900 int majorrev, minorrev;
903 if (!XShmQueryVersion(dpy, &majorrev, &minorrev, &sharedPixmaps))
905 print_standard_extension_info(dpy, extname, majorrev, minorrev);
906 printf(" shared pixmaps: ");
909 int format = XShmPixmapFormat(dpy);
910 printf("yes, format: %d\n", format);
922 print_xkb_info(Display *dpy, char *extname)
924 int opcode, eventbase, errorbase, majorrev, minorrev;
926 if (!XkbQueryExtension(dpy, &opcode, &eventbase, &errorbase,
927 &majorrev, &minorrev)) {
930 printf("%s version %d.%d ", extname, majorrev, minorrev);
932 printf ("opcode: %d", opcode);
934 printf (", base event: %d", eventbase);
936 printf (", base error: %d", errorbase);
944 print_dbe_info(Display *dpy, char *extname)
946 int majorrev, minorrev;
947 XdbeScreenVisualInfo *svi;
951 if (!XdbeQueryExtension(dpy, &majorrev, &minorrev))
954 print_standard_extension_info(dpy, extname, majorrev, minorrev);
955 svi = XdbeGetVisualInfo(dpy, (Drawable *)NULL, &numscreens);
956 for (iscrn = 0; iscrn < numscreens; iscrn++)
958 printf(" Double-buffered visuals on screen %d\n", iscrn);
959 for (ivis = 0; ivis < svi[iscrn].count; ivis++)
961 printf(" visual id 0x%lx depth %d perflevel %d\n",
962 svi[iscrn].visinfo[ivis].visual,
963 svi[iscrn].visinfo[ivis].depth,
964 svi[iscrn].visinfo[ivis].perflevel);
967 XdbeFreeVisualInfo(svi);
972 print_record_info(Display *dpy, char *extname)
974 int majorrev, minorrev;
976 if (!XRecordQueryVersion(dpy, &majorrev, &minorrev))
978 print_standard_extension_info(dpy, extname, majorrev, minorrev);
984 print_xinput_info(Display *dpy, char *extname)
986 int loop, num_extensions, num_devices;
988 XDeviceInfo *devices;
989 XExtensionVersion *ext;
991 ext = XGetExtensionVersion(dpy, extname);
993 if (!ext || (ext == (XExtensionVersion*) NoSuchExtension))
996 print_standard_extension_info(dpy, extname, ext->major_version,
1000 extensions = XListExtensions(dpy, &num_extensions);
1001 for (loop = 0; loop < num_extensions &&
1002 (strcmp(extensions[loop], extname) != 0); loop++);
1003 XFreeExtensionList(extensions);
1004 if (loop != num_extensions) {
1005 printf(" Extended devices :\n");
1006 devices = XListInputDevices(dpy, &num_devices);
1007 for(loop=0; loop<num_devices; loop++) {
1008 printf(" \"%s\" [", devices[loop].name ? devices[loop].name : "<noname>");
1009 switch(devices[loop].use) {
1011 printf("XPointer]\n");
1014 printf("XKeyboard]\n");
1016 case IsXExtensionDevice:
1017 printf("XExtensionDevice]\n");
1019 #ifdef IsXExtensionKeyboard
1020 case IsXExtensionKeyboard:
1021 printf("XExtensionKeyboard]\n");
1024 #ifdef IsXExtensionPointer
1025 case IsXExtensionPointer:
1026 printf("XExtensionPointer]\n");
1030 printf("invalid value]\n");
1034 XFreeDeviceList(devices);
1044 print_xrender_info(Display *dpy, char *extname)
1046 int loop, num_extensions;
1048 XRenderPictFormat *pictform;
1052 XVisualInfo viproto; /* fill in for getting info */
1053 XVisualInfo *vip; /* retured info */
1054 int nvi; /* number of elements returned */
1055 int ndepths = 0, *depths = NULL;
1056 #if RENDER_MAJOR > 0 || RENDER_MINOR >= 6
1061 if (!XRenderQueryVersion (dpy, &major, &minor))
1064 print_standard_extension_info(dpy, extname, major, minor);
1066 extensions = XListExtensions(dpy, &num_extensions);
1067 for (loop = 0; loop < num_extensions &&
1068 (strcmp(extensions[loop], extname) != 0); loop++);
1069 XFreeExtensionList(extensions);
1070 if (loop != num_extensions) {
1071 printf (" Render formats :\n");
1072 for (count = 0; (pictform = XRenderFindFormat (dpy, 0, NULL, count)); count++)
1074 printf (" pict format:\n");
1075 printf ("\tformat id: 0x%lx\n", pictform->id);
1076 printf ("\ttype: %s\n",
1077 pictform->type == PictTypeIndexed ? "Indexed" : "Direct");
1078 printf ("\tdepth: %d\n", pictform->depth);
1079 if (pictform->type == PictTypeDirect) {
1080 printf("\talpha: %2d mask 0x%x\n", pictform->direct.alpha, pictform->direct.alphaMask);
1081 printf("\tred: %2d mask 0x%x\n", pictform->direct.red, pictform->direct.redMask);
1082 printf("\tgreen: %2d mask 0x%x\n", pictform->direct.green, pictform->direct.greenMask);
1083 printf("\tblue: %2d mask 0x%x\n", pictform->direct.blue, pictform->direct.blueMask);
1086 printf("\tcolormap 0x%lx\n", pictform->colormap);
1088 printf (" Screen formats :\n");
1089 for (i = 0; i < ScreenCount (dpy); i++) {
1092 vip = XGetVisualInfo (dpy, VisualScreenMask, &viproto, &nvi);
1093 printf (" Screen %d", i);
1094 #if RENDER_MAJOR > 0 || RENDER_MINOR >= 6
1095 switch (XRenderQuerySubpixelOrder (dpy, i)) {
1096 case SubPixelUnknown: printf (" (sub-pixel order Unknown)"); break;
1097 case SubPixelHorizontalRGB: printf (" (sub-pixel order Horizontal RGB)"); break;
1098 case SubPixelHorizontalBGR: printf (" (sub-pixel order Horizontal BGR)"); break;
1099 case SubPixelVerticalRGB: printf (" (sub-pixel order Vertical RGB)"); break;
1100 case SubPixelVerticalBGR: printf (" (sub-pixel order Vertical BGR)"); break;
1101 case SubPixelNone: printf (" (sub-pixel order None)"); break;
1104 filters = XRenderQueryFilters (dpy, RootWindow (dpy, i));
1107 printf (" filters: ");
1108 for (f = 0; f < filters->nfilter; f++)
1110 printf ("%s", filters->filter[f]);
1111 if (f < filters->nalias && filters->alias[f] != FilterAliasNone)
1112 printf ("(%s)", filters->filter[filters->alias[f]]);
1113 if (f < filters->nfilter - 1)
1120 for (j = 0; j < nvi; j++)
1122 printf (" visual format:\n");
1123 printf (" visual id: 0x%lx\n", vip[j].visualid);
1124 pictform = XRenderFindVisualFormat (dpy, vip[j].visual);
1126 printf(" pict format id: 0x%lx\n", pictform->id);
1128 printf(" pict format id: None\n");
1130 if (vip) XFree ((char *) vip);
1131 depths = XListDepths (dpy, i, &ndepths);
1132 if (!depths) ndepths = 0;
1133 for (j = 0; j < ndepths; j++)
1135 XRenderPictFormat templ;
1137 templ.depth = depths[j];
1138 printf (" depth formats:\n");
1139 printf (" depth %d\n", depths[j]);
1140 for (count = 0; (pictform = XRenderFindFormat (dpy, PictFormatDepth, &templ, count)); count++)
1141 printf(" pict format id: 0x%lx\n", pictform->id);
1143 if (depths) XFree (depths);
1150 #endif /* XRENDER */
1154 print_composite_info(Display *dpy, char *extname)
1156 int majorrev, minorrev, foo;
1158 if (!XCompositeQueryExtension(dpy, &foo, &foo))
1160 if (!XCompositeQueryVersion(dpy, &majorrev, &minorrev))
1162 print_standard_extension_info(dpy, extname, majorrev, minorrev);
1170 print_xinerama_info(Display *dpy, char *extname)
1172 int majorrev, minorrev;
1174 if (!XineramaQueryVersion (dpy, &majorrev, &minorrev))
1177 print_standard_extension_info(dpy, extname, majorrev, minorrev);
1179 if (!XineramaIsActive(dpy)) {
1180 printf(" Xinerama is inactive.\n");
1183 XineramaScreenInfo *xineramaScreens = XineramaQueryScreens(dpy, &count);
1185 for (i = 0; i < count; i++) {
1186 XineramaScreenInfo *xs = &xineramaScreens[i];
1187 printf(" head #%d: %dx%d @ %d,%d\n", xs->screen_number,
1188 xs->width, xs->height, xs->x_org, xs->y_org);
1191 XFree(xineramaScreens);
1197 #endif /* PANORAMIX */
1200 static const char *core(DMXInputAttributes *iinfo)
1202 if (iinfo->isCore) return "core";
1203 else if (iinfo->sendsCore) return "extension (sends core)";
1204 else return "extension";
1207 static int print_dmx_info(Display *dpy, char *extname)
1209 int event_base, error_base;
1210 int major_version, minor_version, patch_version;
1211 DMXScreenAttributes sinfo;
1212 DMXInputAttributes iinfo;
1216 if (!DMXQueryExtension(dpy, &event_base, &error_base)
1217 || !DMXQueryVersion(dpy, &major_version, &minor_version,
1218 &patch_version)) return 0;
1219 print_standard_extension_info(dpy, extname, major_version, minor_version);
1220 printf(" Version stamp: %d\n", patch_version);
1222 if (!DMXGetScreenCount(dpy, &count)) return 1;
1223 printf(" Screen count: %d\n", count);
1224 for (i = 0; i < count; i++) {
1225 if (DMXGetScreenAttributes(dpy, i, &sinfo)) {
1226 printf(" %2d %s %ux%u+%d+%d %d @%dx%d\n",
1227 i, sinfo.displayName,
1228 sinfo.screenWindowWidth, sinfo.screenWindowHeight,
1229 sinfo.screenWindowXoffset, sinfo.screenWindowYoffset,
1230 sinfo.logicalScreen,
1231 sinfo.rootWindowXorigin, sinfo.rootWindowYorigin);
1235 if (major_version != 1
1236 || minor_version < 1
1237 || !DMXGetInputCount(dpy, &count))
1240 printf(" Input count = %d\n", count);
1241 for (i = 0; i < count; i++) {
1244 char *backendname = NULL;
1246 if (DMXGetInputAttributes(dpy, i, &iinfo)) {
1247 switch (iinfo.inputType) {
1248 case DMXLocalInputType:
1249 printf(" %2d local %s", i, core(&iinfo));
1251 case DMXConsoleInputType:
1252 printf(" %2d console %s %s", i, core(&iinfo),
1255 case DMXBackendInputType:
1257 if (iinfo.physicalId >= 0) {
1258 if ((backend = XOpenDisplay(iinfo.name))) {
1259 XExtensionVersion *ext
1260 = XGetExtensionVersion(backend, INAME);
1262 && ext != (XExtensionVersion *)NoSuchExtension) {
1265 XDeviceInfo *devInfo = XListInputDevices(backend,
1268 for (i = 0; i < count; i++) {
1269 if ((unsigned)iinfo.physicalId
1271 && devInfo[i].name) {
1272 backendname = strdup(devInfo[i].name);
1276 XFreeDeviceList(devInfo);
1279 XCloseDisplay(backend);
1283 printf(" %2d backend %s o%d/%s",i, core(&iinfo),
1284 iinfo.physicalScreen, iinfo.name);
1285 if (iinfo.physicalId >= 0) printf("/id%d", iinfo.physicalId);
1288 printf("=%s", backendname);
1302 /* utilities to manage the list of recognized extensions */
1305 typedef int (*ExtensionPrintFunc)(
1311 ExtensionPrintFunc printfunc;
1313 } ExtensionPrintInfo;
1315 static ExtensionPrintInfo known_extensions[] =
1318 {"MIT-SHM", print_mitshm_info, False},
1321 {XkbName, print_xkb_info, False},
1324 {MULTIBUFFER_PROTOCOL_NAME, print_multibuf_info, False},
1326 {"SHAPE", print_shape_info, False},
1327 {SYNC_NAME, print_sync_info, False},
1329 {XF86DGANAME, print_dga_info, False},
1330 #endif /* XFreeXDGA */
1332 {XF86VIDMODENAME, print_XF86VidMode_info, False},
1333 #endif /* XF86VIDMODE */
1335 {XF86MISCNAME, print_XF86Misc_info, False},
1336 #endif /* XF86MISC */
1337 {XTestExtensionName, print_xtest_info, False},
1338 {"DOUBLE-BUFFER", print_dbe_info, False},
1339 {"RECORD", print_record_info, False},
1341 {INAME, print_xinput_info, False},
1344 {RENDER_NAME, print_xrender_info, False},
1347 {COMPOSITE_NAME, print_composite_info, False},
1350 {"XINERAMA", print_xinerama_info, False},
1353 {"DMX", print_dmx_info, False},
1355 /* add new extensions here */
1358 static int num_known_extensions = sizeof known_extensions / sizeof known_extensions[0];
1361 print_known_extensions(FILE *f)
1364 for (i = 0, col = 6; i < num_known_extensions; i++)
1366 int extlen = strlen(known_extensions[i].extname) + 1;
1368 if ((col + extlen) > 79)
1373 fprintf(f, "%s ", known_extensions[i].extname);
1379 mark_extension_for_printing(char *extname)
1383 if (strcmp(extname, "all") == 0)
1385 for (i = 0; i < num_known_extensions; i++)
1386 known_extensions[i].printit = True;
1390 for (i = 0; i < num_known_extensions; i++)
1392 if (strcmp(extname, known_extensions[i].extname) == 0)
1394 known_extensions[i].printit = True;
1398 printf("%s extension not supported by %s\n", extname, ProgramName);
1403 print_marked_extensions(Display *dpy)
1406 for (i = 0; i < num_known_extensions; i++)
1408 if (known_extensions[i].printit)
1411 if (! (*known_extensions[i].printfunc)(dpy,
1412 known_extensions[i].extname))
1414 printf("%s extension not supported by server\n",
1415 known_extensions[i].extname);
1424 fprintf (stderr, "usage: %s [options]\n", ProgramName);
1425 fprintf (stderr, "-display displayname\tserver to query\n");
1426 fprintf (stderr, "-queryExtensions\tprint info returned by XQueryExtension\n");
1427 fprintf (stderr, "-ext all\t\tprint detailed info for all supported extensions\n");
1428 fprintf (stderr, "-ext extension-name\tprint detailed info for extension-name if one of:\n ");
1429 print_known_extensions(stderr);
1430 fprintf (stderr, "\n");
1435 main(int argc, char *argv[])
1437 Display *dpy; /* X connection */
1438 char *displayname = NULL; /* server to contact */
1439 int i; /* temp variable: iterator */
1441 ProgramName = argv[0];
1443 for (i = 1; i < argc; i++) {
1444 char *arg = argv[i];
1445 int len = strlen(arg);
1447 if (!strncmp("-display", arg, len)) {
1448 if (++i >= argc) usage ();
1449 displayname = argv[i];
1450 } else if (!strncmp("-queryExtensions", arg, len)) {
1451 queryExtensions = True;
1452 } else if (!strncmp("-ext", arg, len)) {
1453 if (++i >= argc) usage ();
1454 mark_extension_for_printing(argv[i]);
1459 dpy = XOpenDisplay (displayname);
1461 fprintf (stderr, "%s: unable to open display \"%s\".\n",
1462 ProgramName, XDisplayName (displayname));
1466 print_display_info (dpy);
1467 for (i = 0; i < ScreenCount (dpy); i++) {
1468 print_screen_info (dpy, i);
1471 print_marked_extensions(dpy);
1473 XCloseDisplay (dpy);