Merge branch 'master' into glsl-pp-rework-1glsl-pp-rework-1

9 files changed, 665 insertions, 151 deletions

diff --git a/progs/xdemos/.gitignore b/progs/xdemos/.gitignore
index 92446dd9fc..1b9b3a87c0 100644
--- a/progs/xdemos/.gitignore
+++ b/progs/xdemos/.gitignore
@@ -13,6 +13,7 @@ glxpixmap
 glxsnoop
 glxswapcontrol
 manywin
+multictx
 offset
 overlay
 pbdemo
diff --git a/progs/xdemos/Makefile b/progs/xdemos/Makefile
index 6581df8039..53e1c54ef3 100644
--- a/progs/xdemos/Makefile
+++ b/progs/xdemos/Makefile
@@ -26,6 +26,7 @@ PROGS = \
 	glxsnoop \
 	glxswapcontrol \
 	manywin \
+	multictx \
 	offset \
 	overlay \
 	pbinfo \
diff --git a/progs/xdemos/glthreads.c b/progs/xdemos/glthreads.c
index b90e6b4f31..ea5474870b 100644
--- a/progs/xdemos/glthreads.c
+++ b/progs/xdemos/glthreads.c
@@ -26,7 +26,7 @@
  *  -p                       Open a display connection for each thread
  *  -l                       Enable application-side locking
  *  -n <num threads>         Number of threads to create (default is 2)
- *  -display <display name>  Specify X display (default is :0.0)
+ *  -display <display name>  Specify X display (default is $DISPLAY)
  *  -t                       Use texture mapping
  *
  * Brian Paul  20 July 2000
