Add Qt3 development HEAD version

6 files changed, 479 insertions, 0 deletions

diff --git a/examples/opengl/overlay_x11/utilities/NOTICE b/examples/opengl/overlay_x11/utilities/NOTICE
new file mode 100644
index 0000000..4157392
--- /dev/null
+++ b/examples/opengl/overlay_x11/utilities/NOTICE
@@ -0,0 +1,11 @@
+
+NOTICE:  This source code distribution contains source code contained
+in the book "Programming OpenGL for the X Window System" (ISBN:
+0-201-48359-9) published by Addison-Wesley.  The programs and
+associated files contained in the distribution were developed by Mark
+J. Kilgard and are Copyright 1994, 1995, 1996 by Mark J.  Kilgard
+(unless otherwise noted).  The programs are not in the public domain,
+but they are freely distributable without licensing fees.  These
+programs are provided without guarantee or warranty expressed or
+implied.
+
diff --git a/examples/opengl/overlay_x11/utilities/README b/examples/opengl/overlay_x11/utilities/README
new file mode 100644
index 0000000..d96f343
--- /dev/null
+++ b/examples/opengl/overlay_x11/utilities/README
@@ -0,0 +1,22 @@
+
+Welcome to the "Programming OpenGL for the X Window System" Xlib-based
+example source code.  The following table names each example program
+directory and what section of the book discusses the example.
+
+Section        Example directory
+----------     ------------------
+  1.5            glxsimple
+  2.1            glxdino
+  2.2.2          glxvisuals
+  2.6.1          pixmap2eps
+  6.2.3.1        xdevices
+  6.2.7          dials
+  6.3.4          sovinfo
+  6.3.5          layerdemo
+
+I've tried to make the Makefiles as simple and as portable as
+possible.  If you find problems with these examples, please report bugs
+to [email protected]
+
+- Mark Kilgard
+
diff --git a/examples/opengl/overlay_x11/utilities/glxvisuals/glxvisuals.c b/examples/opengl/overlay_x11/utilities/glxvisuals/glxvisuals.c
new file mode 100644
index 0000000..3c1a21e
--- /dev/null
+++ b/examples/opengl/overlay_x11/utilities/glxvisuals/glxvisuals.c
@@ -0,0 +1,147 @@
+
+/* Copyright (c) Mark J. Kilgard, 1996. */
+
+/* This program is freely distributable without licensing fees 
+   and is provided without guarantee or warrantee expressed or 
+   implied. This program is -not- in the public domain. */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <X11/Xlib.h>
+#include <GL/glx.h>
+
+static char *ClassOf(int c);
+static char *Format(int n, int w);
+
+void
+main(int argc, char *argv[])
+{
+  Display *dpy;
+  XVisualInfo match, *visualList, *vi, *visualToTry;
+  int errorBase, eventBase, major, minor, found;
+  int glxCapable, bufferSize, level, renderType, doubleBuffer, stereo,
+    auxBuffers, redSize, greenSize, blueSize, alphaSize, depthSize,
+    stencilSize, acRedSize, acGreenSize, acBlueSize, acAlphaSize;
+
+  dpy = XOpenDisplay(NULL);
+  if (!dpy) {
+    fprintf(stderr, "Could not connect to %s.\n", XDisplayName(NULL));
+    exit(1);
+  }
+  if (glXQueryExtension(dpy, &errorBase, &eventBase) == False) {
+    fprintf(stderr, "OpenGL not supported by X server.\n");
+    exit(1);
+  }
+
+  glXQueryVersion(dpy, &major, &minor);
+  printf("display: %s\n", XDisplayName(NULL));
+  printf("using GLX version: %d.%d\n\n", major, minor);
+
+  match.screen = DefaultScreen(dpy);
+  visualList = XGetVisualInfo(dpy, VisualScreenMask, &match, &found);
+
+  printf("   visual     bf lv rg d st  r  g  b a   ax dp st accum buffs\n");
+  printf(" id dep cl    sz l  ci b ro sz sz sz sz  bf th cl  r  g  b  a\n");
+  printf("-------------------------------------------------------------\n");
+
+  visualToTry = NULL;
+  for(vi = visualList; found > 0; found--, vi++) {
+    glXGetConfig(dpy, vi, GLX_USE_GL, &glxCapable);
+    if (glxCapable) {
+      printf("0x%x %2d %s", vi->visualid, vi->depth, ClassOf(vi->class));
+      glXGetConfig(dpy, vi, GLX_BUFFER_SIZE, &bufferSize);
+      glXGetConfig(dpy, vi, GLX_LEVEL, &level);
+      glXGetConfig(dpy, vi, GLX_RGBA, &renderType);
+      glXGetConfig(dpy, vi, GLX_DOUBLEBUFFER, &doubleBuffer);
+      glXGetConfig(dpy, vi, GLX_STEREO, &stereo);
+      glXGetConfig(dpy, vi, GLX_AUX_BUFFERS, &auxBuffers);
+      glXGetConfig(dpy, vi, GLX_RED_SIZE, &redSize);
+      glXGetConfig(dpy, vi, GLX_GREEN_SIZE, &greenSize);
+      glXGetConfig(dpy, vi, GLX_BLUE_SIZE, &blueSize);
+      glXGetConfig(dpy, vi, GLX_ALPHA_SIZE, &alphaSize);
+      glXGetConfig(dpy, vi, GLX_DEPTH_SIZE, &depthSize);
+      glXGetConfig(dpy, vi, GLX_STENCIL_SIZE, &stencilSize);
+      glXGetConfig(dpy, vi, GLX_ACCUM_RED_SIZE, &acRedSize);
+      glXGetConfig(dpy, vi, GLX_ACCUM_GREEN_SIZE, &acGreenSize);
+      glXGetConfig(dpy, vi, GLX_ACCUM_BLUE_SIZE, &acBlueSize);
+      glXGetConfig(dpy, vi, GLX_ACCUM_ALPHA_SIZE, &acAlphaSize);
+      printf("    %2s %2s %1s  %1s  %1s ",
+        Format(bufferSize, 2), Format(level, 2),
+        renderType ? "r" : "c",
+	doubleBuffer ? "y" : ".", 
+	stereo ? "y" : ".");
+      printf("%2s %2s %2s %2s ",
+        Format(redSize, 2), Format(greenSize, 2),
+	Format(blueSize, 2), Format(alphaSize, 2));
+      printf("%2s %2s %2s %2s %2s %2s %2s",
+        Format(auxBuffers, 2), Format(depthSize, 2), Format(stencilSize, 2),
+        Format(acRedSize, 2), Format(acGreenSize, 2),
+        Format(acBlueSize, 2), Format(acAlphaSize, 2));
+      printf("\n");
+      visualToTry = vi;
+    }
+  }
+
+  if (visualToTry) {
+    GLXContext context;
+    Window window;
+    Colormap colormap;
+    XSetWindowAttributes swa;
+
+    context = glXCreateContext(dpy, visualToTry, 0, GL_TRUE);
+    colormap = XCreateColormap(dpy,
+      RootWindow(dpy, visualToTry->screen),
+      visualToTry->visual, AllocNone);
+    swa.colormap = colormap;
+    swa.border_pixel = 0;
+    window = XCreateWindow(dpy, RootWindow(dpy, visualToTry->screen), 0, 0, 100, 100,
+      0, visualToTry->depth, InputOutput, visualToTry->visual,
+      CWBorderPixel | CWColormap, &swa);
+    glXMakeCurrent(dpy, window, context);
+    printf("\n");
+    printf("OpenGL vendor string: %s\n", glGetString(GL_VENDOR));
+    printf("OpenGL renderer string: %s\n", glGetString(GL_RENDERER));
+    printf("OpenGL version string: %s\n", glGetString(GL_VERSION));
+    if (glXIsDirect(dpy, context))
+      printf("direct rendering: supported\n");
+    printf( "GL extensions: '%s'\n\n", glGetString(GL_EXTENSIONS) );
+#if defined(GLX_VERSION_1_1)
+    printf( "GLX extensions: '%s'\n\n", glXQueryExtensionsString( dpy, visualToTry->screen ) );
+#endif
+
+  } else
+    printf("No GLX-capable visuals!\n");
+  XFree(visualList);
+}
+
+static char *
+ClassOf(int c)
+{
+  switch (c) {
+  case StaticGray:   return "sg";
+  case GrayScale:    return "gs";
+  case StaticColor:  return "sc";
+  case PseudoColor:  return "pc";
+  case TrueColor:    return "tc";
+  case DirectColor:  return "dc";
+  default:           return "??";
+  }
+}
+
+static char *
+Format(int n, int w)
+{
+  static char buffer[256];
+  static int bufptr;
+  char *buf;
+
+  if (bufptr >= sizeof(buffer) - w)
+    bufptr = 0;
+  buf = buffer + bufptr;
+  if (n == 0)
+    sprintf(buf, "%*s", w, ".");
+  else
+    sprintf(buf, "%*d", w, n);
+  bufptr += w + 1;
+  return buf;
+}
diff --git a/examples/opengl/overlay_x11/utilities/sovinfo/sovLayerUtil.h b/examples/opengl/overlay_x11/utilities/sovinfo/sovLayerUtil.h
new file mode 100644
index 0000000..f45423a
--- /dev/null
+++ b/examples/opengl/overlay_x11/utilities/sovinfo/sovLayerUtil.h
@@ -0,0 +1,54 @@
+#ifndef __sovLayerUtil_h__
+#define __sovLayerUtil_h__
+
+/* Copyright (c) Mark J. Kilgard, 1996. */
+
+/* This program is freely distributable without licensing fees 
+   and is provided without guarantee or warrantee expressed or 
+   implied. This program is -not- in the public domain. */
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xmd.h>
+
+/* Transparent type values */
+/*      None                  0 */
+#define TransparentPixel      1
+#define TransparentMask       2
+
+/* layered visual info template flags */
+#define VisualLayerMask		0x200
+#define VisualTransparentType	0x400
+#define VisualTransparentValue	0x800
+#define VisualAllLayerMask	0xFFF
+
+/* layered visual info structure */
+typedef struct _sovVisualInfo {
+   XVisualInfo vinfo;
+   int layer;
+   int type;
+   unsigned long value;
+} sovVisualInfo;
+
+/* SERVER_OVERLAY_VISUALS property element */
+typedef struct _sovOverlayInfo {
+   long  overlay_visual;
+   long  transparent_type;
+   long  value;
+   long  layer;
+} sovOverlayInfo;
+
+extern sovVisualInfo *sovGetVisualInfo(
+  Display *display,
+  long lvinfo_mask,
+  sovVisualInfo *lvinfo_template,
+  int *nitems_return);
+extern Status sovMatchVisualInfo(
+  Display *display,
+  int screen,
+  int depth,
+  int class,
+  int layer,
+  sovVisualInfo *lvinfo_return);
+
+#endif /* __sovLayerUtil_h__ */
diff --git a/examples/opengl/overlay_x11/utilities/sovinfo/sovinfo.c b/examples/opengl/overlay_x11/utilities/sovinfo/sovinfo.c
new file mode 100644
index 0000000..059050c
--- /dev/null
+++ b/examples/opengl/overlay_x11/utilities/sovinfo/sovinfo.c
@@ -0,0 +1,95 @@
+
+/* Copyright (c) Mark J. Kilgard, 1996. */
+
+/* This program is freely distributable without licensing fees 
+   and is provided without guarantee or warrantee expressed or 
+   implied. This program is -not- in the public domain. */
+
+/* compile: cc -o sovinfo sovinfo.c sovLayerUtil.c -lX11 */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "sovLayerUtil.h"
+
+int
+main(int argc, char *argv[])
+{
+  Display *dpy;
+  char *display_name, *arg, *class;
+  sovVisualInfo template, *lvinfo;
+  int nVisuals, i, overlaysOnly = 0;
+
+  display_name = NULL;
+  for (i = 1; i < argc; i++) {
+    arg = argv[i];
+    if (!strcmp(arg, "-display")) {
+      if (++i >= argc) {
+        fprintf(stderr, "sovinfo: missing argument to -display\n");
+        exit(1);
+      }
+      display_name = argv[i];
+    } else if (!strcmp(arg, "-overlays_only")) {
+      overlaysOnly = 1;
+    } else {
+      fprintf(stderr,
+        "usage: sovinfo [-display dpy] [-overlays_only]\n");
+      exit(1);
+    }
+  }
+  dpy = XOpenDisplay(display_name);
+  if (dpy == NULL) {
+    fprintf(stderr, "sovinfo: cannot open display %s\n",
+      XDisplayName(NULL));
+    exit(1);
+  }
+  lvinfo = sovGetVisualInfo(dpy, 0L, &template, &nVisuals);
+  for (i = 0; i < nVisuals; i++) {
+    if (!overlaysOnly || lvinfo[i].layer > 0) {
+      printf("  Visual ID: 0x%x\n", lvinfo[i].vinfo.visualid);
+      printf("    screen: %d\n", lvinfo[i].vinfo.screen);
+      printf("    depth: %d\n", lvinfo[i].vinfo.depth);
+      switch (lvinfo[i].vinfo.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:
+        class = "Unknown";
+        break;
+      }
+      printf("    class: %s\n", class);
+      switch (lvinfo[i].type) {
+      case None:
+        printf("    transparent type: None\n");
+        break;
+      case TransparentPixel:
+        printf("    transparent type: TransparentPixel\n");
+        printf("    pixel value: %d\n", lvinfo[i].value);
+        break;
+      case TransparentMask:
+        printf("    transparent type: TransparentMask\n");
+        printf("    transparency mask: %0x%x\n", lvinfo[i].value);
+        break;
+      default:
+        printf("    transparent type: Unknown or invalid\n");
+        break;
+      }
+      printf("    layer: %d\n", lvinfo[i].layer);
+    }
+  }
+  return 0;
+}
diff --git a/examples/opengl/overlay_x11/utilities/sovinfo/sovlayerutil.c b/examples/opengl/overlay_x11/utilities/sovinfo/sovlayerutil.c
new file mode 100644
index 0000000..8837d06
--- /dev/null
+++ b/examples/opengl/overlay_x11/utilities/sovinfo/sovlayerutil.c
@@ -0,0 +1,150 @@
+
+/* Copyright (c) Mark J. Kilgard, 1996. */
+
+/* This program is freely distributable without licensing fees 
+   and is provided without guarantee or warrantee expressed or 
+   implied. This program is -not- in the public domain. */
+
+#include <stdlib.h>
+#include "sovLayerUtil.h"
+
+static Bool layersRead;
+static Atom overlayVisualsAtom;
+static sovOverlayInfo **overlayInfoPerScreen;
+static int *numOverlaysPerScreen;
+
+sovVisualInfo *
+sovGetVisualInfo(Display *display, long lvinfo_mask,
+  sovVisualInfo *lvinfo_template, int *nitems_return)
+{
+  XVisualInfo *vinfo;
+  sovVisualInfo *layerInfo;
+  Window root;
+  Status status;
+  Atom actualType;
+  unsigned long sizeData, bytesLeft;
+  int actualFormat, numVisuals, numScreens, count, i, j;
+
+  vinfo = XGetVisualInfo(display, lvinfo_mask & VisualAllMask,
+    &lvinfo_template->vinfo, nitems_return);
+  if (vinfo == NULL)
+    return NULL;
+  numVisuals = *nitems_return;
+  if (layersRead == False) {
+    overlayVisualsAtom = XInternAtom(display, 
+      "SERVER_OVERLAY_VISUALS", True);
+    if (overlayVisualsAtom != None) {
+      numScreens = ScreenCount(display);
+      overlayInfoPerScreen = (sovOverlayInfo **)
+        malloc(numScreens * sizeof(sovOverlayInfo *));
+      numOverlaysPerScreen = (int *) malloc(numScreens * sizeof(int));
+      if (overlayInfoPerScreen != NULL &&
+        numOverlaysPerScreen != NULL) {
+        for (i = 0; i < numScreens; i++) {
+          root = RootWindow(display, i);
+          status = XGetWindowProperty(display, root, overlayVisualsAtom,
+            0L, (long) 10000, False, overlayVisualsAtom,
+	    &actualType, &actualFormat,
+            &sizeData, &bytesLeft,
+	    (unsigned char **) &overlayInfoPerScreen[i]);
+          if (status != Success ||
+	    actualType != overlayVisualsAtom ||
+            actualFormat != 32 || sizeData < 4)
+            numOverlaysPerScreen[i] = 0;
+          else
+            numOverlaysPerScreen[i] = sizeData / 4;
+        }
+        layersRead = True;
+      } else {
+        if (overlayInfoPerScreen != NULL)
+          free(overlayInfoPerScreen);
+        if (numOverlaysPerScreen != NULL)
+          free(numOverlaysPerScreen);
+      }
+    }
+  }
+  layerInfo = (sovVisualInfo *)
+    malloc(numVisuals * sizeof(sovVisualInfo));
+  if (layerInfo == NULL) {
+    XFree(vinfo);
+    return NULL;
+  }
+  count = 0;
+  for (i = 0; i < numVisuals; i++) {
+    XVisualInfo *pVinfo;
+    int screen;
+    sovOverlayInfo *overlayInfo;
+
+    pVinfo = &vinfo[i];
+    screen = pVinfo->screen;
+    overlayInfo = NULL;
+    if (layersRead) {
+      for (j = 0; j < numOverlaysPerScreen[screen]; j++)
+        if (pVinfo->visualid == 
+  	  overlayInfoPerScreen[screen][j].overlay_visual) {
+          overlayInfo = &overlayInfoPerScreen[screen][j];
+          break;
+        }
+    }
+    if (lvinfo_mask & VisualLayerMask)
+      if (overlayInfo == NULL) {
+        if (lvinfo_template->layer != 0)
+          continue;
+      } else if (lvinfo_template->layer != overlayInfo->layer)
+        continue;
+    if (lvinfo_mask & VisualTransparentType)
+      if (overlayInfo == NULL) {
+        if (lvinfo_template->type != None)
+          continue;
+      } else if (lvinfo_template->type !=
+        overlayInfo->transparent_type)
+        continue;
+    if (lvinfo_mask & VisualTransparentValue)
+      if (overlayInfo == NULL)
+        /* non-overlay visuals have no sense of
+           TransparentValue */
+        continue;
+      else if (lvinfo_template->value != overlayInfo->value)
+        continue;
+    layerInfo[count].vinfo = *pVinfo;
+    if (overlayInfo == NULL) {
+      layerInfo[count].layer = 0;
+      layerInfo[count].type = None;
+      layerInfo[count].value = 0;  /* meaningless */
+    } else {
+      layerInfo[count].layer = overlayInfo->layer;
+      layerInfo[count].type = overlayInfo->transparent_type;
+      layerInfo[count].value = overlayInfo->value;
+    }
+    count++;
+  }
+  XFree(vinfo);
+  *nitems_return = count;
+  if (count == 0) {
+    XFree(layerInfo);
+    return NULL;
+  } else
+    return layerInfo;
+}
+
+Status
+sovMatchVisualInfo(Display *display, int screen,
+  int depth, int class, int layer, sovVisualInfo *lvinfo_return)
+{
+  sovVisualInfo *lvinfo;
+  sovVisualInfo lvinfoTemplate;
+  int nitems;
+
+  lvinfoTemplate.vinfo.screen = screen;
+  lvinfoTemplate.vinfo.depth = depth;
+  lvinfoTemplate.vinfo.class = class;
+  lvinfoTemplate.layer = layer;
+  lvinfo = sovGetVisualInfo(display,
+    VisualScreenMask|VisualDepthMask|VisualClassMask|VisualLayerMask,
+    &lvinfoTemplate, &nitems);
+  if (lvinfo != NULL && nitems > 0) {
+    *lvinfo_return = *lvinfo;
+    return 1;
+  } else
+    return 0;
+}