summaryrefslogtreecommitdiffstats
path: root/driver/xdpyinfo.c
diff options
context:
space:
mode:
Diffstat (limited to 'driver/xdpyinfo.c')
-rw-r--r--driver/xdpyinfo.c1098
1 files changed, 1098 insertions, 0 deletions
diff --git a/driver/xdpyinfo.c b/driver/xdpyinfo.c
new file mode 100644
index 0000000..9f67966
--- /dev/null
+++ b/driver/xdpyinfo.c
@@ -0,0 +1,1098 @@
+/*
+ * $ TOG: xdpyinfo.c /main/35 1998/02/09 13:57:05 kaleb $
+ *
+ * xdpyinfo - print information about X display connecton
+ *
+ *
+Copyright 1988, 1998 The Open Group
+
+All Rights Reserved.
+
+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.
+ *
+ * Author: Jim Fulton, MIT X Consortium
+ *
+ * GLX and Overlay support added by Jamie Zawinski <jwz@jwz.org>, 11-Nov-99
+ *
+ * To compile:
+ * cc -DHAVE_GLX xdpyinfo.c -o xdpyinfo -lGL -lX11 -lXext [-lXtst] -lm
+ *
+ * Other defines to consider:
+ * -DMITSHM -DHAVE_XDBE -DHAVE_XIE -DHAVE_XTEST -DHAVE_SYNC
+ * -DHAVE_XRECORD
+ */
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xproto.h> /* for CARD32 */
+#include <X11/extensions/multibuf.h>
+#ifdef HAVE_XIE
+#include <X11/extensions/XIElib.h>
+#endif /* HAVE_XIE */
+#ifdef HAVE_XTEST
+#include <X11/extensions/XTest.h>
+#endif /* HAVE_XTEST */
+#ifdef HAVE_XSYNC
+#include <X11/extensions/sync.h>
+#endif /* HAVE_XSYNC */
+#ifdef HAVE_XDBE
+#include <X11/extensions/Xdbe.h>
+#endif /* HAVE_XDBE */
+#ifdef HAVE_XRECORD
+#include <X11/extensions/record.h>
+#endif /* HAVE_XRECORD */
+#ifdef MITSHM
+#include <X11/extensions/XShm.h>
+#endif
+#include <X11/Xos.h>
+#include <stdio.h>
+
+#ifdef HAVE_GLX
+# include <GL/gl.h>
+# include <GL/glx.h>
+#endif /* HAVE_GLX */
+
+#define HAVE_OVERLAY /* jwz: no compile-time deps, so do this all the time */
+
+char *ProgramName;
+Bool queryExtensions = False;
+
+static int StrCmp(a, b)
+ char **a, **b;
+{
+ return strcmp(*a, *b);
+}
+
+
+#ifdef HAVE_GLX /* Added by jwz, 11-Nov-99 */
+
+static void
+print_glx_versions (dpy)
+ Display *dpy;
+{
+ /* Note: with Mesa 3.0, this lies: it prints the info from the
+ client's GL library, rather than the info from the GLX server.
+
+ Note also that we can't protect these calls by only doing
+ them when the GLX extension is present, because with Mesa,
+ the server doesn't have that extension (but the GL library
+ works anyway.)
+ */
+ int scr = DefaultScreen (dpy);
+ const char *vend, *vers;
+ vend = glXQueryServerString (dpy, scr, GLX_VENDOR);
+ if (!vend) return;
+ vers = glXQueryServerString (dpy, scr, GLX_VERSION);
+ printf ("GLX vendor: %s (%s)\n",
+ vend, (vers ? vers : "unknown version"));
+}
+
+static void
+print_glx_visual_info (dpy, vip)
+ Display *dpy;
+ XVisualInfo *vip;
+{
+ int status, value = False;
+
+ status = glXGetConfig (dpy, vip, GLX_USE_GL, &value);
+ if (status == GLX_NO_EXTENSION)
+ /* dpy does not support the GLX extension. */
+ return;
+
+ if (status == GLX_BAD_VISUAL || value == False)
+ {
+ printf (" GLX supported: no\n");
+ return;
+ }
+ else
+ {
+ printf (" GLX supported: yes\n");
+ }
+
+ if (!glXGetConfig (dpy, vip, GLX_LEVEL, &value) &&
+ value != 0)
+ printf (" GLX level: %d\n", value);
+
+ if (!glXGetConfig (dpy, vip, GLX_RGBA, &value) && value)
+ {
+ int r=0, g=0, b=0, a=0;
+ glXGetConfig (dpy, vip, GLX_RED_SIZE, &r);
+ glXGetConfig (dpy, vip, GLX_GREEN_SIZE, &g);
+ glXGetConfig (dpy, vip, GLX_BLUE_SIZE, &b);
+ glXGetConfig (dpy, vip, GLX_ALPHA_SIZE, &a);
+ printf (" GLX type: RGBA (%2d, %2d, %2d, %2d)\n",
+ r, g, b, a);
+
+ r=0, g=0, b=0, a=0;
+ glXGetConfig (dpy, vip, GLX_ACCUM_RED_SIZE, &r);
+ glXGetConfig (dpy, vip, GLX_ACCUM_GREEN_SIZE, &g);
+ glXGetConfig (dpy, vip, GLX_ACCUM_BLUE_SIZE, &b);
+ glXGetConfig (dpy, vip, GLX_ACCUM_ALPHA_SIZE, &a);
+ printf (" GLX accum: RGBA (%2d, %2d, %2d, %2d)\n",
+ r, g, b, a);
+ }
+ else
+ {
+ value = 0;
+ glXGetConfig (dpy, vip, GLX_BUFFER_SIZE, &value);
+ printf (" GLX type: indexed (%d)\n", value);
+ }
+
+# if 0 /* redundant */
+ if (!glXGetConfig (dpy, vip, GLX_X_VISUAL_TYPE_EXT, &value))
+ printf (" GLX class: %s\n",
+ (value == GLX_TRUE_COLOR_EXT ? "TrueColor" :
+ value == GLX_DIRECT_COLOR_EXT ? "DirectColor" :
+ value == GLX_PSEUDO_COLOR_EXT ? "PseudoColor" :
+ value == GLX_STATIC_COLOR_EXT ? "StaticColor" :
+ value == GLX_GRAY_SCALE_EXT ? "Grayscale" :
+ value == GLX_STATIC_GRAY_EXT ? "StaticGray" : "???"));
+# endif
+
+# ifdef GLX_VISUAL_CAVEAT_EXT
+ if (!glXGetConfig (dpy, vip, GLX_VISUAL_CAVEAT_EXT, &value) &&
+ value != GLX_NONE_EXT)
+ printf (" GLX rating: %s\n",
+ (value == GLX_NONE_EXT ? "none" :
+ value == GLX_SLOW_VISUAL_EXT ? "slow" :
+# ifdef GLX_NON_CONFORMANT_EXT
+ value == GLX_NON_CONFORMANT_EXT ? "non-conformant" :
+# endif
+ "???"));
+# endif
+
+ if (!glXGetConfig (dpy, vip, GLX_DOUBLEBUFFER, &value))
+ printf (" GLX double-buffer: %s\n", (value ? "yes" : "no"));
+
+ if (!glXGetConfig (dpy, vip, GLX_STEREO, &value) &&
+ value)
+ printf (" GLX stereo: %s\n", (value ? "yes" : "no"));
+
+ if (!glXGetConfig (dpy, vip, GLX_AUX_BUFFERS, &value) &&
+ value != 0)
+ printf (" GLX aux buffers: %d\n", value);
+
+ if (!glXGetConfig (dpy, vip, GLX_DEPTH_SIZE, &value))
+ printf (" GLX depth size: %d\n", value);
+
+ if (!glXGetConfig (dpy, vip, GLX_STENCIL_SIZE, &value) &&
+ value != 0)
+ printf (" GLX stencil size: %d\n", value);
+
+# if defined(GL_SAMPLE_BUFFERS)
+# define SB GL_SAMPLE_BUFFERS
+# define SM GL_SAMPLES
+# elif defined(GLX_SAMPLE_BUFFERS)
+# define SB GLX_SAMPLE_BUFFERS
+# define SM GLX_SAMPLES
+# elif defined(GLX_SAMPLE_BUFFERS_ARB)
+# define SB GLX_SAMPLE_BUFFERS_ARB
+# define SM GLX_SAMPLES_ARB
+# elif defined(GLX_SAMPLE_BUFFERS_SGIS)
+# define SB GLX_SAMPLE_BUFFERS_SGIS
+# define SM GLX_SAMPLES_SGIS
+# endif
+
+# ifdef SB
+ if (!glXGetConfig (dpy, vip, SB, &value) && value != 0)
+ {
+ int bufs = value;
+ if (!glXGetConfig (dpy, vip, SM, &value))
+ printf (" GLX multisample: %d, %d\n", bufs, value);
+ }
+# endif /* SB */
+
+ if (!glXGetConfig (dpy, vip, GLX_TRANSPARENT_TYPE_EXT, &value) &&
+ value != GLX_NONE_EXT)
+ {
+ if (value == GLX_NONE_EXT)
+ printf (" GLX transparency: none\n");
+ else if (value == GLX_TRANSPARENT_INDEX_EXT)
+ {
+ if (!glXGetConfig (dpy, vip, GLX_TRANSPARENT_INDEX_VALUE_EXT,&value))
+ printf (" GLX transparency: indexed (%d)\n", value);
+ }
+ else if (value == GLX_TRANSPARENT_RGB_EXT)
+ {
+ int r=0, g=0, b=0, a=0;
+ glXGetConfig (dpy, vip, GLX_TRANSPARENT_RED_VALUE_EXT, &r);
+ glXGetConfig (dpy, vip, GLX_TRANSPARENT_GREEN_VALUE_EXT, &g);
+ glXGetConfig (dpy, vip, GLX_TRANSPARENT_BLUE_VALUE_EXT, &b);
+ glXGetConfig (dpy, vip, GLX_TRANSPARENT_ALPHA_VALUE_EXT, &a);
+ printf (" GLX transparency: RGBA (%2d, %2d, %2d, %2d)\n",
+ r, g, b, a);
+ }
+ }
+}
+#endif /* HAVE_GLX */
+
+
+#ifdef HAVE_OVERLAY /* Added by jwz, 11-Nov-99 */
+
+ /* If the server's root window contains a SERVER_OVERLAY_VISUALS property,
+ then that identifies the visuals which correspond to the video hardware's
+ overlay planes. Windows created in these kinds of visuals may have
+ transparent pixels that let other layers shine through.
+
+ This might not be an X Consortium standard, but it turns out that
+ SGI, HP, DEC, and IBM all use this same mechanism. So that's close
+ enough for me.
+
+ Documentation on the SERVER_OVERLAY_VISUALS property can be found at:
+ http://www.hp.com/xwindow/sharedInfo/Whitepapers/Visuals/server_overlay_visuals.html
+ */
+
+struct overlay
+{
+ CARD32 visual_id;
+ CARD32 transparency; /* 0: none; 1: pixel; 2: mask */
+ CARD32 value; /* the transparent pixel */
+ CARD32 layer; /* -1: underlay; 0: normal; 1: popup; 2: overlay */
+};
+
+struct overlay_list
+{
+ int count;
+ struct overlay *list;
+};
+
+static struct overlay_list *overlays = 0;
+
+static void
+find_overlay_info (dpy)
+ Display *dpy;
+{
+ int screen;
+ Atom OVERLAY = XInternAtom (dpy, "SERVER_OVERLAY_VISUALS", False);
+
+ overlays = (struct overlay_list *) calloc (sizeof (struct overlay_list),
+ ScreenCount (dpy));
+
+ for (screen = 0; screen < ScreenCount (dpy); screen++)
+ {
+ Window window = RootWindow (dpy, screen);
+ Atom actual_type;
+ int actual_format;
+ unsigned long nitems, bytes_after;
+ struct overlay *data = 0;
+ int result = XGetWindowProperty (dpy, window, OVERLAY,
+ 0, (65536 / sizeof (long)), False,
+ OVERLAY, &actual_type, &actual_format,
+ &nitems, &bytes_after,
+ (unsigned char **) &data);
+ if (result == Success &&
+ actual_type == OVERLAY &&
+ actual_format == 32 &&
+ nitems > 0)
+ {
+ overlays[screen].count = (nitems /
+ (sizeof(struct overlay) / sizeof(CARD32)));
+ overlays[screen].list = data;
+ }
+ else if (data)
+ XFree((char *) data);
+ }
+}
+
+static void
+print_overlay_visual_info (vip)
+ XVisualInfo *vip;
+{
+ int i;
+ int vis = vip->visualid;
+ int scr = vip->screen;
+ if (!overlays) return;
+ for (i = 0; i < overlays[scr].count; i++)
+ if (vis == overlays[scr].list[i].visual_id)
+ {
+ struct overlay *ov = &overlays[scr].list[i];
+ printf (" Overlay info: layer %ld (%s), ",
+ (long) ov->layer,
+ (ov->layer == -1 ? "underlay" :
+ ov->layer == 0 ? "normal" :
+ ov->layer == 1 ? "popup" :
+ ov->layer == 2 ? "overlay" : "???"));
+ if (ov->transparency == 1)
+ printf ("transparent pixel %lu\n", (unsigned long) ov->value);
+ else if (ov->transparency == 2)
+ printf ("transparent mask 0x%x\n", (unsigned long) ov->value);
+ else
+ printf ("opaque\n");
+ }
+}
+#endif /* HAVE_OVERLAY */
+
+
+void
+print_extension_info (dpy)
+ Display *dpy;
+{
+ int n = 0;
+ char **extlist = XListExtensions (dpy, &n);
+
+ printf ("number of extensions: %d\n", n);
+
+ if (extlist) {
+ register int i;
+ int opcode, event, error;
+
+ qsort(extlist, n, sizeof(char *), StrCmp);
+ for (i = 0; i < n; i++) {
+ if (!queryExtensions) {
+ printf (" %s\n", extlist[i]);
+ continue;
+ }
+ XQueryExtension(dpy, extlist[i], &opcode, &event, &error);
+ printf (" %s (opcode: %d", extlist[i], opcode);
+ if (event)
+ printf (", base event: %d", event);
+ if (error)
+ printf (", base error: %d", error);
+ printf(")\n");
+ }
+ /* do not free, Xlib can depend on contents being unaltered */
+ /* XFreeExtensionList (extlist); */
+ }
+}
+
+void
+print_display_info (dpy)
+ Display *dpy;
+{
+ char dummybuf[40];
+ char *cp;
+ int minkeycode, maxkeycode;
+ int i, n;
+ long req_size;
+ XPixmapFormatValues *pmf;
+ Window focuswin;
+ int focusrevert;
+
+ printf ("name of display: %s\n", DisplayString (dpy));
+ printf ("version number: %d.%d\n",
+ ProtocolVersion (dpy), ProtocolRevision (dpy));
+ printf ("vendor string: %s\n", ServerVendor (dpy));
+ printf ("vendor release number: %d\n", VendorRelease (dpy));
+
+#ifdef HAVE_GLX
+ print_glx_versions (dpy);
+#endif /* HAVE_GLX */
+
+ req_size = XExtendedMaxRequestSize (dpy);
+ if (!req_size) req_size = XMaxRequestSize (dpy);
+ printf ("maximum request size: %ld bytes\n", req_size * 4);
+ printf ("motion buffer size: %d\n", XDisplayMotionBufferSize (dpy));
+
+ switch (BitmapBitOrder (dpy)) {
+ case LSBFirst: cp = "LSBFirst"; break;
+ case MSBFirst: cp = "MSBFirst"; break;
+ default:
+ sprintf (dummybuf, "unknown order %d", BitmapBitOrder (dpy));
+ cp = dummybuf;
+ break;
+ }
+ printf ("bitmap unit, bit order, padding: %d, %s, %d\n",
+ BitmapUnit (dpy), cp, BitmapPad (dpy));
+
+ switch (ImageByteOrder (dpy)) {
+ case LSBFirst: cp = "LSBFirst"; break;
+ case MSBFirst: cp = "MSBFirst"; break;
+ default:
+ sprintf (dummybuf, "unknown order %d", ImageByteOrder (dpy));
+ cp = dummybuf;
+ break;
+ }
+ printf ("image byte order: %s\n", cp);
+
+ pmf = XListPixmapFormats (dpy, &n);
+ printf ("number of supported pixmap formats: %d\n", n);
+ if (pmf) {
+ printf ("supported pixmap formats:\n");
+ for (i = 0; i < n; i++) {
+ printf (" depth %d, bits_per_pixel %d, scanline_pad %d\n",
+ pmf[i].depth, pmf[i].bits_per_pixel, pmf[i].scanline_pad);
+ }
+ XFree ((char *) pmf);
+ }
+
+
+ /*
+ * when we get interfaces to the PixmapFormat stuff, insert code here
+ */
+
+ XDisplayKeycodes (dpy, &minkeycode, &maxkeycode);
+ printf ("keycode range: minimum %d, maximum %d\n",
+ minkeycode, maxkeycode);
+
+ XGetInputFocus (dpy, &focuswin, &focusrevert);
+ printf ("focus: ");
+ switch (focuswin) {
+ case PointerRoot:
+ printf ("PointerRoot\n");
+ break;
+ case None:
+ printf ("None\n");
+ break;
+ default:
+ printf("window 0x%lx, revert to ", focuswin);
+ switch (focusrevert) {
+ case RevertToParent:
+ printf ("Parent\n");
+ break;
+ case RevertToNone:
+ printf ("None\n");
+ break;
+ case RevertToPointerRoot:
+ printf ("PointerRoot\n");
+ break;
+ default: /* should not happen */
+ printf ("%d\n", focusrevert);
+ break;
+ }
+ break;
+ }
+
+ print_extension_info (dpy);
+
+ printf ("default screen number: %d\n", DefaultScreen (dpy));
+ printf ("number of screens: %d\n", ScreenCount (dpy));
+}
+
+void
+print_visual_info (vip)
+ XVisualInfo *vip;
+{
+ char errorbuf[40]; /* for sprintfing into */
+ char *class = NULL; /* for printing */
+
+ switch (vip->class) {
+ case StaticGray: class = "StaticGray"; break;
+ case GrayScale: class = "GrayScale"; break;
+ case StaticColor: class = "StaticColor"; break;
+ case PseudoColor: class = "PseudoColor"; break;
+ case TrueColor: class = "TrueColor"; break;
+ case DirectColor: class = "DirectColor"; break;
+ default:
+ sprintf (errorbuf, "unknown class %d", vip->class);
+ class = errorbuf;
+ break;
+ }
+
+ printf (" visual:\n");
+ printf (" visual id: 0x%lx\n", vip->visualid);
+ printf (" class: %s\n", class);
+ printf (" depth: %d plane%s\n", vip->depth,
+ vip->depth == 1 ? "" : "s");
+ if (vip->class == TrueColor || vip->class == DirectColor)
+ printf (" available colormap entries: %d per subfield\n",
+ vip->colormap_size);
+ else
+ printf (" available colormap entries: %d\n",
+ vip->colormap_size);
+ printf (" red, green, blue masks: 0x%lx, 0x%lx, 0x%lx\n",
+ vip->red_mask, vip->green_mask, vip->blue_mask);
+ printf (" significant bits in color specification: %d bits\n",
+ vip->bits_per_rgb);
+}
+
+void
+print_screen_info (dpy, scr)
+ Display *dpy;
+ int scr;
+{
+ Screen *s = ScreenOfDisplay (dpy, scr); /* opaque structure */
+ XVisualInfo viproto; /* fill in for getting info */
+ XVisualInfo *vip; /* retured info */
+ int nvi; /* number of elements returned */
+ int i; /* temp variable: iterator */
+ char eventbuf[80]; /* want 79 chars per line + nul */
+ static char *yes = "YES", *no = "NO", *when = "WHEN MAPPED";
+ double xres, yres;
+ int ndepths = 0, *depths = NULL;
+ unsigned int width, height;
+
+
+ /*
+ * there are 2.54 centimeters to an inch; so there are 25.4 millimeters.
+ *
+ * dpi = N pixels / (M millimeters / (25.4 millimeters / 1 inch))
+ * = N pixels / (M inch / 25.4)
+ * = N * 25.4 pixels / M inch
+ */
+
+ xres = ((((double) DisplayWidth(dpy,scr)) * 25.4) /
+ ((double) DisplayWidthMM(dpy,scr)));
+ yres = ((((double) DisplayHeight(dpy,scr)) * 25.4) /
+ ((double) DisplayHeightMM(dpy,scr)));
+
+ printf ("\n");
+ printf ("screen #%d:\n", scr);
+ printf (" dimensions: %dx%d pixels (%dx%d millimeters)\n",
+ DisplayWidth (dpy, scr), DisplayHeight (dpy, scr),
+ DisplayWidthMM(dpy, scr), DisplayHeightMM (dpy, scr));
+ printf (" resolution: %dx%d dots per inch\n",
+ (int) (xres + 0.5), (int) (yres + 0.5));
+ depths = XListDepths (dpy, scr, &ndepths);
+ if (!depths) ndepths = 0;
+ printf (" depths (%d): ", ndepths);
+ for (i = 0; i < ndepths; i++) {
+ printf ("%d", depths[i]);
+ if (i < ndepths - 1) {
+ putchar (',');
+ putchar (' ');
+ }
+ }
+ putchar ('\n');
+ if (depths) XFree ((char *) depths);
+ printf (" root window id: 0x%lx\n", RootWindow (dpy, scr));
+ printf (" depth of root window: %d plane%s\n",
+ DisplayPlanes (dpy, scr),
+ DisplayPlanes (dpy, scr) == 1 ? "" : "s");
+ printf (" number of colormaps: minimum %d, maximum %d\n",
+ MinCmapsOfScreen(s), MaxCmapsOfScreen(s));
+ printf (" default colormap: 0x%lx\n", DefaultColormap (dpy, scr));
+ printf (" default number of colormap cells: %d\n",
+ DisplayCells (dpy, scr));
+ printf (" preallocated pixels: black %d, white %d\n",
+ BlackPixel (dpy, scr), WhitePixel (dpy, scr));
+ printf (" options: backing-store %s, save-unders %s\n",
+ (DoesBackingStore (s) == NotUseful) ? no :
+ ((DoesBackingStore (s) == Always) ? yes : when),
+ DoesSaveUnders (s) ? yes : no);
+ XQueryBestSize (dpy, CursorShape, RootWindow (dpy, scr), 65535, 65535,
+ &width, &height);
+ if (width == 65535 && height == 65535)
+ printf (" largest cursor: unlimited\n");
+ else
+ printf (" largest cursor: %dx%d\n", width, height);
+ printf (" current input event mask: 0x%lx\n", EventMaskOfScreen (s));
+ (void) print_event_mask (eventbuf, 79, 4, EventMaskOfScreen (s));
+
+
+ nvi = 0;
+ viproto.screen = scr;
+ vip = XGetVisualInfo (dpy, VisualScreenMask, &viproto, &nvi);
+ printf (" number of visuals: %d\n", nvi);
+ printf (" default visual id: 0x%lx\n",
+ XVisualIDFromVisual (DefaultVisual (dpy, scr)));
+ for (i = 0; i < nvi; i++) {
+ print_visual_info (vip+i);
+#ifdef HAVE_OVERLAY
+ print_overlay_visual_info (vip+i);
+#endif /* HAVE_OVERLAY */
+#ifdef HAVE_GLX
+ print_glx_visual_info (dpy, vip+i);
+#endif /* HAVE_GLX */
+ }
+ if (vip) XFree ((char *) vip);
+}
+
+/*
+ * The following routine prints out an event mask, wrapping events at nice
+ * boundaries.
+ */
+
+#define MASK_NAME_WIDTH 25
+
+static struct _event_table {
+ char *name;
+ long value;
+} event_table[] = {
+ { "KeyPressMask ", KeyPressMask },
+ { "KeyReleaseMask ", KeyReleaseMask },
+ { "ButtonPressMask ", ButtonPressMask },
+ { "ButtonReleaseMask ", ButtonReleaseMask },
+ { "EnterWindowMask ", EnterWindowMask },
+ { "LeaveWindowMask ", LeaveWindowMask },
+ { "PointerMotionMask ", PointerMotionMask },
+ { "PointerMotionHintMask ", PointerMotionHintMask },
+ { "Button1MotionMask ", Button1MotionMask },
+ { "Button2MotionMask ", Button2MotionMask },
+ { "Button3MotionMask ", Button3MotionMask },
+ { "Button4MotionMask ", Button4MotionMask },
+ { "Button5MotionMask ", Button5MotionMask },
+ { "ButtonMotionMask ", ButtonMotionMask },
+ { "KeymapStateMask ", KeymapStateMask },
+ { "ExposureMask ", ExposureMask },
+ { "VisibilityChangeMask ", VisibilityChangeMask },
+ { "StructureNotifyMask ", StructureNotifyMask },
+ { "ResizeRedirectMask ", ResizeRedirectMask },
+ { "SubstructureNotifyMask ", SubstructureNotifyMask },
+ { "SubstructureRedirectMask ", SubstructureRedirectMask },
+ { "FocusChangeMask ", FocusChangeMask },
+ { "PropertyChangeMask ", PropertyChangeMask },
+ { "ColormapChangeMask ", ColormapChangeMask },
+ { "OwnerGrabButtonMask ", OwnerGrabButtonMask },
+ { NULL, 0 }};
+
+int print_event_mask (buf, lastcol, indent, mask)
+ char *buf; /* string to write into */
+ int lastcol; /* strlen(buf)+1 */
+ int indent; /* amount by which to indent */
+ long mask; /* event mask */
+{
+ struct _event_table *etp;
+ int len;
+ int bitsfound = 0;
+
+ buf[0] = buf[lastcol] = '\0'; /* just in case */
+
+#define INDENT() { register int i; len = indent; \
+ for (i = 0; i < indent; i++) buf[i] = ' '; }
+
+ INDENT ();
+
+ for (etp = event_table; etp->name; etp++) {
+ if (mask & etp->value) {
+ if (len + MASK_NAME_WIDTH > lastcol) {
+ puts (buf);
+ INDENT ();
+ }
+ strcpy (buf+len, etp->name);
+ len += MASK_NAME_WIDTH;
+ bitsfound++;
+ }
+ }
+
+ if (bitsfound) puts (buf);
+
+#undef INDENT
+
+ return (bitsfound);
+}
+
+void
+print_standard_extension_info(dpy, extname, majorrev, minorrev)
+ Display *dpy;
+ char *extname;
+ int majorrev, minorrev;
+{
+ int opcode, event, error;
+
+ printf("%s version %d.%d ", extname, majorrev, minorrev);
+
+ XQueryExtension(dpy, extname, &opcode, &event, &error);
+ printf ("opcode: %d", opcode);
+ if (event)
+ printf (", base event: %d", event);
+ if (error)
+ printf (", base error: %d", error);
+ printf("\n");
+}
+
+int
+print_multibuf_info(dpy, extname)
+ Display *dpy;
+ char *extname;
+{
+ int i, j; /* temp variable: iterator */
+ int nmono, nstereo; /* count */
+ XmbufBufferInfo *mono_info = NULL, *stereo_info = NULL; /* arrays */
+ static char *fmt =
+ " visual id, max buffers, depth: 0x%lx, %d, %d\n";
+ int scr = 0;
+ int majorrev, minorrev;
+
+ if (!XmbufGetVersion(dpy, &majorrev, &minorrev))
+ return 0;
+
+ print_standard_extension_info(dpy, extname, majorrev, minorrev);
+
+ for (i = 0; i < ScreenCount (dpy); i++)
+ {
+ if (!XmbufGetScreenInfo (dpy, RootWindow(dpy, scr), &nmono, &mono_info,
+ &nstereo, &stereo_info)) {
+ fprintf (stderr,
+ "%s: unable to get multibuffer info for screen %d\n",
+ ProgramName, scr);
+ } else {
+ printf (" screen %d number of mono multibuffer types: %d\n", i, nmono);
+ for (j = 0; j < nmono; j++) {
+ printf (fmt, mono_info[j].visualid, mono_info[j].max_buffers,
+ mono_info[j].depth);
+ }
+ printf (" number of stereo multibuffer types: %d\n", nstereo);
+ for (j = 0; j < nstereo; j++) {
+ printf (fmt, stereo_info[j].visualid,
+ stereo_info[j].max_buffers, stereo_info[j].depth);
+ }
+ if (mono_info) XFree ((char *) mono_info);
+ if (stereo_info) XFree ((char *) stereo_info);
+ }
+ }
+ return 1;
+} /* end print_multibuf_info */
+
+
+/* XIE stuff */
+
+#ifdef HAVE_XIE
+
+char *subset_names[] = { NULL, "FULL", "DIS" };
+char *align_names[] = { NULL, "Alignable", "Arbitrary" };
+char *group_names[] = { /* 0 */ "Default",
+ /* 2 */ "ColorAlloc",
+ /* 4 */ "Constrain",
+ /* 6 */ "ConvertFromRGB",
+ /* 8 */ "ConvertToRGB",
+ /* 10 */ "Convolve",
+ /* 12 */ "Decode",
+ /* 14 */ "Dither",
+ /* 16 */ "Encode",
+ /* 18 */ "Gamut",
+ /* 20 */ "Geometry",
+ /* 22 */ "Histogram",
+ /* 24 */ "WhiteAdjust"
+ };
+
+int
+print_xie_info(dpy, extname)
+ Display *dpy;
+ char *extname;
+{
+ XieExtensionInfo *xieInfo;
+ int i;
+ int ntechs;
+ XieTechnique *techs;
+ XieTechniqueGroup prevGroup;
+
+ if (!XieInitialize(dpy, &xieInfo ))
+ return 0;
+
+ print_standard_extension_info(dpy, extname,
+ xieInfo->server_major_rev, xieInfo->server_minor_rev);
+
+ printf(" service class: %s\n", subset_names[xieInfo->service_class]);
+ printf(" alignment: %s\n", align_names[xieInfo->alignment]);
+ printf(" uncnst_mantissa: %d\n", xieInfo->uncnst_mantissa);
+ printf(" uncnst_min_exp: %d\n", xieInfo->uncnst_min_exp);
+ printf(" uncnst_max_exp: %d\n", xieInfo->uncnst_max_exp);
+ printf(" cnst_levels:");
+ for (i = 0; i < xieInfo->n_cnst_levels; i++)
+ printf(" %d", xieInfo->cnst_levels[i]);
+ printf("\n");
+
+ if (!XieQueryTechniques(dpy, xieValAll, &ntechs, &techs))
+ return 1;
+
+ prevGroup = -1;
+
+ for (i = 0; i < ntechs; i++)
+ {
+ if (techs[i].group != prevGroup)
+ {
+ printf(" technique group: %s\n", group_names[techs[i].group >> 1]);
+ prevGroup = techs[i].group;
+ }
+ printf(" %s\tspeed: %d needs_param: %s number: %d\n",
+ techs[i].name,
+ techs[i].speed, (techs[i].needs_param ? "True " : "False"),
+ techs[i].number);
+ }
+ return 1;
+} /* end print_xie_info */
+
+#endif /* HAVE_XIE */
+
+
+#ifdef HAVE_XTEST
+int
+print_xtest_info(dpy, extname)
+ Display *dpy;
+ char *extname;
+{
+ int majorrev, minorrev, foo;
+
+ if (!XTestQueryExtension(dpy, &foo, &foo, &majorrev, &minorrev))
+ return 0;
+ print_standard_extension_info(dpy, extname, majorrev, minorrev);
+ return 1;
+}
+#endif /* HAVE_XTEST */
+
+#ifdef HAVE_XSYNC
+int
+print_sync_info(dpy, extname)
+ Display *dpy;
+ char *extname;
+{
+ int majorrev, minorrev;
+ XSyncSystemCounter *syscounters;
+ int ncounters, i;
+
+ if (!XSyncInitialize(dpy, &majorrev, &minorrev))
+ return 0;
+ print_standard_extension_info(dpy, extname, majorrev, minorrev);
+
+ syscounters = XSyncListSystemCounters(dpy, &ncounters);
+ printf(" system counters: %d\n", ncounters);
+ for (i = 0; i < ncounters; i++)
+ {
+ printf(" %s id: 0x%08x resolution_lo: %d resolution_hi: %d\n",
+ syscounters[i].name, syscounters[i].counter,
+ XSyncValueLow32(syscounters[i].resolution),
+ XSyncValueHigh32(syscounters[i].resolution));
+ }
+ XSyncFreeSystemCounterList(syscounters);
+ return 1;
+}
+#endif /* HAVE_XSYNC */
+
+int
+print_shape_info(dpy, extname)
+ Display *dpy;
+ char *extname;
+{
+ int majorrev, minorrev;
+
+ if (!XShapeQueryVersion(dpy, &majorrev, &minorrev))
+ return 0;
+ print_standard_extension_info(dpy, extname, majorrev, minorrev);
+ return 1;
+}
+
+#ifdef MITSHM
+int
+print_mitshm_info(dpy, extname)
+ Display *dpy;
+ char *extname;
+{
+ int majorrev, minorrev;
+ Bool sharedPixmaps;
+
+ if (!XShmQueryVersion(dpy, &majorrev, &minorrev, &sharedPixmaps))
+ return 0;
+ print_standard_extension_info(dpy, extname, majorrev, minorrev);
+ printf(" shared pixmaps: ");
+ if (sharedPixmaps)
+ {
+ int format = XShmPixmapFormat(dpy);
+ printf("yes, format: %d\n", format);
+ }
+ else
+ {
+ printf("no\n");
+ }
+ return 1;
+}
+#endif /* MITSHM */
+
+#ifdef HAVE_XDBE
+int
+print_dbe_info(dpy, extname)
+ Display *dpy;
+ char *extname;
+{
+ int majorrev, minorrev;
+ XdbeScreenVisualInfo *svi;
+ int numscreens = 0;
+ int iscrn, ivis;
+
+ if (!XdbeQueryExtension(dpy, &majorrev, &minorrev))
+ return 0;
+
+ print_standard_extension_info(dpy, extname, majorrev, minorrev);
+ svi = XdbeGetVisualInfo(dpy, (Drawable *)NULL, &numscreens);
+ for (iscrn = 0; iscrn < numscreens; iscrn++)
+ {
+ printf(" Double-buffered visuals on screen %d\n", iscrn);
+ for (ivis = 0; ivis < svi[iscrn].count; ivis++)
+ {
+ printf(" visual id 0x%lx depth %d perflevel %d\n",
+ svi[iscrn].visinfo[ivis].visual,
+ svi[iscrn].visinfo[ivis].depth,
+ svi[iscrn].visinfo[ivis].perflevel);
+ }
+ }
+ XdbeFreeVisualInfo(svi);
+ return 1;
+}
+#endif /* HAVE_XDBE */
+
+#ifdef HAVE_XRECORD
+int
+print_record_info(dpy, extname)
+ Display *dpy;
+ char *extname;
+{
+ int majorrev, minorrev;
+
+ if (!XRecordQueryVersion(dpy, &majorrev, &minorrev))
+ return 0;
+ print_standard_extension_info(dpy, extname, majorrev, minorrev);
+ return 1;
+}
+#endif /* HAVE_XRECORD */
+
+/* utilities to manage the list of recognized extensions */
+
+
+typedef int (*ExtensionPrintFunc)(
+#if NeedFunctionPrototypes
+ Display *, char *
+#endif
+);
+
+typedef struct {
+ char *extname;
+ ExtensionPrintFunc printfunc;
+ Bool printit;
+} ExtensionPrintInfo;
+
+ExtensionPrintInfo known_extensions[] =
+{
+#ifdef MITSHM
+ {"MIT-SHM", print_mitshm_info, False},
+#endif /* MITSHM */
+ {MULTIBUFFER_PROTOCOL_NAME, print_multibuf_info, False},
+ {"SHAPE", print_shape_info, False},
+#ifdef HAVE_XSYNC
+ {SYNC_NAME, print_sync_info, False},
+#endif /* HAVE_XSYNC */
+#ifdef HAVE_XIE
+ {xieExtName, print_xie_info, False},
+#endif /* HAVE_XIE */
+#ifdef HAVE_XTEST
+ {XTestExtensionName, print_xtest_info, False},
+#endif /* HAVE_XTEST */
+#ifdef HAVE_XDBE
+ {"DOUBLE-BUFFER", print_dbe_info, False},
+#endif /* HAVE_XDBE */
+#ifdef HAVE_XRECORD
+ {"RECORD", print_record_info, False}
+#endif /* HAVE_XRECORD */
+ /* add new extensions here */
+ /* wish list: PEX XKB LBX */
+};
+
+int num_known_extensions = sizeof known_extensions / sizeof known_extensions[0];
+
+void
+print_known_extensions(f)
+ FILE *f;
+{
+ int i;
+ for (i = 0; i < num_known_extensions; i++)
+ {
+ fprintf(f, "%s ", known_extensions[i].extname);
+ }
+}
+
+void
+mark_extension_for_printing(extname)
+ char *extname;
+{
+ int i;
+
+ if (strcmp(extname, "all") == 0)
+ {
+ for (i = 0; i < num_known_extensions; i++)
+ known_extensions[i].printit = True;
+ }
+ else
+ {
+ for (i = 0; i < num_known_extensions; i++)
+ {
+ if (strcmp(extname, known_extensions[i].extname) == 0)
+ {
+ known_extensions[i].printit = True;
+ return;
+ }
+ }
+ printf("%s extension not supported by %s\n", extname, ProgramName);
+ }
+}
+
+void
+print_marked_extensions(dpy)
+ Display *dpy;
+{
+ int i;
+ for (i = 0; i < num_known_extensions; i++)
+ {
+ if (known_extensions[i].printit)
+ {
+ printf("\n");
+ if (! (*known_extensions[i].printfunc)(dpy,
+ known_extensions[i].extname))
+ {
+ printf("%s extension not supported by server\n",
+ known_extensions[i].extname);
+ }
+ }
+ }
+}
+
+static void usage ()
+{
+ fprintf (stderr, "usage: %s [options]\n", ProgramName);
+ fprintf (stderr, "-display displayname\tserver to query\n");
+ fprintf (stderr, "-queryExtensions\tprint info returned by XQueryExtension\n");
+ fprintf (stderr, "-ext all\t\tprint detailed info for all supported extensions\n");
+ fprintf (stderr, "-ext extension-name\tprint detailed info for extension-name if one of:\n ");
+ print_known_extensions(stderr);
+ fprintf (stderr, "\n");
+ exit (1);
+}
+
+int main (argc, argv)
+ int argc;
+ char *argv[];
+{
+ Display *dpy; /* X connection */
+ char *displayname = NULL; /* server to contact */
+ int i; /* temp variable: iterator */
+ Bool multibuf = False;
+ int mbuf_event_base, mbuf_error_base;
+
+ ProgramName = argv[0];
+
+ for (i = 1; i < argc; i++) {
+ char *arg = argv[i];
+ int len = strlen(arg);
+
+ if (!strncmp("-display", arg, len)) {
+ if (++i >= argc) usage ();
+ displayname = argv[i];
+ } else if (!strncmp("-queryExtensions", arg, len)) {
+ queryExtensions = True;
+ } else if (!strncmp("-ext", arg, len)) {
+ if (++i >= argc) usage ();
+ mark_extension_for_printing(argv[i]);
+ } else
+ usage ();
+ }
+
+ dpy = XOpenDisplay (displayname);
+ if (!dpy) {
+ fprintf (stderr, "%s: unable to open display \"%s\".\n",
+ ProgramName, XDisplayName (displayname));
+ exit (1);
+ }
+
+#ifdef HAVE_OVERLAY
+ find_overlay_info (dpy);
+#endif /* HAVE_OVERLAY */
+
+ print_display_info (dpy);
+ for (i = 0; i < ScreenCount (dpy); i++) {
+ print_screen_info (dpy, i);
+ }
+
+ print_marked_extensions(dpy);
+
+ XCloseDisplay (dpy);
+ exit (0);
+}
generated by cgit v1.2.3-55-g7522 (git 2.39.0) at 2024-05-18 02:30:55 +0200