@@ -573,7 +573,7 @@ usage(void)
 int
 main(int argc, char *argv[])
 {
-   char *displayName = ":0.0";
+   char *displayName = NULL;
    int numThreads = 2;
    Display *dpy = NULL;
    int i;
diff --git a/progs/xdemos/glxcontexts.c b/progs/xdemos/glxcontexts.c
index a97b62a908..9f83679acd 100644
--- a/progs/xdemos/glxcontexts.c
+++ b/progs/xdemos/glxcontexts.c
@@ -20,16 +20,17 @@
  */
 
 /*
- * This is a port of the infamous "gears" demo to straight GLX (i.e. no GLUT)
- * Port by Brian Paul  23 March 2001
+ * Version of glxgears that creates/destroys the rendering context for each
+ * frame.  Also periodically destroy/recreate the window.
+ * Good for finding memory leaks, etc.
  *
  * Command line options:
  *    -info      print GL implementation information
- *    -stereo    use stereo enabled GLX visual
  *
  */
 
 
+#include <assert.h>
 #include <math.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -92,13 +93,8 @@ static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
 static GLint gear1, gear2, gear3;
 static GLfloat angle = 0.0;
 
-static GLboolean fullscreen = GL_FALSE;	/* Create a single fullscreen window */
-static GLboolean stereo = GL_FALSE;	/* Enable stereo.  */
-static GLfloat eyesep = 5.0;		/* Eye separation. */
-static GLfloat fix_point = 40.0;	/* Fixation point distance.  */
-static GLfloat left, right, asp;	/* Stereo frustum params.  */
-
-   XVisualInfo *visinfo;
+static XVisualInfo *visinfo = NULL;
+static int WinWidth = 300, WinHeight = 300;
 
 
 /*
@@ -272,22 +268,13 @@ do_draw(void)
 }
 
 
-
 /* new window size or exposure */
 static void
 reshape(int width, int height)
 {
    glViewport(0, 0, (GLint) width, (GLint) height);
 
-   if (stereo) {
-      GLfloat w;
-
-      asp = (GLfloat) height / (GLfloat) width;
-      w = fix_point * (1.0 / 5.0);
-
-      left = -5.0 * ((w - 0.5 * eyesep) / fix_point);
-      right = 5.0 * ((w + 0.5 * eyesep) / fix_point);
-   } else {
+   {
       GLfloat h = (GLfloat) height / (GLfloat) width;
 
       glMatrixMode(GL_PROJECTION);
@@ -299,7 +286,6 @@ reshape(int width, int height)
    glLoadIdentity();
    glTranslatef(0.0, 0.0, -40.0);
 }
-   
 
 
 static void
@@ -337,7 +323,7 @@ init(void)
 
    glEnable(GL_NORMALIZE);
 }
-
+   
 
 static void
 draw( Display *dpy, Window win )
@@ -354,36 +340,9 @@ draw( Display *dpy, Window win )
 
    init();
 
-   if (stereo) {
-      /* First left eye.  */
-      glDrawBuffer(GL_BACK_LEFT);
-
-      glMatrixMode(GL_PROJECTION);
-      glLoadIdentity();
-      glFrustum(left, right, -asp, asp, 5.0, 60.0);
-
-      glMatrixMode(GL_MODELVIEW);
-
-      glPushMatrix();
-      glTranslated(+0.5 * eyesep, 0.0, 0.0);
-      do_draw();
-      glPopMatrix();
+   reshape(WinWidth, WinHeight);
 
-      /* Then right eye.  */
-      glDrawBuffer(GL_BACK_RIGHT);
-
-      glMatrixMode(GL_PROJECTION);
-      glLoadIdentity();
-      glFrustum(-right, -left, -asp, asp, 5.0, 60.0);
-
-      glMatrixMode(GL_MODELVIEW);
-
-      glPushMatrix();
-      glTranslated(-0.5 * eyesep, 0.0, 0.0);
-      do_draw();
-      glPopMatrix();
-   } else
-      do_draw();
+   do_draw();
 
    glDeleteLists(gear1, 1);
    glDeleteLists(gear2, 1);
@@ -410,14 +369,6 @@ make_window( Display *dpy, const char *name,
                      GLX_DOUBLEBUFFER,
                      GLX_DEPTH_SIZE, 1,
                      None };
-   int stereoAttribs[] = { GLX_RGBA,
-                           GLX_RED_SIZE, 1,
-                           GLX_GREEN_SIZE, 1,
-                           GLX_BLUE_SIZE, 1,
-                           GLX_DOUBLEBUFFER,
-                           GLX_DEPTH_SIZE, 1,
-                           GLX_STEREO,
-                           None };
    int scrnum;
    XSetWindowAttributes attr;
    unsigned long mask;
@@ -427,22 +378,12 @@ make_window( Display *dpy, const char *name,
    scrnum = DefaultScreen( dpy );
    root = RootWindow( dpy, scrnum );
 
-   if (fullscreen) {
-      x = 0; y = 0;
-      width = DisplayWidth( dpy, scrnum );
-      height = DisplayHeight( dpy, scrnum );
-   }
+   if (visinfo)
+	   XFree(visinfo);
 
-   if (stereo)
-      visinfo = glXChooseVisual( dpy, scrnum, stereoAttribs );
-   else
-      visinfo = glXChooseVisual( dpy, scrnum, attribs );
+   visinfo = glXChooseVisual( dpy, scrnum, attribs );
    if (!visinfo) {
-      if (stereo) {
-         printf("Error: couldn't get an RGB, "
-                "Double-buffered, Stereo visual\n");
-      } else
-         printf("Error: couldn't get an RGB, Double-buffered visual\n");
+      printf("Error: couldn't get an RGB, Double-buffered visual\n");
       exit(1);
    }
 
@@ -451,7 +392,7 @@ make_window( Display *dpy, const char *name,
    attr.border_pixel = 0;
    attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
    attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
-   attr.override_redirect = fullscreen;
+   attr.override_redirect = 0;
    mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect;
 
    win = XCreateWindow( dpy, root, x, y, width, height,
@@ -479,10 +420,9 @@ static void
 event_loop(Display *dpy)
 {
    Window win;
-   make_window(dpy, "glxgears", 0, 0, 300, 300, &win);
+   make_window(dpy, "glxgears", 0, 0, WinWidth, WinHeight, &win);
    XMapWindow(dpy, win);
 
-
    while (1) {
       while (XPending(dpy) > 0) {
          XEvent event;
@@ -492,34 +432,35 @@ event_loop(Display *dpy)
             /* we'll redraw below */
 	    break;
 	 case ConfigureNotify:
-	    reshape(event.xconfigure.width, event.xconfigure.height);
+            WinWidth = event.xconfigure.width;
+            WinHeight = event.xconfigure.height;
 	    break;
          case KeyPress:
-	 {
-	    char buffer[10];
-	    int r, code;
-	    code = XLookupKeysym(&event.xkey, 0);
-	    if (code == XK_Left) {
-	       view_roty += 5.0;
-	    }
-	    else if (code == XK_Right) {
-	       view_roty -= 5.0;
-	    }
-	    else if (code == XK_Up) {
-	       view_rotx += 5.0;
-	    }
-	    else if (code == XK_Down) {
-	       view_rotx -= 5.0;
-	    }
-	    else {
-	       r = XLookupString(&event.xkey, buffer, sizeof(buffer),
-				 NULL, NULL);
-	       if (buffer[0] == 27) {
-		  /* escape */
-		  return;
-	       }
-	    }
-	 }
+            {
+               char buffer[10];
+               int r, code;
+               code = XLookupKeysym(&event.xkey, 0);
+               if (code == XK_Left) {
+                  view_roty += 5.0;
+               }
+               else if (code == XK_Right) {
+                  view_roty -= 5.0;
+               }
+               else if (code == XK_Up) {
+                  view_rotx += 5.0;
+               }
+               else if (code == XK_Down) {
+                  view_rotx -= 5.0;
+               }
+               else {
+                  r = XLookupString(&event.xkey, buffer, sizeof(buffer),
+                                    NULL, NULL);
+                  if (buffer[0] == 27) {
+                     /* escape */
+                     return;
+                  }
+               }
+            }
          }
       }
 
@@ -550,9 +491,12 @@ event_loop(Display *dpy)
             printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds,
                    fps);
             tRate0 = t;
-	    
+
+            /* Destroy window and create new one */	    
 	    XDestroyWindow(dpy, win);
-	    make_window(dpy, "glxgears", (int)(fps * 100) % 100, (int)(fps * 100) % 100, 300, 300, &win);
+	    make_window(dpy, "glxgears",
+                        (int)(fps * 100) % 100, (int)(fps * 100) % 100, /* x,y */
+                        WinWidth, WinHeight, &win);
 	    XMapWindow(dpy, win);
 
             frames = 0;
@@ -562,7 +506,6 @@ event_loop(Display *dpy)
 }
 
 
-
 int
 main(int argc, char *argv[])
 {
@@ -579,12 +522,6 @@ main(int argc, char *argv[])
       else if (strcmp(argv[i], "-info") == 0) {
          printInfo = GL_TRUE;
       }
-      else if (strcmp(argv[i], "-stereo") == 0) {
-         stereo = GL_TRUE;
-      }
-      else if (strcmp(argv[i], "-fullscreen") == 0) {
-         fullscreen = GL_TRUE;
-      }
       else
 	 printf("Warrning: unknown parameter: %s\n", argv[i]);
    }
@@ -596,7 +533,6 @@ main(int argc, char *argv[])
       return -1;
    }
 
-
    if (printInfo) {
       printf("GL_RENDERER   = %s\n", (char *) glGetString(GL_RENDERER));
       printf("GL_VERSION    = %s\n", (char *) glGetString(GL_VERSION));
@@ -604,7 +540,6 @@ main(int argc, char *argv[])
       printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
    }
 
-
    event_loop(dpy);
 
    XCloseDisplay(dpy);
diff --git a/progs/xdemos/glxgears.c b/progs/xdemos/glxgears.c
index 2dc157a890..088f25a357 100644
--- a/progs/xdemos/glxgears.c
+++ b/progs/xdemos/glxgears.c
@@ -23,10 +23,7 @@
  * This is a port of the infamous "gears" demo to straight GLX (i.e. no GLUT)
  * Port by Brian Paul  23 March 2001
  *
- * Command line options:
- *    -info      print GL implementation information
- *    -stereo    use stereo enabled GLX visual
- *
+ * See usage() below for command line options.
  */
 
 
@@ -39,9 +36,11 @@
 #include <GL/gl.h>
 #include <GL/glx.h>
 
-static int is_glx_extension_supported(Display *dpy, const char *query);
+#ifndef GLX_MESA_swap_control
+#define GLX_MESA_swap_control 1
+typedef int (*PFNGLXGETSWAPINTERVALMESAPROC)(void);
+#endif
 
-static void query_vsync(Display *dpy);
 
 #define BENCHMARK
 
@@ -566,7 +565,7 @@ make_window( Display *dpy, const char *name,
 /**
  * Determine whether or not a GLX extension is supported.
  */
-int
+static int
 is_glx_extension_supported(Display *dpy, const char *query)
 {
    const int scrnum = DefaultScreen(dpy);
@@ -586,37 +585,28 @@ is_glx_extension_supported(Display *dpy, const char *query)
 /**
  * Attempt to determine whether or not the display is synched to vblank.
  */
-void
+static void
 query_vsync(Display *dpy)
 {
    int interval = 0;
 
 
-#ifdef GLX_MESA_swap_control
-   if ((interval <= 0)
-       && is_glx_extension_supported(dpy, "GLX_MESA_swap_control")) {
+   if (is_glx_extension_supported(dpy, "GLX_MESA_swap_control")) {
       PFNGLXGETSWAPINTERVALMESAPROC pglXGetSwapIntervalMESA =
           (PFNGLXGETSWAPINTERVALMESAPROC)
           glXGetProcAddressARB((const GLubyte *) "glXGetSwapIntervalMESA");
 
       interval = (*pglXGetSwapIntervalMESA)();
+   } else if (is_glx_extension_supported(dpy, "GLX_SGI_swap_control")) {
+      /* The default swap interval with this extension is 1.  Assume that it
+       * is set to the default.
+       *
+       * Many Mesa-based drivers default to 0, but all of these drivers also
+       * export GLX_MESA_swap_control.  In that case, this branch will never
+       * be taken, and the correct result should be reported.
+       */
+      interval = 1;
    }
-#endif
-
-
-#ifdef GLX_SGI_video_sync
-   if ((interval <= 0)
-       && is_glx_extension_supported(dpy, "GLX_SGI_video_sync")) {
-      PFNGLXGETVIDEOSYNCSGIPROC pglXGetVideoSyncSGI =
-          (PFNGLXGETVIDEOSYNCSGIPROC)
-          glXGetProcAddressARB((const GLubyte *) "glXGetVideoSyncSGI");
-      unsigned count;
-
-      if ((*pglXGetVideoSyncSGI)(& count) == 0) {
-         interval = (int) count;
-      }
-   }
-#endif
 
 
    if (interval > 0) {
diff --git a/progs/xdemos/glxheads.c b/progs/xdemos/glxheads.c
index b3290e90d5..b1a63d3d50 100644
--- a/progs/xdemos/glxheads.c
+++ b/progs/xdemos/glxheads.c
@@ -267,7 +267,8 @@ main(int argc, char *argv[])
       printf("  glxheads xdisplayname ...\n");
       printf("Example:\n");
       printf("  glxheads :0 mars:0 venus:1\n");
-      h = AddHead(":0");
+
+      h = AddHead(XDisplayName(NULL));
       if (h)
          PrintInfo(h);
    }
diff --git a/progs/xdemos/glxswapcontrol.c b/progs/xdemos/glxswapcontrol.c
index 2c51801989..cd60d460a0 100644
--- a/progs/xdemos/glxswapcontrol.c
+++ b/progs/xdemos/glxswapcontrol.c
@@ -303,13 +303,13 @@ draw(void)
       glDisable(GL_LIGHTING);
       glShadeModel(GL_SMOOTH);
 
-      glEnable( GL_VERTEX_ARRAY );
-      glEnable( GL_COLOR_ARRAY );
+      glEnableClientState( GL_VERTEX_ARRAY );
+      glEnableClientState( GL_COLOR_ARRAY );
       glVertexPointer( 3, GL_FLOAT, 0, vert );
       glColorPointer( 3, GL_FLOAT, 0, col );
       glDrawArrays( GL_POLYGON, 0, 4 );
-      glDisable( GL_COLOR_ARRAY );
-      glDisable( GL_VERTEX_ARRAY );
+      glDisableClientState( GL_COLOR_ARRAY );
+      glDisableClientState( GL_VERTEX_ARRAY );
 
       glMatrixMode(GL_PROJECTION);
       glLoadIdentity();
@@ -587,6 +587,9 @@ event_loop(Display *dpy, Window win)
       angle += 2.0;
 
       draw();
+
+      glXSwapBuffers(dpy, win);
+
       if ( get_frame_usage != NULL ) {
 	 GLfloat   temp;
 	 
@@ -594,8 +597,6 @@ event_loop(Display *dpy, Window win)
 	 frame_usage += temp;
       }
 
-      glXSwapBuffers(dpy, win);
-
       /* calc framerate */
       {
          static int t0 = -1;
@@ -759,7 +760,7 @@ main(int argc, char *argv[])
    Display *dpy;
    Window win;
    GLXContext ctx;
-   char *dpyName = ":0";
+   char *dpyName = NULL;
    int swap_interval = 1;
    GLboolean do_swap_interval = GL_FALSE;
    GLboolean force_get_rate = GL_FALSE;
diff --git a/progs/xdemos/multictx.c b/progs/xdemos/multictx.c
new file mode 100644
index 0000000000..75255b2860
--- /dev/null
+++ b/progs/xdemos/multictx.c
@@ -0,0 +1,585 @@
+/*
+ * Copyright (C) 2009  VMware, Inc.   All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * 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
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * Test rendering with two contexts into one window.
+ * Setup different rendering state for each context to check that
+ * context switching is handled properly.
+ *
+ * Brian Paul
+ * 6 Aug 2009
+ */
+
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+#include <GL/gl.h>
+#include <GL/glx.h>
+
+
+
+#ifndef M_PI
+#define M_PI 3.14159265
+#endif
+
+
+/** Event handler results: */
+#define NOP 0
+#define EXIT 1
+#define DRAW 2
+
+static GLfloat view_rotx = 0.0, view_roty = 210.0, view_rotz = 0.0;
+static GLint gear1, gear2;
+static GLfloat angle = 0.0;
+
+static GLboolean animate = GL_TRUE;	/* Animation */
+
+
+static double
+current_time(void)
+{
+   struct timeval tv;
+#ifdef __VMS
+   (void) gettimeofday(&tv, NULL );
+#else
+   struct timezone tz;
+   (void) gettimeofday(&tv, &tz);
+#endif
+   return (double) tv.tv_sec + tv.tv_usec / 1000000.0;
+}
+
+
+/*
+ *
+ *  Draw a gear wheel.  You'll probably want to call this function when
+ *  building a display list since we do a lot of trig here.
+ * 
+ *  Input:  inner_radius - radius of hole at center
+ *          outer_radius - radius at center of teeth
+ *          width - width of gear
+ *          teeth - number of teeth
+ *          tooth_depth - depth of tooth
+ */
+static void
+gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
+     GLint teeth, GLfloat tooth_depth)
+{
+   GLint i;
+   GLfloat r0, r1, r2;
+   GLfloat angle, da;
+   GLfloat u, v, len;
+
+   r0 = inner_radius;
+   r1 = outer_radius - tooth_depth / 2.0;
+   r2 = outer_radius + tooth_depth / 2.0;
+
+   da = 2.0 * M_PI / teeth / 4.0;
+
+   glShadeModel(GL_FLAT);
+
+   glNormal3f(0.0, 0.0, 1.0);
+
+   /* draw front face */
+   glBegin(GL_QUAD_STRIP);
+   for (i = 0; i <= teeth; i++) {
+      angle = i * 2.0 * M_PI / teeth;
+      glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
+      glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
+      if (i < teeth) {
+	 glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
+	 glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
+		    width * 0.5);
+      }
+   }
+   glEnd();
+
+   /* draw front sides of teeth */
+   glBegin(GL_QUADS);
+   da = 2.0 * M_PI / teeth / 4.0;
+   for (i = 0; i < teeth; i++) {
+      angle = i * 2.0 * M_PI / teeth;
+
+      glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
+      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
+      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
+		 width * 0.5);
+      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
+		 width * 0.5);
+   }
+   glEnd();
+
+   glNormal3f(0.0, 0.0, -1.0);
+
+   /* draw back face */
+   glBegin(GL_QUAD_STRIP);
+   for (i = 0; i <= teeth; i++) {
+      angle = i * 2.0 * M_PI / teeth;
+      glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
+      glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
+      if (i < teeth) {
+	 glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
+		    -width * 0.5);
+	 glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
+      }
+   }
+   glEnd();
+
+   /* draw back sides of teeth */
+   glBegin(GL_QUADS);
+   da = 2.0 * M_PI / teeth / 4.0;
+   for (i = 0; i < teeth; i++) {
+      angle = i * 2.0 * M_PI / teeth;
+
+      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
+		 -width * 0.5);
+      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
+		 -width * 0.5);
+      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
+      glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
+   }
+   glEnd();
+
+   /* draw outward faces of teeth */
+   glBegin(GL_QUAD_STRIP);
+   for (i = 0; i < teeth; i++) {
+      angle = i * 2.0 * M_PI / teeth;
+
+      glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
+      glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
+      u = r2 * cos(angle + da) - r1 * cos(angle);
+      v = r2 * sin(angle + da) - r1 * sin(angle);
+      len = sqrt(u * u + v * v);
+      u /= len;
+      v /= len;
+      glNormal3f(v, -u, 0.0);
+      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
+      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
+      glNormal3f(cos(angle), sin(angle), 0.0);
+      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
+		 width * 0.5);
+      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
+		 -width * 0.5);
+      u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
+      v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
+      glNormal3f(v, -u, 0.0);
+      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
+		 width * 0.5);
+      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
+		 -width * 0.5);
+      glNormal3f(cos(angle), sin(angle), 0.0);
+   }
+
+   glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
+   glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
+
+   glEnd();
+
+   glShadeModel(GL_SMOOTH);
+
+   /* draw inside radius cylinder */
+   glBegin(GL_QUAD_STRIP);
+   for (i = 0; i <= teeth; i++) {
+      angle = i * 2.0 * M_PI / teeth;
+      glNormal3f(-cos(angle), -sin(angle), 0.0);
+      glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
+      glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
+   }
+   glEnd();
+}
+
+
+static void
+draw(int ctx)
+{
+   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+   glPushMatrix();
+   glRotatef(view_rotx, 1.0, 0.0, 0.0);
+   glRotatef(view_roty + angle, 0.0, 1.0, 0.0);
+   glRotatef(view_rotz, 0.0, 0.0, 1.0);
+
+   if (ctx == 0) {
+      glDisable(GL_CULL_FACE);
+      glPushMatrix();
+      glRotatef(angle, 0.0, 0.0, 1.0);
+      glCallList(gear1);
+      glPopMatrix();
+      /* This should not effect the other context's rendering */
+      glEnable(GL_CULL_FACE);
+      glCullFace(GL_FRONT_AND_BACK);
+   }
+   else {
+      glPushMatrix();
+      glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
+      glCallList(gear2);
+      glPopMatrix();
+   }
+
+   glPopMatrix();
+
+   /* this flush is important since we'll be switching contexts next */
+   glFlush();
+}
+
+
+
+static void
+draw_frame(Display *dpy, Window win, GLXContext ctx1, GLXContext ctx2)
+{
+   static double tRot0 = -1.0;
+   double dt, t = current_time();
+
+   if (tRot0 < 0.0)
+      tRot0 = t;
+   dt = t - tRot0;
+   tRot0 = t;
+
+   if (animate) {
+      /* advance rotation for next frame */
+      angle += 70.0 * dt;  /* 70 degrees per second */
+      if (angle > 3600.0)
+         angle -= 3600.0;
+   }
+
+   glXMakeCurrent(dpy, (GLXDrawable) win, ctx1);
+   draw(0);
+
+   glXMakeCurrent(dpy, (GLXDrawable) win, ctx2);
+   draw(1);
+
+   glXSwapBuffers(dpy, win);
+}
+
+
+/* new window size or exposure */
+static void
+reshape(Display *dpy, Window win,
+        GLXContext ctx1, GLXContext ctx2, int width, int height)
+{
+   int i;
+
+   width /= 2;
+
+   /* loop: left half of window, right half of window */
+   for (i = 0; i < 2; i++) {
+      if (i == 0)
+         glXMakeCurrent(dpy, win, ctx1);
+      else
+         glXMakeCurrent(dpy, win, ctx2);
+
+      glViewport(width * i, 0, width, height);
+      glScissor(width * i, 0, width, height);
+
+      {
+         GLfloat h = (GLfloat) height / (GLfloat) width;
+
+         glMatrixMode(GL_PROJECTION);
+         glLoadIdentity();
+         glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
+      }
+
+      glMatrixMode(GL_MODELVIEW);
+      glLoadIdentity();
+      glTranslatef(0.0, 0.0, -30.0);
+   }
+}
+   
+
+
+static void
+init(Display *dpy, Window win, GLXContext ctx1, GLXContext ctx2)
+{
+   static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
+   static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
+   static GLfloat green[4] = { 0.0, 0.8, 0.2, 0.5 };
+   /*static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };*/
+
+   /* first ctx */
+   {
+      static GLuint stipple[32] = {
+         0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff,
+         0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff,
+
+         0xff00ff00, 0xff00ff00, 0xff00ff00, 0xff00ff00,
+         0xff00ff00, 0xff00ff00, 0xff00ff00, 0xff00ff00,
+
+         0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff,
+         0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff,
+
+         0xff00ff00, 0xff00ff00, 0xff00ff00, 0xff00ff00,
+         0xff00ff00, 0xff00ff00, 0xff00ff00, 0xff00ff00
+      };
+
+      glXMakeCurrent(dpy, win, ctx1);
+
+      glLightfv(GL_LIGHT0, GL_POSITION, pos);
+      glEnable(GL_LIGHTING);
+      glEnable(GL_LIGHT0);
+      glEnable(GL_DEPTH_TEST);
+
+      gear1 = glGenLists(1);
+      glNewList(gear1, GL_COMPILE);
+      glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
+      gear(1.0, 4.0, 1.0, 20, 0.7);
+      glEndList();
+
+      glEnable(GL_NORMALIZE);
+      glEnable(GL_SCISSOR_TEST);
+      glClearColor(0.4, 0.4, 0.4, 1.0);
+
+      glPolygonStipple((GLubyte *) stipple);
+      glEnable(GL_POLYGON_STIPPLE);
+   }
+
+   /* second ctx */
+   {
+      glXMakeCurrent(dpy, win, ctx2);
+
+      glLightfv(GL_LIGHT0, GL_POSITION, pos);
+      glEnable(GL_LIGHTING);
+      glEnable(GL_LIGHT0);
+      glEnable(GL_DEPTH_TEST);
+
+      gear2 = glGenLists(1);
+      glNewList(gear2, GL_COMPILE);
+      glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
+      gear(1.5, 3.0, 1.5, 16, 0.7);
+      glEndList();
+
+      glEnable(GL_NORMALIZE);
+      glEnable(GL_SCISSOR_TEST);
+      glClearColor(0.6, 0.6, 0.6, 1.0);
+
+      glEnable(GL_BLEND);
+      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+   }
+}
+
+
+/**
+ * Create an RGB, double-buffered window.
+ * Return the window and two context handles.
+ */
+static void
+make_window_and_contexts( Display *dpy, const char *name,
+                          int x, int y, int width, int height,
+                          Window *winRet,
+                          GLXContext *ctxRet1,
+                          GLXContext *ctxRet2)
+{
+   int attribs[] = { GLX_RGBA,
+                     GLX_RED_SIZE, 1,
+                     GLX_GREEN_SIZE, 1,
+                     GLX_BLUE_SIZE, 1,
+                     GLX_DOUBLEBUFFER,
+                     GLX_DEPTH_SIZE, 1,
+                     None };
+   int scrnum;
+   XSetWindowAttributes attr;
+   unsigned long mask;
+   Window root;
+   Window win;
+   XVisualInfo *visinfo;
+
+   scrnum = DefaultScreen( dpy );
+   root = RootWindow( dpy, scrnum );
+
+   visinfo = glXChooseVisual( dpy, scrnum, attribs );
+   if (!visinfo) {
+      printf("Error: couldn't get an RGB, Double-buffered visual\n");
+      exit(1);
+   }
+
+   /* window attributes */
+   attr.background_pixel = 0;
+   attr.border_pixel = 0;
+   attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
+   attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
+   mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+
+   win = XCreateWindow( dpy, root, x, y, width, height,
+		        0, visinfo->depth, InputOutput,
+		        visinfo->visual, mask, &attr );
+
+   /* set hints and properties */
+   {
+      XSizeHints sizehints;
+      sizehints.x = x;
+      sizehints.y = y;
+      sizehints.width  = width;
+      sizehints.height = height;
+      sizehints.flags = USSize | USPosition;
+      XSetNormalHints(dpy, win, &sizehints);
+      XSetStandardProperties(dpy, win, name, name,
+                              None, (char **)NULL, 0, &sizehints);
+   }
+
+   *winRet = win;
+   *ctxRet1 = glXCreateContext( dpy, visinfo, NULL, True );
+   *ctxRet2 = glXCreateContext( dpy, visinfo, NULL, True );
+
+   if (!*ctxRet1 || !*ctxRet2) {
+      printf("Error: glXCreateContext failed\n");
+      exit(1);
+   }
+
+   XFree(visinfo);
+}
+
+
+/**
+ * Handle one X event.
+ * \return NOP, EXIT or DRAW
+ */
+static int
+handle_event(Display *dpy, Window win, GLXContext ctx1, GLXContext ctx2,
+             XEvent *event)
+{
+   (void) dpy;
+   (void) win;
+
+   switch (event->type) {
+   case Expose:
+      return DRAW;
+   case ConfigureNotify:
+      reshape(dpy, win, ctx1, ctx2,
+              event->xconfigure.width, event->xconfigure.height);
+      break;
+   case KeyPress:
+      {
+         char buffer[10];
+         int r, code;
+         code = XLookupKeysym(&event->xkey, 0);
+         if (code == XK_Left) {
+            view_roty += 5.0;
+         }
+         else if (code == XK_Right) {
+            view_roty -= 5.0;
+         }
+         else if (code == XK_Up) {
+            view_rotx += 5.0;
+         }
+         else if (code == XK_Down) {
+            view_rotx -= 5.0;
+         }
+         else {
+            r = XLookupString(&event->xkey, buffer, sizeof(buffer),
+                              NULL, NULL);
+            if (buffer[0] == 27) {
+               /* escape */
+               return EXIT;
+            }
+            else if (buffer[0] == 'a' || buffer[0] == 'A') {
+               animate = !animate;
+            }
+         }
+         return DRAW;
+      }
+   }
+   return NOP;
+}
+
+
+static void
+event_loop(Display *dpy, Window win, GLXContext ctx1, GLXContext ctx2)
+{
+   while (1) {
+      int op;
+      while (!animate || XPending(dpy) > 0) {
+         XEvent event;
+         XNextEvent(dpy, &event);
+         op = handle_event(dpy, win, ctx1, ctx2, &event);
+         if (op == EXIT)
+            return;
+         else if (op == DRAW)
+            break;
+      }
+
+      draw_frame(dpy, win, ctx1, ctx2);
+   }
+}
+
+
+int
+main(int argc, char *argv[])
+{
+   unsigned int winWidth = 800, winHeight = 400;
+   int x = 0, y = 0;
+   Display *dpy;
+   Window win;
+   GLXContext ctx1, ctx2;
+   char *dpyName = NULL;
+   GLboolean printInfo = GL_FALSE;
+   int i;
+
+   for (i = 1; i < argc; i++) {
+      if (strcmp(argv[i], "-display") == 0) {
+         dpyName = argv[i+1];
+         i++;
+      }
+      else {
+         return 1;
+      }
+   }
+
+   dpy = XOpenDisplay(dpyName);
+   if (!dpy) {
+      printf("Error: couldn't open display %s\n",
+	     dpyName ? dpyName : getenv("DISPLAY"));
+      return -1;
+   }
+
+   make_window_and_contexts(dpy, "multictx", x, y, winWidth, winHeight,
+                            &win, &ctx1, &ctx2);
+   XMapWindow(dpy, win);
+
+   if (printInfo) {
+      printf("GL_RENDERER   = %s\n", (char *) glGetString(GL_RENDERER));
+      printf("GL_VERSION    = %s\n", (char *) glGetString(GL_VERSION));
+      printf("GL_VENDOR     = %s\n", (char *) glGetString(GL_VENDOR));
+      printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
+   }
+
+   init(dpy, win, ctx1, ctx2);
+
+   /* Set initial projection/viewing transformation.
+    * We can't be sure we'll get a ConfigureNotify event when the window
+    * first appears.
+    */
+   reshape(dpy, win, ctx1, ctx2, winWidth, winHeight);
+
+   event_loop(dpy, win, ctx1, ctx2);
+
+   glDeleteLists(gear1, 1);
+   glDeleteLists(gear2, 1);
+   glXDestroyContext(dpy, ctx1);
+   glXDestroyContext(dpy, ctx2);
+   XDestroyWindow(dpy, win);
+   XCloseDisplay(dpy);
+
+   return 0;
+}
diff --git a/progs/xdemos/opencloseopen.c b/progs/xdemos/opencloseopen.c
index 0b8d061843..756096095e 100644
--- a/progs/xdemos/opencloseopen.c
+++ b/progs/xdemos/opencloseopen.c
@@ -158,7 +158,7 @@ main(int argc, char *argv[])
    Display *dpy;
    Window win;
    GLXContext ctx;
-   char *dpyName = ":0";
+   char *dpyName = NULL;
    int i;
 
    for (i = 1; i < argc; i++) {