23 files changed, 1618 insertions, 1180 deletions

diff --git a/GL/apple/aglGlx.c b/GL/apple/aglGlx.c
index 106a6464d..fa7533e73 100644
--- a/GL/apple/aglGlx.c
+++ b/GL/apple/aglGlx.c
@@ -1,10 +1,14 @@
 /*
  * GLX implementation that uses Apple's AGL.framework for OpenGL
+ *
+ * FIXME: This file and indirect.c are very similar. The two should be
+ * merged by introducing suitable abstractions.
  */
 /*
  * Copyright (c) 2002 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2004 Torrey T. Lyons. All Rights Reserved.
  *
- * Portions of this file are copied from xf86glx.c,
+ * Large portions of this file are copied from Mesa's xf86glx.c,
  * which contains the following copyright:
  *
  * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
@@ -27,10 +31,6 @@
  * 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(s) of the above copyright
- * holders shall not be used in advertising or otherwise to promote the sale,
- * use or other dealings in this Software without prior written authorization.
  */
 /* $XFree86: xc/programs/Xserver/GL/apple/aglGlx.c,v 1.2 2003/09/16 00:36:11 torrey Exp $ */
 
@@ -58,6 +58,11 @@
 #include <GL/internal/glcore.h>
 #undef BOOL
 
+#include "glcontextmodes.h"
+
+// ggs: needed to call back to glx with visual configs
+extern void GlxSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs, void **configprivs);
+
 // Write debugging output, or not
 #ifdef GLAQUA_DEBUG
 #define GLAQUA_DEBUG_MSG ErrorF
@@ -84,14 +89,14 @@ GLboolean glIsTextureEXT (GLuint h) {
 // some prototypes
 static Bool glAquaScreenProbe(int screen);
 static Bool glAquaInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
-			      int *nvisualp, int *ndepthp,
-			      int *rootDepthp, VisualID *defaultVisp,
-			      unsigned long sizes, int bitsPerRGB);
+                              int *nvisualp, int *ndepthp,
+                              int *rootDepthp, VisualID *defaultVisp,
+                              unsigned long sizes, int bitsPerRGB);
 static void glAquaSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
-				   void **privates);
+                                   void **privates);
 static __GLinterface *glAquaCreateContext(__GLimports *imports,
-					  __GLcontextModes *mode,
-					  __GLinterface *shareGC);
+                                          __GLcontextModes *mode,
+                                          __GLinterface *shareGC);
 static void glAquaCreateBuffer(__GLXdrawablePrivate *glxPriv);
 static void glAquaResetExtension(void);
 
@@ -102,14 +107,14 @@ static void glAquaResetExtension(void);
  * __glXScreenInit to initialize each of the active screens
  * (__glXActiveScreens[]).  Several of the fields must be initialized by
  * the screenProbe routine before they are copied to the active screens
- * struct.  In particular, the contextCreate, pGlxVisual, numVisuals,
+ * struct.  In particular, the contextCreate, modes, numVisuals,
  * and numUsableVisuals fields must be initialized.
  */
-__GLXscreenInfo __glDDXScreenInfo = {
+static __GLXscreenInfo __glDDXScreenInfo = {
     glAquaScreenProbe,   /* Must be generic and handle all screens */
     glAquaCreateContext, /* Substitute screen's createContext routine */
     glAquaCreateBuffer,  /* Substitute screen's createBuffer routine */
-    NULL,                 /* Set up pGlxVisual in probe */
+    NULL,                 /* Set up modes in probe */
     NULL,                 /* Set up pVisualPriv in probe */
     0,                    /* Set up numVisuals in probe */
     0,                    /* Set up numUsableVisuals in probe */
@@ -119,13 +124,20 @@ __GLXscreenInfo __glDDXScreenInfo = {
     NULL                  /* WrappedPositionWindow is overwritten */
 };
 
-__GLXextensionInfo __glDDXExtensionInfo = {
+void *__glXglDDXScreenInfo(void) {
+    return &__glDDXScreenInfo;
+}
+
+static __GLXextensionInfo __glDDXExtensionInfo = {
     GL_CORE_APPLE,
     glAquaResetExtension,
     glAquaInitVisuals,
     glAquaSetVisualConfigs
 };
 
+void *__glXglDDXExtensionInfo(void) {
+    return &__glDDXExtensionInfo;
+}
 
 // prototypes
 
@@ -134,7 +146,7 @@ static GLboolean glAquaLoseCurrent(__GLcontext *gc);
 static GLboolean glAquaMakeCurrent(__GLcontext *gc);
 static GLboolean glAquaShareContext(__GLcontext *gc, __GLcontext *gcShare);
 static GLboolean glAquaCopyContext(__GLcontext *dst, const __GLcontext *src,
-			    GLuint mask);
+                                    GLuint mask);
 static GLboolean glAquaForceCurrent(__GLcontext *gc);
 
 /* Drawing surface notification callbacks */
@@ -168,7 +180,7 @@ static __GLexports glAquaExports = {
 
 typedef struct {
     int num_vis;
-    __GLXvisualConfig *glx_vis;
+    __GLcontextModes *modes;
     void **priv;
 
     // wrapped screen functions
@@ -192,6 +204,7 @@ struct __GLcontextRec {
 
   AGLContext ctx;
   AGLPixelFormat pixelFormat;
+
   Bool isAttached; // TRUE if ctx is really attached to a window
 };
 
@@ -206,22 +219,28 @@ static GLboolean glAquaDestroyContext(__GLcontext *gc)
         if (gc->pixelFormat) aglDestroyPixelFormat(gc->pixelFormat);
         free(gc);
     }
+
     return GL_TRUE;
 }
 
 
 static GLboolean glAquaLoseCurrent(__GLcontext *gc)
 {
-    // GLAQUA_DEBUG_MSG("glAquaLoseCurrent (ctx 0x%x)\n", gc->ctx);
+    GLAQUA_DEBUG_MSG("glAquaLoseCurrent (ctx 0x%x)\n", gc->ctx);
+
     aglSetCurrentContext(NULL);
     __glXLastContext = NULL; // Mesa does this; why?
+    gc->isAttached = FALSE;
+
     return GL_TRUE;
 }
 
-// (x, y, w, h) is global coordinates of view or -1
-// glPriv may be NULL
-static void attach(__GLcontext *gc, __GLdrawablePrivate *glPriv,
-                   int x, int y, int w, int h)
+
+/*
+ * Attach a GL context to a GL drawable
+ * If glPriv is NULL, the context is detached.
+ */
+static void attach(__GLcontext *gc, __GLdrawablePrivate *glPriv)
 {
     __GLXdrawablePrivate *glxPriv;
 
@@ -244,7 +263,15 @@ static void attach(__GLcontext *gc, __GLdrawablePrivate *glPriv,
         CRWindowPtr crWinPtr;
         AGLDrawable newPort;
 
-        crWinPtr = (CRWindowPtr) quartzProcs->FrameForWindow(pWin, TRUE);
+        if (glPriv->width <= 0 || glPriv->height <= 0) {
+            // attach to zero size drawable - will really attach later
+            GLAQUA_DEBUG_MSG("couldn't attach to zero size drawable\n");
+            aglSetDrawable(gc->ctx, NULL);
+            gc->isAttached = FALSE;
+            return;
+        }
+
+        crWinPtr = (CRWindowPtr) quartzProcs->FrameForWindow(pWin, FALSE);
 
         if (crWinPtr) {
             newPort = (AGLDrawable) crWinPtr->port;
@@ -253,35 +280,43 @@ static void attach(__GLcontext *gc, __GLdrawablePrivate *glPriv,
         }
 
         if (newPort) {
-            // fixme won't be a CGrafPtr if currently offscreen or fullscreen
+            // FIXME: won't be a CGrafPtr if currently offscreen or fullscreen
             AGLDrawable oldPort = aglGetDrawable(gc->ctx);
             // AGLDrawable newPort = GetWindowPort(window);
-            GLint frame[4] = {x, y, w, h}; // fixme multi-screen?
-            // frame is now X11-global
+
+            // Frame is GLdrawable in X11 global coordinates
+            // FIXME: Does this work for multiple screens?
+            GLint frame[4] = {glPriv->xOrigin, glPriv->yOrigin, glPriv->width, glPriv->height};
+            GLAQUA_DEBUG_MSG("global size %d %d %d %d\n",
+                             frame[0], frame[1], frame[2], frame[3]);
+
+            // Convert to window-local coordinates
             frame[0] -= topWin->drawable.x - topWin->borderWidth;
             frame[1] -= topWin->drawable.y - topWin->borderWidth;
-            // frame is now window-local
-            // GL uses flipped coordinates
+
+            // AGL uses flipped coordinates
             frame[1] = topWin->drawable.height + 2*topWin->borderWidth -
                        frame[1] - frame[3];
 
-            // GLAQUA_DEBUG_MSG("local size %d %d %d %d\n",
-            // frame[0], frame[1], frame[2], frame[3]);
+            GLAQUA_DEBUG_MSG("local size %d %d %d %d\n",
+                             frame[0], frame[1], frame[2], frame[3]);
 
             if (oldPort != newPort) {
-                // fixme retain/release windows
-                aglSetDrawable(gc->ctx, newPort);
+                // FIXME: retain/release windows
+                if (!aglSetDrawable(gc->ctx, newPort)) return;
             }
-            aglSetInteger(gc->ctx, AGL_BUFFER_RECT, frame);
-            aglEnable(gc->ctx, AGL_BUFFER_RECT);
-            // aglSetInteger(gc->ctx, AGL_SWAP_RECT, frame);
-            // aglEnable(gc->ctx, AGL_SWAP_RECT);
-            aglUpdateContext(gc->ctx);
+            if (!aglSetInteger(gc->ctx, AGL_BUFFER_RECT, frame)) return;
+            if (!aglEnable(gc->ctx, AGL_BUFFER_RECT)) return;
+            if (!aglSetInteger(gc->ctx, AGL_SWAP_RECT, frame)) return;
+            if (!aglEnable(gc->ctx, AGL_SWAP_RECT)) return;
+            if (!aglUpdateContext(gc->ctx)) return;
+
             gc->isAttached = TRUE;
-            GLAQUA_DEBUG_MSG("attached\n");
+            GLAQUA_DEBUG_MSG("attached context 0x%x to window 0x%x\n", gc->ctx,
+                             pWin->drawable.id);
         } else {
             // attach to not-yet-realized window - will really attach later
-            GLAQUA_DEBUG_MSG("couldn't attach\n");
+            GLAQUA_DEBUG_MSG("couldn't attach to unrealized window\n");
             aglSetDrawable(gc->ctx, NULL);
             gc->isAttached = FALSE;
         }
@@ -294,14 +329,14 @@ static void attach(__GLcontext *gc, __GLdrawablePrivate *glPriv,
 
 static GLboolean glAquaMakeCurrent(__GLcontext *gc)
 {
-#if 0
     __GLdrawablePrivate *glPriv = gc->interface.imports.getDrawablePrivate(gc);
+
     GLAQUA_DEBUG_MSG("glAquaMakeCurrent (ctx 0x%x)\n", gc->ctx);
 
     if (!gc->isAttached) {
-        attach(gc, glPriv, glPriv->xOrigin, glPriv->yOrigin, glPriv->width, glPriv->height);
+        attach(gc, glPriv);
     }
-#endif
+
     return aglSetCurrentContext(gc->ctx);
 }
 
@@ -317,8 +352,8 @@ static GLboolean glAquaCopyContext(__GLcontext *dst, const __GLcontext *src,
                                    GLuint mask)
 {
   GLAQUA_DEBUG_MSG("glAquaCopyContext\n");
-  aglCopyContext(src->ctx, dst->ctx, mask);
-  return GL_TRUE;
+
+    return aglCopyContext(src->ctx, dst->ctx, mask);
 }
 
 static GLboolean glAquaForceCurrent(__GLcontext *gc)
@@ -436,16 +471,15 @@ static AGLPixelFormat makeFormat(__GLcontextModes *mode)
 }
 
 static __GLinterface *glAquaCreateContext(__GLimports *imports,
-					  __GLcontextModes *mode,
-					  __GLinterface *shareGC)
+                                          __GLcontextModes *mode,
+                                          __GLinterface *shareGC)
 {
     __GLcontext *result;
     __GLcontext *sharectx = (__GLcontext *)shareGC;
-    GLint value;
 
     GLAQUA_DEBUG_MSG("glAquaCreateContext\n");
 
-    result = (__GLcontext *)malloc(sizeof(__GLcontext));
+    result = (__GLcontext *)calloc(1, sizeof(__GLcontext));
     if (!result) return NULL;
 
     result->interface.imports = *imports;
@@ -468,10 +502,6 @@ static __GLinterface *glAquaCreateContext(__GLimports *imports,
 
     result->isAttached = FALSE;
 
-    // Tell aglSwapBuffers to wait for vertical retrace
-    value = 1;
-    aglSetInteger(result->ctx, AGL_SWAP_INTERVAL, &value);
-
     GLAQUA_DEBUG_MSG("glAquaCreateContext done\n");
     return (__GLinterface *)result;
 }
@@ -505,17 +535,15 @@ glAquaRealizeWindow(WindowPtr pWin)
         GLAQUA_DEBUG_MSG("glAquaRealizeWindow is GL drawable!\n");
 
         // GL contexts bound to this window for drawing
-        for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->next) {
+        for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->nextDrawPriv) {
             gc = (__GLcontext *)gx->gc;
-            attach(gc, glPriv, glxPriv->xorigin, glxPriv->yorigin,
-                   glxPriv->width, glxPriv->height);
+            attach(gc, glPriv);
         }
 
         // GL contexts bound to this window for reading
-        for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->next) {
+        for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->nextReadPriv) {
             gc = (__GLcontext *)gx->gc;
-            attach(gc, glPriv, glxPriv->xorigin, glxPriv->yorigin,
-                   glxPriv->width, glxPriv->height);
+            attach(gc, glPriv);
         }
     }
 
@@ -544,15 +572,15 @@ glAquaUnrealizeWindow(WindowPtr pWin)
         GLAQUA_DEBUG_MSG("glAquaUnealizeWindow is GL drawable!\n");
 
         // GL contexts bound to this window for drawing
-        for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->next) {
+        for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->nextDrawPriv) {
             gc = (__GLcontext *)gx->gc;
-            attach(gc, NULL, 0, 0, 0, 0);
+            attach(gc, NULL);
         }
 
         // GL contexts bound to this window for reading
-        for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->next) {
+        for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->nextReadPriv) {
             gc = (__GLcontext *)gx->gc;
-            attach(gc, NULL, 0, 0, 0, 0);
+            attach(gc, NULL);
         }
     }
 
@@ -564,23 +592,21 @@ glAquaUnrealizeWindow(WindowPtr pWin)
 }
 
 
-
-
-
-
-/*
- * In the case the driver has no GLX visuals we'll use these.
- * [0] = RGB, double buffered
- * [1] = RGB, double buffered, stencil, accum
- */
 // Originally copied from Mesa
 
 static int                 numConfigs     = 0;
 static __GLXvisualConfig  *visualConfigs  = NULL;
 static void              **visualPrivates = NULL;
 
-#define NUM_FALLBACK_CONFIGS 2
+/*
+ * In the case the driver defines no GLX visuals we'll use these.
+ * Note that for TrueColor and DirectColor visuals, bufferSize is the 
+ * sum of redSize, greenSize, blueSize and alphaSize, which may be larger 
+ * than the nplanes/rootDepth of the server's X11 visuals
+ */
+#define NUM_FALLBACK_CONFIGS 5
 static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
+  /* [0] = RGB, double buffered, Z */
   {
     -1,                 /* vid */
     -1,                 /* class */
@@ -595,11 +621,12 @@ static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
     0,                  /* stencilSize */
     0,                  /* auxBuffers */
     0,                  /* level */
-    GLX_NONE_EXT,       /* visualRating */
-    0,                  /* transparentPixel */
+    GLX_NONE,           /* visualRating */
+    GLX_NONE,           /* transparentPixel */
     0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
     0                   /* transparentIndex */
   },
+  /* [1] = RGB, double buffered, Z, stencil, accum */
   {
     -1,                 /* vid */
     -1,                 /* class */
@@ -614,15 +641,94 @@ static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
     8,                  /* stencilSize */
     0,                  /* auxBuffers */
     0,                  /* level */
+    GLX_NONE,           /* visualRating */
+    GLX_NONE,           /* transparentPixel */
+    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
+    0                   /* transparentIndex */
+  },
+  /* [2] = RGB+Alpha, double buffered, Z, stencil, accum */
+  {
+    -1,                 /* vid */
+    -1,                 /* class */
+    True,               /* rgba */
+    -1, -1, -1, 8,      /* rgba sizes */
+    -1, -1, -1, -1,     /* rgba masks */
+    16, 16, 16, 16,     /* rgba accum sizes */
+    True,               /* doubleBuffer */
+    False,              /* stereo */
+    -1,                 /* bufferSize */
+    16,                 /* depthSize */
+    8,                  /* stencilSize */
+    0,                  /* auxBuffers */
+    0,                  /* level */
+    GLX_NONE,           /* visualRating */
+    GLX_NONE,           /* transparentPixel */
+    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
+    0                   /* transparentIndex */
+  },
+  /* [3] = RGB+Alpha, single buffered, Z, stencil, accum */
+  {
+    -1,                 /* vid */
+    -1,                 /* class */
+    True,               /* rgba */
+    -1, -1, -1, 8,      /* rgba sizes */
+    -1, -1, -1, -1,     /* rgba masks */
+    16, 16, 16, 16,     /* rgba accum sizes */
+    False,              /* doubleBuffer */
+    False,              /* stereo */
+    -1,                 /* bufferSize */
+    16,                 /* depthSize */
+    8,                  /* stencilSize */
+    0,                  /* auxBuffers */
+    0,                  /* level */
+    GLX_NONE,           /* visualRating */
+    GLX_NONE,           /* transparentPixel */
+    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
+    0                   /* transparentIndex */
+  },
+  /* [4] = CI, double buffered, Z */
+  {
+    -1,                 /* vid */
+    -1,                 /* class */
+    False,              /* rgba? (false = color index) */
+    -1, -1, -1, 0,      /* rgba sizes */
+    -1, -1, -1, 0,      /* rgba masks */
+     0,  0,  0, 0,      /* rgba accum sizes */
+    True,               /* doubleBuffer */
+    False,              /* stereo */
+    -1,                 /* bufferSize */
+    16,                 /* depthSize */
+    0,                  /* stencilSize */
+    0,                  /* auxBuffers */
+    0,                  /* level */
+    GLX_NONE,           /* visualRating */
+    GLX_NONE,           /* transparentPixel */
+    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
+    0                   /* transparentIndex */
+  },
+};
+
+static __GLXvisualConfig NullConfig = {
+    -1,                 /* vid */
+    -1,                 /* class */
+    False,              /* rgba */
+    -1, -1, -1, 0,      /* rgba sizes */
+    -1, -1, -1, 0,      /* rgba masks */
+     0,  0,  0, 0,      /* rgba accum sizes */
+    False,              /* doubleBuffer */
+    False,              /* stereo */
+    -1,                 /* bufferSize */
+    16,                 /* depthSize */
+    0,                  /* stencilSize */
+    0,                  /* auxBuffers */
+    0,                  /* level */
     GLX_NONE_EXT,       /* visualRating */
     0,                  /* transparentPixel */
     0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
     0                   /* transparentIndex */
-  }
 };
 
 
-
 static int count_bits(unsigned int n)
 {
    int bits = 0;
@@ -635,11 +741,10 @@ static int count_bits(unsigned int n)
 }
 
 
-// Mostly copied from Mesa's xf86glx.c
 static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
-			 VisualID *defaultVisp,
-			 int ndepth, DepthPtr pdepth,
-			 int rootDepth)
+                         VisualID *defaultVisp,
+                         int ndepth, DepthPtr pdepth,
+                         int rootDepth)
 {
     int numRGBconfigs;
     int numCIconfigs;
@@ -649,7 +754,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     VisualPtr pVisual = *visualp;
     VisualPtr pVisualNew = NULL;
     VisualID *orig_vid = NULL;
-    __GLXvisualConfig *glXVisualPtr = NULL;
+    __GLcontextModes *modes;
     __GLXvisualConfig *pNewVisualConfigs = NULL;
     void **glXVisualPriv;
     void **pNewVisualPriv;
@@ -667,14 +772,14 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     pNewVisualConfigs = (__GLXvisualConfig *)
                      __glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig));
     if (!pNewVisualConfigs) {
-	return FALSE;
+        return FALSE;
     }
 
     /* Alloc space for the list of new GLX visual privates */
     pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *));
     if (!pNewVisualPriv) {
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
     }
 
     /*
@@ -682,9 +787,9 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     ** visual configs.
     */
     if (numConfigs == 0) {
-	memcpy(pNewVisualConfigs, FallbackConfigs,
+        memcpy(pNewVisualConfigs, FallbackConfigs,
                NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig));
-	memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
+        memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
     }
     else {
         /* copy driver's visual config info */
@@ -698,18 +803,24 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     numRGBconfigs = 0;
     numCIconfigs = 0;
     for (i = 0; i < numNewConfigs; i++) {
-	if (pNewVisualConfigs[i].rgba)
-	    numRGBconfigs++;
-	else
-	    numCIconfigs++;
+        if (pNewVisualConfigs[i].rgba)
+            numRGBconfigs++;
+        else
+            numCIconfigs++;
     }
 
     /* Count the total number of visuals to compute */
     numNewVisuals = 0;
     for (i = 0; i < numVisuals; i++) {
-        numNewVisuals +=
-	    (pVisual[i].class == TrueColor || pVisual[i].class == DirectColor)
-	    ? numRGBconfigs : numCIconfigs;
+        int count;
+
+        count = ((pVisual[i].class == TrueColor ||
+                  pVisual[i].class == DirectColor)
+                ? numRGBconfigs : numCIconfigs);
+        if (count == 0)
+            count = 1;          /* preserve the existing visual */
+
+        numNewVisuals += count;
     }
 
     /* Reset variables for use with the next screen/driver's visual configs */
@@ -719,127 +830,159 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     /* Alloc temp space for the list of orig VisualIDs for each new visual */
     orig_vid = (VisualID *)__glXMalloc(numNewVisuals * sizeof(VisualID));
     if (!orig_vid) {
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+        __glXFree(pNewVisualPriv);
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
     }
 
     /* Alloc space for the list of glXVisuals */
-    glXVisualPtr = (__GLXvisualConfig *)__glXMalloc(numNewVisuals *
-						    sizeof(__GLXvisualConfig));
-    if (!glXVisualPtr) {
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+    modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes));
+    if (modes == NULL) {
+        __glXFree(orig_vid);
+        __glXFree(pNewVisualPriv);
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
     }
 
     /* Alloc space for the list of glXVisualPrivates */
     glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *));
     if (!glXVisualPriv) {
-	__glXFree(glXVisualPtr);
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+        _gl_context_modes_destroy( modes );
+        __glXFree(orig_vid);
+        __glXFree(pNewVisualPriv);
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
     }
 
     /* Alloc space for the new list of the X server's visuals */
     pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec));
     if (!pVisualNew) {
-	__glXFree(glXVisualPriv);
-	__glXFree(glXVisualPtr);
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+        __glXFree(glXVisualPriv);
+        _gl_context_modes_destroy( modes );
+        __glXFree(orig_vid);
+        __glXFree(pNewVisualPriv);
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
     }
 
     /* Initialize the new visuals */
     found_default = FALSE;
+    glAquaScreens[screenInfo.numScreens-1].modes = modes;
     for (i = j = 0; i < numVisuals; i++) {
         int is_rgb = (pVisual[i].class == TrueColor ||
-		      pVisual[i].class == DirectColor);
-
-	for (k = 0; k < numNewConfigs; k++) {
-	    if (pNewVisualConfigs[k].rgba != is_rgb)
-		continue;
-
-	    /* Initialize the new visual */
-	    pVisualNew[j] = pVisual[i];
-	    pVisualNew[j].vid = FakeClientID(0);
-
-	    /* Check for the default visual */
-	    if (!found_default && pVisual[i].vid == *defaultVisp) {
-		*defaultVisp = pVisualNew[j].vid;
-		found_default = TRUE;
-	    }
-
-	    /* Save the old VisualID */
-	    orig_vid[j] = pVisual[i].vid;
-
-	    /* Initialize the glXVisual */
-	    glXVisualPtr[j] = pNewVisualConfigs[k];
-	    glXVisualPtr[j].vid = pVisualNew[j].vid;
-
-	    /*
-	     * If the class is -1, then assume the X visual information
-	     * is identical to what GLX needs, and take them from the X
-	     * visual.  NOTE: if class != -1, then all other fields MUST
-	     * be initialized.
-	     */
-	    if (glXVisualPtr[j].class == -1) {
-		glXVisualPtr[j].class      = pVisual[i].class;
-		glXVisualPtr[j].redSize    = count_bits(pVisual[i].redMask);
-		glXVisualPtr[j].greenSize  = count_bits(pVisual[i].greenMask);
-		glXVisualPtr[j].blueSize   = count_bits(pVisual[i].blueMask);
-		glXVisualPtr[j].alphaSize  = glXVisualPtr[j].alphaSize;
-		glXVisualPtr[j].redMask    = pVisual[i].redMask;
-		glXVisualPtr[j].greenMask  = pVisual[i].greenMask;
-		glXVisualPtr[j].blueMask   = pVisual[i].blueMask;
-		glXVisualPtr[j].alphaMask  = glXVisualPtr[j].alphaMask;
-		glXVisualPtr[j].bufferSize = rootDepth;
-	    }
-
-	    /* Save the device-dependent private for this visual */
-	    glXVisualPriv[j] = pNewVisualPriv[k];
-
-	    j++;
-	}
+                  pVisual[i].class == DirectColor);
+
+        if (!is_rgb)
+        {
+            /* We don't support non-rgb visuals for GL. But we don't
+               want to remove them either, so just pass them through
+               with null glX configs */
+
+            pVisualNew[j] = pVisual[i];
+            pVisualNew[j].vid = FakeClientID(0);
+
+            /* Check for the default visual */
+            if (!found_default && pVisual[i].vid == *defaultVisp) {
+                *defaultVisp = pVisualNew[j].vid;
+                found_default = TRUE;
+            }
+
+            /* Save the old VisualID */
+            orig_vid[j] = pVisual[i].vid;
+
+            /* Initialize the glXVisual */
+            _gl_copy_visual_to_context_mode( modes, & NullConfig );
+            modes->visualID = pVisualNew[j].vid;
+
+            j++;
+
+            continue;
+        }
+
+        for (k = 0; k < numNewConfigs; k++) {
+            if (pNewVisualConfigs[k].rgba != is_rgb)
+                continue;
+
+            assert( modes != NULL );
+
+            /* Initialize the new visual */
+            pVisualNew[j] = pVisual[i];
+            pVisualNew[j].vid = FakeClientID(0);
+
+            /* Check for the default visual */
+            if (!found_default && pVisual[i].vid == *defaultVisp) {
+                *defaultVisp = pVisualNew[j].vid;
+                found_default = TRUE;
+            }
+
+            /* Save the old VisualID */
+            orig_vid[j] = pVisual[i].vid;
+
+            /* Initialize the glXVisual */
+            _gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] );
+            modes->visualID = pVisualNew[j].vid;
+
+            /*
+             * If the class is -1, then assume the X visual information
+             * is identical to what GLX needs, and take them from the X
+             * visual.  NOTE: if class != -1, then all other fields MUST
+             * be initialized.
+             */
+            if (modes->visualType == GLX_NONE) {
+                modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class );
+                modes->redBits    = count_bits(pVisual[i].redMask);
+                modes->greenBits  = count_bits(pVisual[i].greenMask);
+                modes->blueBits   = count_bits(pVisual[i].blueMask);
+                modes->alphaBits  = modes->alphaBits;
+                modes->redMask    = pVisual[i].redMask;
+                modes->greenMask  = pVisual[i].greenMask;
+                modes->blueMask   = pVisual[i].blueMask;
+                modes->alphaMask  = modes->alphaMask;
+                modes->rgbBits = (is_rgb)
+                    ? (modes->redBits + modes->greenBits +
+                       modes->blueBits + modes->alphaBits)
+                    : rootDepth;
+            }
+
+            /* Save the device-dependent private for this visual */
+            glXVisualPriv[j] = pNewVisualPriv[k];
+
+            j++;
+            modes = modes->next;
+        }
     }
 
     assert(j <= numNewVisuals);
 
     /* Save the GLX visuals in the screen structure */
     glAquaScreens[screenInfo.numScreens-1].num_vis = numNewVisuals;
-    glAquaScreens[screenInfo.numScreens-1].glx_vis = glXVisualPtr;
     glAquaScreens[screenInfo.numScreens-1].priv = glXVisualPriv;
 
     /* Set up depth's VisualIDs */
     for (i = 0; i < ndepth; i++) {
-	int numVids = 0;
-	VisualID *pVids = NULL;
-	int k, n = 0;
-
-	/* Count the new number of VisualIDs at this depth */
-	for (j = 0; j < pdepth[i].numVids; j++)
-	    for (k = 0; k < numNewVisuals; k++)
-		if (pdepth[i].vids[j] == orig_vid[k])
-		    numVids++;
-
-	/* Allocate a new list of VisualIDs for this depth */
-	pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID));
-
-	/* Initialize the new list of VisualIDs for this depth */
-	for (j = 0; j < pdepth[i].numVids; j++)
-	    for (k = 0; k < numNewVisuals; k++)
-		if (pdepth[i].vids[j] == orig_vid[k])
-		    pVids[n++] = pVisualNew[k].vid;
-
-	/* Update this depth's list of VisualIDs */
-	__glXFree(pdepth[i].vids);
-	pdepth[i].vids = pVids;
-	pdepth[i].numVids = numVids;
+        int numVids = 0;
+        VisualID *pVids = NULL;
+        int k, n = 0;
+
+        /* Count the new number of VisualIDs at this depth */
+        for (j = 0; j < pdepth[i].numVids; j++)
+            for (k = 0; k < numNewVisuals; k++)
+            if (pdepth[i].vids[j] == orig_vid[k])
+                numVids++;
+
+        /* Allocate a new list of VisualIDs for this depth */
+        pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID));
+
+        /* Initialize the new list of VisualIDs for this depth */
+        for (j = 0; j < pdepth[i].numVids; j++)
+            for (k = 0; k < numNewVisuals; k++)
+            if (pdepth[i].vids[j] == orig_vid[k])
+                pVids[n++] = pVisualNew[k].vid;
+
+        /* Update this depth's list of VisualIDs */
+        __glXFree(pdepth[i].vids);
+        pdepth[i].vids = pVids;
+        pdepth[i].numVids = numVids;
     }
 
     /* Update the X server's visuals */
@@ -862,9 +1005,96 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     return TRUE;
 }
 
-// Copied from Mesa
+/* based on code in i830_dri.c
+   This ends calling glAquaSetVisualConfigs to set the static
+   numconfigs, etc. */
+static void
+glAquaInitVisualConfigs(void)
+{
+    int                 lclNumConfigs     = 0;
+    __GLXvisualConfig  *lclVisualConfigs  = NULL;
+    void              **lclVisualPrivates = NULL;
+
+    int depth, aux, buffers, stencil, accum;
+    int i = 0;
+
+    GLAQUA_DEBUG_MSG("glAquaInitVisualConfigs ");
+
+    /* count num configs:
+        2 Z buffer (0, 24 bit)
+        2 AUX buffer (0, 2)
+        2 buffers (single, double)
+        2 stencil (0, 8 bit)
+        2 accum (0, 64 bit)
+        = 32 configs */
+
+    lclNumConfigs = 2 * 2 * 2 * 2 * 2; /* 32 */
+
+    /* alloc */
+    lclVisualConfigs = xcalloc(sizeof(__GLXvisualConfig), lclNumConfigs);
+    lclVisualPrivates = xcalloc(sizeof(void *), lclNumConfigs);
+
+    /* fill in configs */
+    if (NULL != lclVisualConfigs) {
+        i = 0; /* current buffer */
+        for (depth = 0; depth < 2; depth++) {
+            for (aux = 0; aux < 2; aux++) {
+                for (buffers = 0; buffers < 2; buffers++) {
+                    for (stencil = 0; stencil < 2; stencil++) {
+                        for (accum = 0; accum < 2; accum++) {
+                            lclVisualConfigs[i].vid = -1;
+                            lclVisualConfigs[i].class = -1;
+                            lclVisualConfigs[i].rgba = TRUE;
+                            lclVisualConfigs[i].redSize = -1;
+                            lclVisualConfigs[i].greenSize = -1;
+                            lclVisualConfigs[i].blueSize = -1;
+                            lclVisualConfigs[i].redMask = -1;
+                            lclVisualConfigs[i].greenMask = -1;
+                            lclVisualConfigs[i].blueMask = -1;
+                            lclVisualConfigs[i].alphaMask = 0;
+                            if (accum) {
+                                lclVisualConfigs[i].accumRedSize = 16;
+                                lclVisualConfigs[i].accumGreenSize = 16;
+                                lclVisualConfigs[i].accumBlueSize = 16;
+                                lclVisualConfigs[i].accumAlphaSize = 16;
+                            }
+                            else {
+                                lclVisualConfigs[i].accumRedSize = 0;
+                                lclVisualConfigs[i].accumGreenSize = 0;
+                                lclVisualConfigs[i].accumBlueSize = 0;
+                                lclVisualConfigs[i].accumAlphaSize = 0;
+                            }
+                            lclVisualConfigs[i].doubleBuffer = buffers ? TRUE : FALSE;
+                            lclVisualConfigs[i].stereo = FALSE;
+                            lclVisualConfigs[i].bufferSize = -1;
+
+                            lclVisualConfigs[i].depthSize = depth? 24 : 0;
+                            lclVisualConfigs[i].stencilSize = stencil ? 8 : 0;
+                            lclVisualConfigs[i].auxBuffers = aux ? 2 : 0;
+                            lclVisualConfigs[i].level = 0;
+                            lclVisualConfigs[i].visualRating = GLX_NONE_EXT;
+                            lclVisualConfigs[i].transparentPixel = 0;
+                            lclVisualConfigs[i].transparentRed = 0;
+                            lclVisualConfigs[i].transparentGreen = 0;
+                            lclVisualConfigs[i].transparentBlue = 0;
+                            lclVisualConfigs[i].transparentAlpha = 0;
+                            lclVisualConfigs[i].transparentIndex = 0;
+                            i++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (i != lclNumConfigs)
+        GLAQUA_DEBUG_MSG("glAquaInitVisualConfigs failed to alloc visual configs");
+
+    GlxSetVisualConfigs(lclNumConfigs, lclVisualConfigs, lclVisualPrivates);
+}
+
+
 static void glAquaSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
-				   void **privates)
+                                   void **privates)
 {
     GLAQUA_DEBUG_MSG("glAquaSetVisualConfigs\n");
 
@@ -873,19 +1103,21 @@ static void glAquaSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
     visualPrivates = privates;
 }
 
-// Copied from Mesa
 static Bool glAquaInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
-			      int *nvisualp, int *ndepthp,
-			      int *rootDepthp, VisualID *defaultVisp,
-			      unsigned long sizes, int bitsPerRGB)
+                              int *nvisualp, int *ndepthp,
+                              int *rootDepthp, VisualID *defaultVisp,
+                              unsigned long sizes, int bitsPerRGB)
 {
     GLAQUA_DEBUG_MSG("glAquaInitVisuals\n");
 
+    if (numConfigs == 0) /* if no configs */
+        glAquaInitVisualConfigs(); /* ensure the visual configs are setup */
+
     /*
      * Setup the visuals supported by this particular screen.
      */
     return init_visuals(nvisualp, visualp, defaultVisp,
-			*ndepthp, *depthp, *rootDepthp);
+                        *ndepthp, *depthp, *rootDepthp);
 }
 
 
@@ -893,100 +1125,92 @@ static void fixup_visuals(int screen)
 {
     ScreenPtr pScreen = screenInfo.screens[screen];
     glAquaScreenRec *pScr = &glAquaScreens[screen];
-    __GLXvisualConfig *pGLXVis  = pScr->glx_vis;
-    VisualPtr pVis;
-    int i, j;
+    int j;
+    __GLcontextModes *modes;
 
     GLAQUA_DEBUG_MSG("fixup_visuals\n");
 
-    for (i = 0; i < pScr->num_vis; i++, pGLXVis++) {
-	pVis = pScreen->visuals;
-
-	/* Find a visual that matches the GLX visual's class and size */
-	for (j = 0; j < pScreen->numVisuals; j++, pVis++) {
-	    if (pVis->class == pGLXVis->class &&
-		pVis->nplanes == pGLXVis->bufferSize) {
-
-		/* Fixup the masks */
-		pGLXVis->redMask   = pVis->redMask;
-		pGLXVis->greenMask = pVis->greenMask;
-		pGLXVis->blueMask  = pVis->blueMask;
-
-		/* Recalc the sizes */
-		pGLXVis->redSize   = count_bits(pGLXVis->redMask);
-		pGLXVis->greenSize = count_bits(pGLXVis->greenMask);
-		pGLXVis->blueSize  = count_bits(pGLXVis->blueMask);
-	    }
-	}
+    for ( modes = pScr->modes ; modes != NULL ; modes = modes->next ) {
+        const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
+        const int nplanes = (modes->rgbBits - modes->alphaBits);
+        const VisualPtr pVis = pScreen->visuals;
+
+        /* Find a visual that matches the GLX visual's class and size */
+        for (j = 0; j < pScreen->numVisuals; j++) {
+            if (pVis[j].class == vis_class &&
+            pVis[j].nplanes == nplanes) {
+
+            /* Fixup the masks */
+            modes->redMask   = pVis[j].redMask;
+            modes->greenMask = pVis[j].greenMask;
+            modes->blueMask  = pVis[j].blueMask;
+
+            /* Recalc the sizes */
+            modes->redBits   = count_bits(modes->redMask);
+            modes->greenBits = count_bits(modes->greenMask);
+            modes->blueBits  = count_bits(modes->blueMask);
+            }
+        }
     }
 }
 
 static void init_screen_visuals(int screen)
 {
     ScreenPtr pScreen = screenInfo.screens[screen];
-    __GLXvisualConfig *pGLXVis = glAquaScreens[screen].glx_vis;
-    // XMesaVisual *pXMesaVisual;
-    VisualPtr pVis;
+    __GLcontextModes *modes;
     int *used;
     int i, j;
 
     GLAQUA_DEBUG_MSG("init_screen_visuals\n");
 
-    /* Alloc space for the list of XMesa visuals */
-    // pXMesaVisual = (XMesaVisual *)__glXMalloc(MESAScreens[screen].num_vis *
-    //					      sizeof(XMesaVisual));
-    // __glXMemset(pXMesaVisual, 0,
-    //		MESAScreens[screen].num_vis * sizeof(XMesaVisual));
-
+    /* FIXME: Change 'used' to be a array of bits (rather than of ints),
+     * FIXME: create a stack array of 8 or 16 bytes.  If 'numVisuals' is less
+     * FIXME: than 64 or 128 the stack array can be used instead of calling
+     * FIXME: __glXMalloc / __glXFree.  If nothing else, convert 'used' to
+     * FIXME: array of bytes instead of ints!
+     */
     used = (int *)__glXMalloc(pScreen->numVisuals * sizeof(int));
     __glXMemset(used, 0, pScreen->numVisuals * sizeof(int));
 
-    for (i = 0; i < glAquaScreens[screen].num_vis; i++, pGLXVis++) {
-	pVis = pScreen->visuals;
-	for (j = 0; j < pScreen->numVisuals; j++, pVis++) {
-
-	    if (pVis->class == pGLXVis->class &&
-		pVis->nplanes == pGLXVis->bufferSize &&
-		!used[j]) {
-
-		if (pVis->redMask   == pGLXVis->redMask &&
-		    pVis->greenMask == pGLXVis->greenMask &&
-		    pVis->blueMask  == pGLXVis->blueMask) {
-
-		    /* Create the XMesa visual */
-		    /*
-		    pXMesaVisual[i] =
-                         XMesaCreateVisual(pScreen,
-					   pVis,
-					   pGLXVis->rgba,
-					   (pGLXVis->alphaSize > 0),
-					   pGLXVis->doubleBuffer,
-					   pGLXVis->stereo,
-					   GL_TRUE, // ximage_flag
-					   pGLXVis->depthSize,
-					   pGLXVis->stencilSize,
-					   pGLXVis->accumRedSize,
-					   pGLXVis->accumGreenSize,
-					   pGLXVis->accumBlueSize,
-					   pGLXVis->accumAlphaSize,
-                                           0,  // numSamples
-					   pGLXVis->level,
-                                           pGLXVis->visualRating );
-		    */
-		    /* Set the VisualID */
-		    pGLXVis->vid = pVis->vid;
-
-		    /* Mark this visual used */
-		    used[j] = 1;
-		    break;
-		}
-	    }
-	}
+    i = 0;
+    for ( modes = glAquaScreens[screen].modes 
+          ; modes != NULL
+          ; modes = modes->next ) {
+        const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
+        const int nplanes = (modes->rgbBits - modes->alphaBits);
+        const VisualPtr pVis = pScreen->visuals;
+
+        for (j = 0; j < pScreen->numVisuals; j++) {
+            if (pVis[j].class     == vis_class &&
+                pVis[j].nplanes   == nplanes &&
+                pVis[j].redMask   == modes->redMask &&
+                pVis[j].greenMask == modes->greenMask &&
+                pVis[j].blueMask  == modes->blueMask &&
+                !used[j]) {
+
+                    /* Set the VisualID */
+                    modes->visualID = pVis[j].vid;
+
+                    /* Mark this visual used */
+                    used[j] = 1;
+                    break;
+            }
+        }
+        if ( j == pScreen->numVisuals ) {
+            ErrorF("No matching visual for __GLcontextMode with "
+                   "visual class = %d (%d), nplanes = %u\n",
+                   vis_class, 
+                   (int)modes->visualType,
+                   (unsigned int)(modes->rgbBits - modes->alphaBits) );
+        }
+        else if ( modes->visualID == -1 ) {
+            FatalError( "Matching visual found, but visualID still -1!\n" );
+        }
+
+        i++;
     }
 
     __glXFree(used);
-
-    // glAquaScreens[screen].xm_vis = pXMesaVisual;
 }
 
 static Bool glAquaScreenProbe(int screen)
@@ -999,10 +1223,10 @@ static Bool glAquaScreenProbe(int screen)
     /*
      * Set up the current screen's visuals.
      */
-    __glDDXScreenInfo.pGlxVisual = glAquaScreens[screen].glx_vis;
+    __glDDXScreenInfo.modes = glAquaScreens[screen].modes;
     __glDDXScreenInfo.pVisualPriv = glAquaScreens[screen].priv;
     __glDDXScreenInfo.numVisuals =
-	__glDDXScreenInfo.numUsableVisuals = glAquaScreens[screen].num_vis;
+        __glDDXScreenInfo.numUsableVisuals = glAquaScreens[screen].num_vis;
 
     /*
      * Set the current screen's createContext routine.  This could be
@@ -1022,7 +1246,9 @@ static Bool glAquaScreenProbe(int screen)
      */
     init_screen_visuals(screen);
 
-    // Wrap RealizeWindow and UnrealizeWindow on this screen
+    /*
+     * Wrap RealizeWindow and UnrealizeWindow on this screen
+     */
     pScreen = screenInfo.screens[screen];
     screenPriv = &glAquaScreens[screen];
     screenPriv->RealizeWindow = pScreen->RealizeWindow;
@@ -1035,28 +1261,28 @@ static Bool glAquaScreenProbe(int screen)
 
 
 static GLboolean glAquaResizeBuffers(__GLdrawableBuffer *buffer,
-				     GLint x, GLint y,
-				     GLuint width, GLuint height,
-				     __GLdrawablePrivate *glPriv,
-				     GLuint bufferMask)
+                                     GLint x, GLint y,
+                                     GLuint width, GLuint height,
+                                     __GLdrawablePrivate *glPriv,
+                                     GLuint bufferMask)
 {
     GLAquaDrawableRec *aquaPriv = (GLAquaDrawableRec *)glPriv->private;
+    __GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *)glPriv->other;
     __GLXcontext *gx;
     __GLcontext *gc;
-    __GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *)glPriv->other;
 
     GLAQUA_DEBUG_MSG("glAquaResizeBuffers to (%d %d %d %d)\n", x, y, width, height);
 
     // update all contexts that point at this drawable for drawing (hack?)
-    for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->next) {
+    for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->nextDrawPriv) {
         gc = (__GLcontext *)gx->gc;
-        attach(gc, glPriv, x, y, width, height);
+        attach(gc, glPriv);
     }
 
     // update all contexts that point at this drawable for reading (hack?)
-    for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->next) {
+    for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->nextReadPriv) {
         gc = (__GLcontext *)gx->gc;
-        attach(gc, glPriv, x, y, width, height);
+        attach(gc, glPriv);
     }
 
     return aquaPriv->resize(buffer, x, y, width, height, glPriv, bufferMask);
@@ -1122,24 +1348,24 @@ GLint __glEvalComputeK(GLenum target)
     case GL_MAP2_VERTEX_4:
     case GL_MAP2_COLOR_4:
     case GL_MAP2_TEXTURE_COORD_4:
-	return 4;
+        return 4;
     case GL_MAP1_VERTEX_3:
     case GL_MAP1_TEXTURE_COORD_3:
     case GL_MAP1_NORMAL:
     case GL_MAP2_VERTEX_3:
     case GL_MAP2_TEXTURE_COORD_3:
     case GL_MAP2_NORMAL:
-	return 3;
+        return 3;
     case GL_MAP1_TEXTURE_COORD_2:
     case GL_MAP2_TEXTURE_COORD_2:
-	return 2;
+        return 2;
     case GL_MAP1_TEXTURE_COORD_1:
     case GL_MAP2_TEXTURE_COORD_1:
     case GL_MAP1_INDEX:
     case GL_MAP2_INDEX:
-	return 1;
+        return 1;
     default:
-	return 0;
+        return 0;
     }
 }
 
@@ -1148,8 +1374,8 @@ GLuint __glFloorLog2(GLuint val)
     int c = 0;
 
     while (val > 1) {
-	c++;
-	val >>= 1;
+        c++;
+        val >>= 1;
     }
     return c;
 }
diff --git a/GL/apple/indirect.c b/GL/apple/indirect.c
index c4d235a47..f885e526e 100644
--- a/GL/apple/indirect.c
+++ b/GL/apple/indirect.c
@@ -5,8 +5,9 @@
 /*
  * Copyright (c) 2002 Greg Parker. All Rights Reserved.
  * Copyright (c) 2002 Apple Computer, Inc.
+ * Copyright (c) 2004 Torrey T. Lyons. All Rights Reserved.
  *
- * Portions of this file are copied from xf86glx.c,
+ * Portions of this file are copied from Mesa's xf86glx.c,
  * which contains the following copyright:
  *
  * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
@@ -29,10 +30,6 @@
  * 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(s) of the above copyright
- * holders shall not be used in advertising or otherwise to promote the sale,
- * use or other dealings in this Software without prior written authorization.
  */
 /* $XFree86: xc/programs/Xserver/GL/apple/indirect.c,v 1.2 2003/09/16 00:36:11 torrey Exp $ */
 
@@ -61,6 +58,8 @@
 #include "x-hash.h"
 #include "x-list.h"
 
+#include "glcontextmodes.h"
+
 // ggs: needed to call back to glx with visual configs
 extern void GlxSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs, void **configprivs);
 
@@ -89,14 +88,14 @@ GLboolean glIsTextureEXT(GLuint h) {
 // some prototypes
 static Bool glAquaScreenProbe(int screen);
 static Bool glAquaInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
-			      int *nvisualp, int *ndepthp,
-			      int *rootDepthp, VisualID *defaultVisp,
-			      unsigned long sizes, int bitsPerRGB);
+                              int *nvisualp, int *ndepthp,
+                              int *rootDepthp, VisualID *defaultVisp,
+                              unsigned long sizes, int bitsPerRGB);
 static void glAquaSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
-				   void **privates);
+                                   void **privates);
 static __GLinterface *glAquaCreateContext(__GLimports *imports,
-					  __GLcontextModes *mode,
-					  __GLinterface *shareGC);
+                                          __GLcontextModes *mode,
+                                          __GLinterface *shareGC);
 static void glAquaCreateBuffer(__GLXdrawablePrivate *glxPriv);
 static void glAquaResetExtension(void);
 
@@ -106,14 +105,14 @@ static void glAquaResetExtension(void);
  * __glXScreenInit to initialize each of the active screens
  * (__glXActiveScreens[]).  Several of the fields must be initialized by
  * the screenProbe routine before they are copied to the active screens
- * struct.  In particular, the contextCreate, pGlxVisual, numVisuals,
+ * struct.  In particular, the contextCreate, modes, numVisuals,
  * and numUsableVisuals fields must be initialized.
  */
-__GLXscreenInfo __glDDXScreenInfo = {
+static __GLXscreenInfo __glDDXScreenInfo = {
     glAquaScreenProbe,   /* Must be generic and handle all screens */
     glAquaCreateContext, /* Substitute screen's createContext routine */
     glAquaCreateBuffer,  /* Substitute screen's createBuffer routine */
-    NULL,                 /* Set up pGlxVisual in probe */
+    NULL,                 /* Set up modes in probe */
     NULL,                 /* Set up pVisualPriv in probe */
     0,                    /* Set up numVisuals in probe */
     0,                    /* Set up numUsableVisuals in probe */
@@ -123,13 +122,21 @@ __GLXscreenInfo __glDDXScreenInfo = {
     NULL                  /* WrappedPositionWindow is overwritten */
 };
 
-__GLXextensionInfo __glDDXExtensionInfo = {
+void *__glXglDDXScreenInfo(void) {
+    return &__glDDXScreenInfo;
+}
+
+static __GLXextensionInfo __glDDXExtensionInfo = {
     GL_CORE_APPLE,
     glAquaResetExtension,
     glAquaInitVisuals,
     glAquaSetVisualConfigs
 };
 
+void *__glXglDDXExtensionInfo(void) {
+    return &__glDDXExtensionInfo;
+}
+
 // prototypes
 
 static GLboolean glAquaDestroyContext(__GLcontext *gc);
@@ -137,7 +144,7 @@ static GLboolean glAquaLoseCurrent(__GLcontext *gc);
 static GLboolean glAquaMakeCurrent(__GLcontext *gc);
 static GLboolean glAquaShareContext(__GLcontext *gc, __GLcontext *gcShare);
 static GLboolean glAquaCopyContext(__GLcontext *dst, const __GLcontext *src,
-			    GLuint mask);
+                                    GLuint mask);
 static GLboolean glAquaForceCurrent(__GLcontext *gc);
 
 /* Drawing surface notification callbacks */
@@ -169,7 +176,7 @@ static __GLexports glAquaExports = {
 
 typedef struct {
     int num_vis;
-    __GLXvisualConfig *glx_vis;
+    __GLcontextModes *modes;
     void **priv;
 
     // wrapped screen functions
@@ -186,15 +193,15 @@ typedef struct {
 } GLAquaDrawableRec;
 
 struct __GLcontextRec {
-  struct __GLinterfaceRec interface; // required to be first
+    struct __GLinterfaceRec interface; // required to be first
 
-  CGLContextObj ctx;
-  CGLPixelFormatObj pixelFormat;
+    CGLContextObj ctx;
+    CGLPixelFormatObj pixelFormat;
 
-  /* set when attached */
-  xp_surface_id sid;
+    /* set when attached */
+    xp_surface_id sid;
 
-  unsigned isAttached :1;
+    unsigned isAttached :1;
 };
 
 /* maps from surface id -> list of __GLcontext */
@@ -210,18 +217,18 @@ static GLboolean glAquaDestroyContext(__GLcontext *gc)
 
     if (gc != NULL)
     {
-	if (gc->sid != 0 && surface_hash != NULL)
-	{
-	    lst = x_hash_table_lookup(surface_hash, (void *) gc->sid, NULL);
-	    lst = x_list_remove(lst, gc);
-	    x_hash_table_insert(surface_hash, (void *) gc->sid, lst);
-	}
+        if (gc->sid != 0 && surface_hash != NULL)
+        {
+            lst = x_hash_table_lookup(surface_hash, (void *) gc->sid, NULL);
+            lst = x_list_remove(lst, gc);
+            x_hash_table_insert(surface_hash, (void *) gc->sid, lst);
+        }
 
         if (gc->ctx != NULL)
-	    CGLDestroyContext(gc->ctx);
+            CGLDestroyContext(gc->ctx);
 
         if (gc->pixelFormat != NULL)
-	    CGLDestroyPixelFormat(gc->pixelFormat);
+            CGLDestroyPixelFormat(gc->pixelFormat);
 
         free(gc);
     }
@@ -237,7 +244,7 @@ static GLboolean glAquaLoseCurrent(__GLcontext *gc)
 
     gl_err = CGLSetCurrentContext(NULL);
     if (gl_err != 0)
-	ErrorF("CGLSetCurrentContext error: %s\n", CGLErrorString(gl_err));
+        ErrorF("CGLSetCurrentContext error: %s\n", CGLErrorString(gl_err));
 
     __glXLastContext = NULL; // Mesa does this; why?
 
@@ -256,24 +263,24 @@ static void surface_notify(void *_arg, void *data)
     switch (arg->kind)
     {
     case AppleDRISurfaceNotifyDestroyed:
-	if (surface_hash != NULL)
-	    x_hash_table_remove(surface_hash, (void *) arg->id);
+        if (surface_hash != NULL)
+            x_hash_table_remove(surface_hash, (void *) arg->id);
 
-	aquaPriv->pDraw = NULL;
-	aquaPriv->sid = 0;
-	break;
+        aquaPriv->pDraw = NULL;
+        aquaPriv->sid = 0;
+        break;
 
     case AppleDRISurfaceNotifyChanged:
-	if (surface_hash != NULL)
-	{
-	    lst = x_hash_table_lookup(surface_hash, (void *) arg->id, NULL);
-	    for (; lst != NULL; lst = lst->next)
-	    {
-		gc = lst->data;
-		xp_update_gl_context(gc->ctx);
-	    }
-	}
-	break;
+        if (surface_hash != NULL)
+        {
+            lst = x_hash_table_lookup(surface_hash, (void *) arg->id, NULL);
+            for (; lst != NULL; lst = lst->next)
+            {
+            gc = lst->data;
+            xp_update_gl_context(gc->ctx);
+            }
+        }
+        break;
     }
 }
 
@@ -283,18 +290,18 @@ static void unattach(__GLcontext *gc)
 
     if (gc->isAttached)
     {
-	GLAQUA_DEBUG_MSG("unattaching\n");
-
-	if (surface_hash != NULL)
-	{
-	    lst = x_hash_table_lookup(surface_hash, (void *) gc->sid, NULL);
-	    lst = x_list_remove(lst, gc);
-	    x_hash_table_insert(surface_hash, (void *) gc->sid, lst);
-	}
-
-	CGLClearDrawable(gc->ctx);
-	gc->isAttached = FALSE;
-	gc->sid = 0;
+        GLAQUA_DEBUG_MSG("unattaching\n");
+
+        if (surface_hash != NULL)
+        {
+            lst = x_hash_table_lookup(surface_hash, (void *) gc->sid, NULL);
+            lst = x_list_remove(lst, gc);
+            x_hash_table_insert(surface_hash, (void *) gc->sid, lst);
+        }
+
+        CGLClearDrawable(gc->ctx);
+        gc->isAttached = FALSE;
+        gc->sid = 0;
     }
 }
 
@@ -307,52 +314,52 @@ static void attach(__GLcontext *gc, __GLdrawablePrivate *glPriv)
     if (glxPriv->type == DRAWABLE_WINDOW)
     {
         WindowPtr pWin = (WindowPtr) glxPriv->pDraw;
-	GLAquaDrawableRec *aquaPriv = (GLAquaDrawableRec *)glPriv->private;
-	x_list *lst;
+        GLAquaDrawableRec *aquaPriv = (GLAquaDrawableRec *)glPriv->private;
+        x_list *lst;
 
-	if (aquaPriv->sid == 0)
-	{
-	    if (!quartzProcs->CreateSurface(pWin->drawable.pScreen,
+        if (aquaPriv->sid == 0)
+        {
+            if (!quartzProcs->CreateSurface(pWin->drawable.pScreen,
                                   pWin->drawable.id, &pWin->drawable,
                                   0, &aquaPriv->sid, NULL,
                                   surface_notify, aquaPriv))
-	    {
-		return;
-	    }
-	    aquaPriv->pDraw = &pWin->drawable;
-	}
-
-	if (!gc->isAttached || gc->sid != aquaPriv->sid)
-	{
-	    if (xp_attach_gl_context(gc->ctx, aquaPriv->sid) != Success)
-	    {
-		quartzProcs->DestroySurface(pWin->drawable.pScreen,
-                                  pWin->drawable.id, &pWin->drawable, 
-                                  surface_notify, aquaPriv);
-
-		if (surface_hash != NULL)
-		    x_hash_table_remove(surface_hash, (void *) aquaPriv->sid);
-
-		aquaPriv->sid = 0;
-		return;
-	    }
-
-	    gc->isAttached = TRUE;
-	    gc->sid = aquaPriv->sid;
-
-	    if (surface_hash == NULL)
-		surface_hash = x_hash_table_new(NULL, NULL, NULL, NULL);
-
-	    lst = x_hash_table_lookup(surface_hash, (void *) gc->sid, NULL);
-	    if (x_list_find(lst, gc) == NULL)
-	    {
-		lst = x_list_prepend(lst, gc);
-		x_hash_table_insert(surface_hash, (void *) gc->sid, lst);
-	    }
-
-	    GLAQUA_DEBUG_MSG("attached 0x%x to 0x%x\n", pWin->drawable.id,
+            {
+            return;
+            }
+            aquaPriv->pDraw = &pWin->drawable;
+        }
+
+        if (!gc->isAttached || gc->sid != aquaPriv->sid)
+        {
+            if (xp_attach_gl_context(gc->ctx, aquaPriv->sid) != Success)
+            {
+            quartzProcs->DestroySurface(pWin->drawable.pScreen,
+                                        pWin->drawable.id, &pWin->drawable, 
+                                        surface_notify, aquaPriv);
+
+            if (surface_hash != NULL)
+                x_hash_table_remove(surface_hash, (void *) aquaPriv->sid);
+
+            aquaPriv->sid = 0;
+            return;
+            }
+
+            gc->isAttached = TRUE;
+            gc->sid = aquaPriv->sid;
+
+            if (surface_hash == NULL)
+                surface_hash = x_hash_table_new(NULL, NULL, NULL, NULL);
+
+            lst = x_hash_table_lookup(surface_hash, (void *) gc->sid, NULL);
+            if (x_list_find(lst, gc) == NULL)
+            {
+                lst = x_list_prepend(lst, gc);
+                x_hash_table_insert(surface_hash, (void *) gc->sid, lst);
+            }
+
+            GLAQUA_DEBUG_MSG("attached 0x%x to 0x%x\n", pWin->drawable.id,
                              aquaPriv->sid);
-	}
+        }
     } else {
         GLAQUA_DEBUG_MSG("attach: attach to non-window unimplemented\n");
         CGLClearDrawable(gc->ctx);
@@ -371,7 +378,7 @@ static GLboolean glAquaMakeCurrent(__GLcontext *gc)
 
     gl_err = CGLSetCurrentContext(gc->ctx);
     if (gl_err != 0)
-	ErrorF("CGLSetCurrentContext error: %s\n", CGLErrorString(gl_err));
+        ErrorF("CGLSetCurrentContext error: %s\n", CGLErrorString(gl_err));
 
     return gl_err == 0;
 }
@@ -392,7 +399,7 @@ static GLboolean glAquaCopyContext(__GLcontext *dst, const __GLcontext *src,
 
     gl_err = CGLCopyContext(src->ctx, dst->ctx, mask);
     if (gl_err != 0)
-	ErrorF("CGLCopyContext error: %s\n", CGLErrorString(gl_err));
+        ErrorF("CGLCopyContext error: %s\n", CGLErrorString(gl_err));
 
     return gl_err == 0;
 }
@@ -405,7 +412,7 @@ static GLboolean glAquaForceCurrent(__GLcontext *gc)
 
     gl_err = CGLSetCurrentContext(gc->ctx);
     if (gl_err != 0)
-	ErrorF("CGLSetCurrentContext error: %s\n", CGLErrorString(gl_err));
+        ErrorF("CGLSetCurrentContext error: %s\n", CGLErrorString(gl_err));
 
     return gl_err == 0;
 }
@@ -456,7 +463,7 @@ static CGLPixelFormatObj makeFormat(__GLcontextModes *mode)
     GLAQUA_DEBUG_MSG("makeFormat\n");
 
     if (!mode->rgbMode)
-	return NULL;
+        return NULL;
 
     i = 0;
 
@@ -471,14 +478,14 @@ static CGLPixelFormatObj makeFormat(__GLcontextModes *mode)
     }
 
     if (mode->colorIndexMode) {
-	/* ignored */
+        /* ignored */
     }
 
     if (mode->rgbMode) {
         attr[i++] = kCGLPFAColorSize;
         attr[i++] = mode->redBits + mode->greenBits + mode->blueBits;
         attr[i++] = kCGLPFAAlphaSize;
-	attr[i++] = 1; /* FIXME: ignoring mode->alphaBits which is always 0 */
+        attr[i++] = 1; /* FIXME: ignoring mode->alphaBits which is always 0 */
     }
 
     if (mode->haveAccumBuffer) {
@@ -509,7 +516,7 @@ static CGLPixelFormatObj makeFormat(__GLcontextModes *mode)
     result = NULL;
     gl_err = CGLChoosePixelFormat(attr, &result, &n_formats);
     if (gl_err != 0)
-	ErrorF("CGLChoosePixelFormat error: %s\n", CGLErrorString(gl_err));
+        ErrorF("CGLChoosePixelFormat error: %s\n", CGLErrorString(gl_err));
 
     GLAQUA_DEBUG_MSG("makeFormat done (0x%x)\n", result);
 
@@ -517,8 +524,8 @@ static CGLPixelFormatObj makeFormat(__GLcontextModes *mode)
 }
 
 static __GLinterface *glAquaCreateContext(__GLimports *imports,
-					  __GLcontextModes *mode,
-					  __GLinterface *shareGC)
+                                          __GLcontextModes *mode,
+                                          __GLinterface *shareGC)
 {
     __GLcontext *result;
     __GLcontext *sharectx = (__GLcontext *)shareGC;
@@ -540,11 +547,11 @@ static __GLinterface *glAquaCreateContext(__GLimports *imports,
 
     result->ctx = NULL;
     gl_err = CGLCreateContext(result->pixelFormat,
-			      sharectx ? sharectx->ctx : NULL,
-			      &result->ctx);
+                              sharectx ? sharectx->ctx : NULL,
+                              &result->ctx);
 
     if (gl_err != 0) {
-	ErrorF("CGLCreateContext error: %s\n", CGLErrorString(gl_err));
+        ErrorF("CGLCreateContext error: %s\n", CGLErrorString(gl_err));
         CGLDestroyPixelFormat(result->pixelFormat);
         free(result);
         return NULL;
@@ -638,19 +645,22 @@ glAquaUnrealizeWindow(WindowPtr pWin)
     return result;
 }
 
-/*
- * In the case the driver has no GLX visuals we'll use these.
- * [0] = RGB, double buffered
- * [1] = RGB, double buffered, stencil, accum
- */
+
 // Originally copied from Mesa
 
 static int                 numConfigs     = 0;
 static __GLXvisualConfig  *visualConfigs  = NULL;
 static void              **visualPrivates = NULL;
 
-#define NUM_FALLBACK_CONFIGS 2
+/*
+ * In the case the driver defines no GLX visuals we'll use these.
+ * Note that for TrueColor and DirectColor visuals, bufferSize is the 
+ * sum of redSize, greenSize, blueSize and alphaSize, which may be larger 
+ * than the nplanes/rootDepth of the server's X11 visuals
+ */
+#define NUM_FALLBACK_CONFIGS 5
 static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
+  /* [0] = RGB, double buffered, Z */
   {
     -1,                 /* vid */
     -1,                 /* class */
@@ -665,11 +675,12 @@ static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
     0,                  /* stencilSize */
     0,                  /* auxBuffers */
     0,                  /* level */
-    GLX_NONE_EXT,       /* visualRating */
-    0,                  /* transparentPixel */
+    GLX_NONE,           /* visualRating */
+    GLX_NONE,           /* transparentPixel */
     0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
     0                   /* transparentIndex */
   },
+  /* [1] = RGB, double buffered, Z, stencil, accum */
   {
     -1,                 /* vid */
     -1,                 /* class */
@@ -684,11 +695,71 @@ static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
     8,                  /* stencilSize */
     0,                  /* auxBuffers */
     0,                  /* level */
-    GLX_NONE_EXT,       /* visualRating */
-    0,                  /* transparentPixel */
+    GLX_NONE,           /* visualRating */
+    GLX_NONE,           /* transparentPixel */
+    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
+    0                   /* transparentIndex */
+  },
+  /* [2] = RGB+Alpha, double buffered, Z, stencil, accum */
+  {
+    -1,                 /* vid */
+    -1,                 /* class */
+    True,               /* rgba */
+    -1, -1, -1, 8,      /* rgba sizes */
+    -1, -1, -1, -1,     /* rgba masks */
+    16, 16, 16, 16,     /* rgba accum sizes */
+    True,               /* doubleBuffer */
+    False,              /* stereo */
+    -1,                 /* bufferSize */
+    16,                 /* depthSize */
+    8,                  /* stencilSize */
+    0,                  /* auxBuffers */
+    0,                  /* level */
+    GLX_NONE,           /* visualRating */
+    GLX_NONE,           /* transparentPixel */
     0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
     0                   /* transparentIndex */
-  }
+  },
+  /* [3] = RGB+Alpha, single buffered, Z, stencil, accum */
+  {
+    -1,                 /* vid */
+    -1,                 /* class */
+    True,               /* rgba */
+    -1, -1, -1, 8,      /* rgba sizes */
+    -1, -1, -1, -1,     /* rgba masks */
+    16, 16, 16, 16,     /* rgba accum sizes */
+    False,              /* doubleBuffer */
+    False,              /* stereo */
+    -1,                 /* bufferSize */
+    16,                 /* depthSize */
+    8,                  /* stencilSize */
+    0,                  /* auxBuffers */
+    0,                  /* level */
+    GLX_NONE,           /* visualRating */
+    GLX_NONE,           /* transparentPixel */
+    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
+    0                   /* transparentIndex */
+  },
+  /* [4] = CI, double buffered, Z */
+  {
+    -1,                 /* vid */
+    -1,                 /* class */
+    False,              /* rgba? (false = color index) */
+    -1, -1, -1, 0,      /* rgba sizes */
+    -1, -1, -1, 0,      /* rgba masks */
+     0,  0,  0, 0,      /* rgba accum sizes */
+    True,               /* doubleBuffer */
+    False,              /* stereo */
+    -1,                 /* bufferSize */
+    16,                 /* depthSize */
+    0,                  /* stencilSize */
+    0,                  /* auxBuffers */
+    0,                  /* level */
+    GLX_NONE,           /* visualRating */
+    GLX_NONE,           /* transparentPixel */
+    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
+    0                   /* transparentIndex */
+  },
 };
 
 static __GLXvisualConfig NullConfig = {
@@ -721,11 +792,11 @@ static inline int count_bits(uint32_t x)
     return x & 63;
 }
 
-// Mostly copied from Mesa's xf86glx.c
+
 static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
-			 VisualID *defaultVisp,
-			 int ndepth, DepthPtr pdepth,
-			 int rootDepth)
+                         VisualID *defaultVisp,
+                         int ndepth, DepthPtr pdepth,
+                         int rootDepth)
 {
     int numRGBconfigs;
     int numCIconfigs;
@@ -735,7 +806,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     VisualPtr pVisual = *visualp;
     VisualPtr pVisualNew = NULL;
     VisualID *orig_vid = NULL;
-    __GLXvisualConfig *glXVisualPtr = NULL;
+    __GLcontextModes *modes;
     __GLXvisualConfig *pNewVisualConfigs = NULL;
     void **glXVisualPriv;
     void **pNewVisualPriv;
@@ -753,14 +824,14 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     pNewVisualConfigs = (__GLXvisualConfig *)
                      __glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig));
     if (!pNewVisualConfigs) {
-	return FALSE;
+        return FALSE;
     }
 
     /* Alloc space for the list of new GLX visual privates */
     pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *));
     if (!pNewVisualPriv) {
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
     }
 
     /*
@@ -768,9 +839,9 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     ** visual configs.
     */
     if (numConfigs == 0) {
-	memcpy(pNewVisualConfigs, FallbackConfigs,
+        memcpy(pNewVisualConfigs, FallbackConfigs,
                NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig));
-	memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
+        memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
     }
     else {
         /* copy driver's visual config info */
@@ -784,22 +855,22 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     numRGBconfigs = 0;
     numCIconfigs = 0;
     for (i = 0; i < numNewConfigs; i++) {
-	if (pNewVisualConfigs[i].rgba)
-	    numRGBconfigs++;
-	else
-	    numCIconfigs++;
+        if (pNewVisualConfigs[i].rgba)
+            numRGBconfigs++;
+        else
+            numCIconfigs++;
     }
 
     /* Count the total number of visuals to compute */
     numNewVisuals = 0;
     for (i = 0; i < numVisuals; i++) {
-	int count;
+        int count;
 
-	count = ((pVisual[i].class == TrueColor
-		  || pVisual[i].class == DirectColor)
-		 ? numRGBconfigs : numCIconfigs);
-	if (count == 0)
-	    count = 1;			/* preserve the existing visual */
+        count = ((pVisual[i].class == TrueColor
+              || pVisual[i].class == DirectColor)
+             ? numRGBconfigs : numCIconfigs);
+        if (count == 0)
+            count = 1;          /* preserve the existing visual */
 
         numNewVisuals += count;
     }
@@ -811,154 +882,159 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     /* Alloc temp space for the list of orig VisualIDs for each new visual */
     orig_vid = (VisualID *)__glXMalloc(numNewVisuals * sizeof(VisualID));
     if (!orig_vid) {
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+        __glXFree(pNewVisualPriv);
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
     }
 
     /* Alloc space for the list of glXVisuals */
-    glXVisualPtr = (__GLXvisualConfig *)__glXMalloc(numNewVisuals *
-						    sizeof(__GLXvisualConfig));
-    if (!glXVisualPtr) {
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+    modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes));
+    if (modes == NULL) {
+        __glXFree(orig_vid);
+        __glXFree(pNewVisualPriv);
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
     }
 
     /* Alloc space for the list of glXVisualPrivates */
     glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *));
     if (!glXVisualPriv) {
-	__glXFree(glXVisualPtr);
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+        _gl_context_modes_destroy( modes );
+        __glXFree(orig_vid);
+        __glXFree(pNewVisualPriv);
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
     }
 
     /* Alloc space for the new list of the X server's visuals */
     pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec));
     if (!pVisualNew) {
-	__glXFree(glXVisualPriv);
-	__glXFree(glXVisualPtr);
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
-	return FALSE;
+        __glXFree(glXVisualPriv);
+        _gl_context_modes_destroy( modes );
+        __glXFree(orig_vid);
+        __glXFree(pNewVisualPriv);
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
     }
 
     /* Initialize the new visuals */
     found_default = FALSE;
+    glAquaScreens[screenInfo.numScreens-1].modes = modes;
     for (i = j = 0; i < numVisuals; i++) {
         int is_rgb = (pVisual[i].class == TrueColor ||
-		      pVisual[i].class == DirectColor);
-
-	if (!is_rgb)
-	{
-	    /* We don't support non-rgb visuals for GL. But we don't
-	       want to remove them either, so just pass them through
-	       with null glX configs */
-
-	    pVisualNew[j] = pVisual[i];
-	    pVisualNew[j].vid = FakeClientID(0);
-
-	    /* Check for the default visual */
-	    if (!found_default && pVisual[i].vid == *defaultVisp) {
-		*defaultVisp = pVisualNew[j].vid;
-		found_default = TRUE;
-	    }
-
-	    /* Save the old VisualID */
-	    orig_vid[j] = pVisual[i].vid;
-
-	    /* Initialize the glXVisual */
-	    glXVisualPtr[j] = NullConfig;
-	    glXVisualPriv[j] = NULL;
-
-	    j++;
-
-	    continue;
-	}
-
-	for (k = 0; k < numNewConfigs; k++) {
-	    if (pNewVisualConfigs[k].rgba != is_rgb)
-		continue;
-
-	    /* Initialize the new visual */
-	    pVisualNew[j] = pVisual[i];
-	    pVisualNew[j].vid = FakeClientID(0);
-
-	    /* Check for the default visual */
-	    if (!found_default && pVisual[i].vid == *defaultVisp) {
-		*defaultVisp = pVisualNew[j].vid;
-		found_default = TRUE;
-	    }
-
-	    /* Save the old VisualID */
-	    orig_vid[j] = pVisual[i].vid;
-
-	    /* Initialize the glXVisual */
-	    glXVisualPtr[j] = pNewVisualConfigs[k];
-	    glXVisualPtr[j].vid = pVisualNew[j].vid;
-
-	    /*
-	     * If the class is -1, then assume the X visual information
-	     * is identical to what GLX needs, and take them from the X
-	     * visual.  NOTE: if class != -1, then all other fields MUST
-	     * be initialized.
-	     */
-	    if (glXVisualPtr[j].class == -1) {
-		glXVisualPtr[j].class      = pVisual[i].class;
-		glXVisualPtr[j].redSize    = count_bits(pVisual[i].redMask);
-		glXVisualPtr[j].greenSize  = count_bits(pVisual[i].greenMask);
-		glXVisualPtr[j].blueSize   = count_bits(pVisual[i].blueMask);
-		glXVisualPtr[j].alphaSize  = glXVisualPtr[j].alphaSize;
-		glXVisualPtr[j].redMask    = pVisual[i].redMask;
-		glXVisualPtr[j].greenMask  = pVisual[i].greenMask;
-		glXVisualPtr[j].blueMask   = pVisual[i].blueMask;
-		glXVisualPtr[j].alphaMask  = glXVisualPtr[j].alphaMask;
-		glXVisualPtr[j].bufferSize = rootDepth;
-	    }
-
-	    /* Save the device-dependent private for this visual */
-	    glXVisualPriv[j] = pNewVisualPriv[k];
-
-	    j++;
-	}
+                      pVisual[i].class == DirectColor);
+
+        if (!is_rgb)
+        {
+            /* We don't support non-rgb visuals for GL. But we don't
+               want to remove them either, so just pass them through
+               with null glX configs */
+
+            pVisualNew[j] = pVisual[i];
+            pVisualNew[j].vid = FakeClientID(0);
+
+            /* Check for the default visual */
+            if (!found_default && pVisual[i].vid == *defaultVisp) {
+                *defaultVisp = pVisualNew[j].vid;
+                found_default = TRUE;
+            }
+
+            /* Save the old VisualID */
+            orig_vid[j] = pVisual[i].vid;
+
+            /* Initialize the glXVisual */
+            _gl_copy_visual_to_context_mode( modes, & NullConfig );
+            modes->visualID = pVisualNew[j].vid;
+
+            j++;
+
+            continue;
+        }
+
+        for (k = 0; k < numNewConfigs; k++) {
+            if (pNewVisualConfigs[k].rgba != is_rgb)
+                continue;
+
+            assert( modes != NULL );
+
+            /* Initialize the new visual */
+            pVisualNew[j] = pVisual[i];
+            pVisualNew[j].vid = FakeClientID(0);
+
+            /* Check for the default visual */
+            if (!found_default && pVisual[i].vid == *defaultVisp) {
+                *defaultVisp = pVisualNew[j].vid;
+                found_default = TRUE;
+            }
+
+            /* Save the old VisualID */
+            orig_vid[j] = pVisual[i].vid;
+
+            /* Initialize the glXVisual */
+            _gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] );
+            modes->visualID = pVisualNew[j].vid;
+
+            /*
+             * If the class is -1, then assume the X visual information
+             * is identical to what GLX needs, and take them from the X
+             * visual.  NOTE: if class != -1, then all other fields MUST
+             * be initialized.
+             */
+            if (modes->visualType == GLX_NONE) {
+                modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class );
+                modes->redBits    = count_bits(pVisual[i].redMask);
+                modes->greenBits  = count_bits(pVisual[i].greenMask);
+                modes->blueBits   = count_bits(pVisual[i].blueMask);
+                modes->alphaBits  = modes->alphaBits;
+                modes->redMask    = pVisual[i].redMask;
+                modes->greenMask  = pVisual[i].greenMask;
+                modes->blueMask   = pVisual[i].blueMask;
+                modes->alphaMask  = modes->alphaMask;
+                modes->rgbBits = (is_rgb)
+                    ? (modes->redBits + modes->greenBits +
+                       modes->blueBits + modes->alphaBits)
+                    : rootDepth;
+            }
+
+            /* Save the device-dependent private for this visual */
+            glXVisualPriv[j] = pNewVisualPriv[k];
+
+            j++;
+            modes = modes->next;
+        }
     }
 
     assert(j <= numNewVisuals);
 
     /* Save the GLX visuals in the screen structure */
     glAquaScreens[screenInfo.numScreens-1].num_vis = numNewVisuals;
-    glAquaScreens[screenInfo.numScreens-1].glx_vis = glXVisualPtr;
     glAquaScreens[screenInfo.numScreens-1].priv = glXVisualPriv;
 
     /* Set up depth's VisualIDs */
     for (i = 0; i < ndepth; i++) {
-	int numVids = 0;
-	VisualID *pVids = NULL;
-	int k, n = 0;
-
-	/* Count the new number of VisualIDs at this depth */
-	for (j = 0; j < pdepth[i].numVids; j++)
-	    for (k = 0; k < numNewVisuals; k++)
-		if (pdepth[i].vids[j] == orig_vid[k])
-		    numVids++;
-
-	/* Allocate a new list of VisualIDs for this depth */
-	pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID));
-
-	/* Initialize the new list of VisualIDs for this depth */
-	for (j = 0; j < pdepth[i].numVids; j++)
-	    for (k = 0; k < numNewVisuals; k++)
-		if (pdepth[i].vids[j] == orig_vid[k])
-		    pVids[n++] = pVisualNew[k].vid;
-
-	/* Update this depth's list of VisualIDs */
-	__glXFree(pdepth[i].vids);
-	pdepth[i].vids = pVids;
-	pdepth[i].numVids = numVids;
+        int numVids = 0;
+        VisualID *pVids = NULL;
+        int k, n = 0;
+
+        /* Count the new number of VisualIDs at this depth */
+        for (j = 0; j < pdepth[i].numVids; j++)
+            for (k = 0; k < numNewVisuals; k++)
+            if (pdepth[i].vids[j] == orig_vid[k])
+                numVids++;
+
+        /* Allocate a new list of VisualIDs for this depth */
+        pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID));
+
+        /* Initialize the new list of VisualIDs for this depth */
+        for (j = 0; j < pdepth[i].numVids; j++)
+            for (k = 0; k < numNewVisuals; k++)
+            if (pdepth[i].vids[j] == orig_vid[k])
+                pVids[n++] = pVisualNew[k].vid;
+
+        /* Update this depth's list of VisualIDs */
+        __glXFree(pdepth[i].vids);
+        pdepth[i].vids = pVids;
+        pdepth[i].numVids = numVids;
     }
 
     /* Update the X server's visuals */
@@ -995,14 +1071,14 @@ glAquaInitVisualConfigs(void)
     int i = 0;
 
     GLAQUA_DEBUG_MSG("glAquaInitVisualConfigs ");
-	
+        
     /* count num configs:
-	2 Z buffer (0, 24 bit)
-	2 AUX buffer (0, 2)
-	2 buffers (single, double)
-	2 stencil (0, 8 bit)
-	2 accum (0, 64 bit)
-	= 32 configs */
+        2 Z buffer (0, 24 bit)
+        2 AUX buffer (0, 2)
+        2 buffers (single, double)
+        2 stencil (0, 8 bit)
+        2 accum (0, 64 bit)
+        = 32 configs */
 
     lclNumConfigs = 2 * 2 * 2 * 2 * 2; /* 32 */
 
@@ -1012,66 +1088,65 @@ glAquaInitVisualConfigs(void)
 
     /* fill in configs */
     if (NULL != lclVisualConfigs) {
-	i = 0; /* current buffer */
-	for (depth = 0; depth < 2; depth++) {
-	    for (aux = 0; aux < 2; aux++) {
-		for (buffers = 0; buffers < 2; buffers++) {
-		    for (stencil = 0; stencil < 2; stencil++) {
-			for (accum = 0; accum < 2; accum++) {
-			    lclVisualConfigs[i].vid = -1;
-			    lclVisualConfigs[i].class = -1;
-			    lclVisualConfigs[i].rgba = TRUE;
-			    lclVisualConfigs[i].redSize = -1;
-			    lclVisualConfigs[i].greenSize = -1;
-			    lclVisualConfigs[i].blueSize = -1;
-			    lclVisualConfigs[i].redMask = -1;
-			    lclVisualConfigs[i].greenMask = -1;
-			    lclVisualConfigs[i].blueMask = -1;
-			    lclVisualConfigs[i].alphaMask = 0;
-			    if (accum) {
-				lclVisualConfigs[i].accumRedSize = 16;
-				lclVisualConfigs[i].accumGreenSize = 16;
-				lclVisualConfigs[i].accumBlueSize = 16;
-				lclVisualConfigs[i].accumAlphaSize = 16;
-			    }
-			    else {
-				lclVisualConfigs[i].accumRedSize = 0;
-				lclVisualConfigs[i].accumGreenSize = 0;
-				lclVisualConfigs[i].accumBlueSize = 0;
-				lclVisualConfigs[i].accumAlphaSize = 0;
-			    }
-			    lclVisualConfigs[i].doubleBuffer = buffers ? TRUE : FALSE;
-			    lclVisualConfigs[i].stereo = FALSE;
-			    lclVisualConfigs[i].bufferSize = -1;
-			    
-			    lclVisualConfigs[i].depthSize = depth? 24 : 0;
-			    lclVisualConfigs[i].stencilSize = stencil ? 8 : 0;
-			    lclVisualConfigs[i].auxBuffers = aux ? 2 : 0;
-			    lclVisualConfigs[i].level = 0;
-			    lclVisualConfigs[i].visualRating = GLX_NONE_EXT;
-			    lclVisualConfigs[i].transparentPixel = 0;
-			    lclVisualConfigs[i].transparentRed = 0;
-			    lclVisualConfigs[i].transparentGreen = 0;
-			    lclVisualConfigs[i].transparentBlue = 0;
-			    lclVisualConfigs[i].transparentAlpha = 0;
-			    lclVisualConfigs[i].transparentIndex = 0;
-			    i++;
-			}
-		    }
-		}
-	    }
-	}
+        i = 0; /* current buffer */
+        for (depth = 0; depth < 2; depth++) {
+            for (aux = 0; aux < 2; aux++) {
+                for (buffers = 0; buffers < 2; buffers++) {
+                    for (stencil = 0; stencil < 2; stencil++) {
+                        for (accum = 0; accum < 2; accum++) {
+                            lclVisualConfigs[i].vid = -1;
+                            lclVisualConfigs[i].class = -1;
+                            lclVisualConfigs[i].rgba = TRUE;
+                            lclVisualConfigs[i].redSize = -1;
+                            lclVisualConfigs[i].greenSize = -1;
+                            lclVisualConfigs[i].blueSize = -1;
+                            lclVisualConfigs[i].redMask = -1;
+                            lclVisualConfigs[i].greenMask = -1;
+                            lclVisualConfigs[i].blueMask = -1;
+                            lclVisualConfigs[i].alphaMask = 0;
+                            if (accum) {
+                                lclVisualConfigs[i].accumRedSize = 16;
+                                lclVisualConfigs[i].accumGreenSize = 16;
+                                lclVisualConfigs[i].accumBlueSize = 16;
+                                lclVisualConfigs[i].accumAlphaSize = 16;
+                            }
+                            else {
+                                lclVisualConfigs[i].accumRedSize = 0;
+                                lclVisualConfigs[i].accumGreenSize = 0;
+                                lclVisualConfigs[i].accumBlueSize = 0;
+                                lclVisualConfigs[i].accumAlphaSize = 0;
+                            }
+                            lclVisualConfigs[i].doubleBuffer = buffers ? TRUE : FALSE;
+                            lclVisualConfigs[i].stereo = FALSE;
+                            lclVisualConfigs[i].bufferSize = -1;
+
+                            lclVisualConfigs[i].depthSize = depth? 24 : 0;
+                            lclVisualConfigs[i].stencilSize = stencil ? 8 : 0;
+                            lclVisualConfigs[i].auxBuffers = aux ? 2 : 0;
+                            lclVisualConfigs[i].level = 0;
+                            lclVisualConfigs[i].visualRating = GLX_NONE_EXT;
+                            lclVisualConfigs[i].transparentPixel = 0;
+                            lclVisualConfigs[i].transparentRed = 0;
+                            lclVisualConfigs[i].transparentGreen = 0;
+                            lclVisualConfigs[i].transparentBlue = 0;
+                            lclVisualConfigs[i].transparentAlpha = 0;
+                            lclVisualConfigs[i].transparentIndex = 0;
+                            i++;
+                        }
+                    }
+                }
+            }
+        }
     }
     if (i != lclNumConfigs)
-	GLAQUA_DEBUG_MSG("glAquaInitVisualConfigs failed to alloc visual configs");
+        GLAQUA_DEBUG_MSG("glAquaInitVisualConfigs failed to alloc visual configs");
 
     GlxSetVisualConfigs(lclNumConfigs, lclVisualConfigs, lclVisualPrivates);
 }
 
 
-// Copied from Mesa
 static void glAquaSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
-				   void **privates)
+                                   void **privates)
 {
     GLAQUA_DEBUG_MSG("glAquaSetVisualConfigs\n");
 
@@ -1080,122 +1155,114 @@ static void glAquaSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
     visualPrivates = privates;
 }
 
-// Copied from Mesa
 static Bool glAquaInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
-			      int *nvisualp, int *ndepthp,
-			      int *rootDepthp, VisualID *defaultVisp,
-			      unsigned long sizes, int bitsPerRGB)
+                              int *nvisualp, int *ndepthp,
+                              int *rootDepthp, VisualID *defaultVisp,
+                              unsigned long sizes, int bitsPerRGB)
 {
     GLAQUA_DEBUG_MSG("glAquaInitVisuals\n");
     
     if (0 == numConfigs) /* if no configs */
-    	glAquaInitVisualConfigs(); /* ensure the visula configs are setup */
+        glAquaInitVisualConfigs(); /* ensure the visula configs are setup */
 
     /*
      * Setup the visuals supported by this particular screen.
      */
     return init_visuals(nvisualp, visualp, defaultVisp,
-			*ndepthp, *depthp, *rootDepthp);
+                        *ndepthp, *depthp, *rootDepthp);
 }
 
+
 static void fixup_visuals(int screen)
 {
     ScreenPtr pScreen = screenInfo.screens[screen];
     glAquaScreenRec *pScr = &glAquaScreens[screen];
-    __GLXvisualConfig *pGLXVis  = pScr->glx_vis;
-    VisualPtr pVis;
-    int i, j;
+    int j;
+    __GLcontextModes *modes;
 
     GLAQUA_DEBUG_MSG("fixup_visuals\n");
 
-    for (i = 0; i < pScr->num_vis; i++, pGLXVis++) {
-	pVis = pScreen->visuals;
-
-	/* Find a visual that matches the GLX visual's class and size */
-	for (j = 0; j < pScreen->numVisuals; j++, pVis++) {
-	    if (pVis->class == pGLXVis->class &&
-		pVis->nplanes == pGLXVis->bufferSize) {
-
-		/* Fixup the masks */
-		pGLXVis->redMask   = pVis->redMask;
-		pGLXVis->greenMask = pVis->greenMask;
-		pGLXVis->blueMask  = pVis->blueMask;
-
-		/* Recalc the sizes */
-		pGLXVis->redSize   = count_bits(pGLXVis->redMask);
-		pGLXVis->greenSize = count_bits(pGLXVis->greenMask);
-		pGLXVis->blueSize  = count_bits(pGLXVis->blueMask);
-	    }
-	}
+    for ( modes = pScr->modes ; modes != NULL ; modes = modes->next ) {
+        const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
+        const int nplanes = (modes->rgbBits - modes->alphaBits);
+        const VisualPtr pVis = pScreen->visuals;
+
+        /* Find a visual that matches the GLX visual's class and size */
+        for (j = 0; j < pScreen->numVisuals; j++) {
+            if (pVis[j].class == vis_class &&
+            pVis[j].nplanes == nplanes) {
+
+            /* Fixup the masks */
+            modes->redMask   = pVis[j].redMask;
+            modes->greenMask = pVis[j].greenMask;
+            modes->blueMask  = pVis[j].blueMask;
+
+            /* Recalc the sizes */
+            modes->redBits   = count_bits(modes->redMask);
+            modes->greenBits = count_bits(modes->greenMask);
+            modes->blueBits  = count_bits(modes->blueMask);
+            }
+        }
     }
 }
 
 static void init_screen_visuals(int screen)
 {
     ScreenPtr pScreen = screenInfo.screens[screen];
-    __GLXvisualConfig *pGLXVis = glAquaScreens[screen].glx_vis;
-    // XMesaVisual *pXMesaVisual;
-    VisualPtr pVis;
+    __GLcontextModes *modes;
     int *used;
     int i, j;
 
     GLAQUA_DEBUG_MSG("init_screen_visuals\n");
 
-    /* Alloc space for the list of XMesa visuals */
-    // pXMesaVisual = (XMesaVisual *)__glXMalloc(MESAScreens[screen].num_vis *
-    //					      sizeof(XMesaVisual));
-    // __glXMemset(pXMesaVisual, 0,
-    //		MESAScreens[screen].num_vis * sizeof(XMesaVisual));
-
+    /* FIXME: Change 'used' to be a array of bits (rather than of ints),
+     * FIXME: create a stack array of 8 or 16 bytes.  If 'numVisuals' is less
+     * FIXME: than 64 or 128 the stack array can be used instead of calling
+     * FIXME: __glXMalloc / __glXFree.  If nothing else, convert 'used' to
+     * FIXME: array of bytes instead of ints!
+     */
     used = (int *)__glXMalloc(pScreen->numVisuals * sizeof(int));
     __glXMemset(used, 0, pScreen->numVisuals * sizeof(int));
 
-    for (i = 0; i < glAquaScreens[screen].num_vis; i++, pGLXVis++) {
-	pVis = pScreen->visuals;
-	for (j = 0; j < pScreen->numVisuals; j++, pVis++) {
-
-	    if (pVis->class == pGLXVis->class &&
-		pVis->nplanes == pGLXVis->bufferSize &&
-		!used[j]) {
-
-		if (pVis->redMask   == pGLXVis->redMask &&
-		    pVis->greenMask == pGLXVis->greenMask &&
-		    pVis->blueMask  == pGLXVis->blueMask) {
-
-		    /* Create the XMesa visual */
-		    /*
-		    pXMesaVisual[i] =
-                         XMesaCreateVisual(pScreen,
-					   pVis,
-					   pGLXVis->rgba,
-					   (pGLXVis->alphaSize > 0),
-					   pGLXVis->doubleBuffer,
-					   pGLXVis->stereo,
-					   GL_TRUE, // ximage_flag
-					   pGLXVis->depthSize,
-					   pGLXVis->stencilSize,
-					   pGLXVis->accumRedSize,
-					   pGLXVis->accumGreenSize,
-					   pGLXVis->accumBlueSize,
-					   pGLXVis->accumAlphaSize,
-                                           0,  // numSamples
-					   pGLXVis->level,
-                                           pGLXVis->visualRating );
-		    */
-		    /* Set the VisualID */
-		    pGLXVis->vid = pVis->vid;
-
-		    /* Mark this visual used */
-		    used[j] = 1;
-		    break;
-		}
-	    }
-	}
+    i = 0;
+    for ( modes = glAquaScreens[screen].modes 
+          ; modes != NULL
+          ; modes = modes->next ) {
+        const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
+        const int nplanes = (modes->rgbBits - modes->alphaBits);
+        const VisualPtr pVis = pScreen->visuals;
+
+        for (j = 0; j < pScreen->numVisuals; j++) {
+            if (pVis[j].class     == vis_class &&
+                pVis[j].nplanes   == nplanes &&
+                pVis[j].redMask   == modes->redMask &&
+                pVis[j].greenMask == modes->greenMask &&
+                pVis[j].blueMask  == modes->blueMask &&
+                !used[j]) {
+
+                    /* Set the VisualID */
+                    modes->visualID = pVis[j].vid;
+
+                    /* Mark this visual used */
+                    used[j] = 1;
+                    break;
+            }
+        }
+        if ( j == pScreen->numVisuals ) {
+            ErrorF("No matching visual for __GLcontextMode with "
+                   "visual class = %d (%d), nplanes = %u\n",
+                   vis_class, 
+                   (int)modes->visualType,
+                   (unsigned int)(modes->rgbBits - modes->alphaBits) );
+        }
+        else if ( modes->visualID == -1 ) {
+            FatalError( "Matching visual found, but visualID still -1!\n" );
+        }
+
+        i++;
     }
 
     __glXFree(used);
-
-    // glAquaScreens[screen].xm_vis = pXMesaVisual;
 }
 
 static Bool glAquaScreenProbe(int screen)
@@ -1208,10 +1275,10 @@ static Bool glAquaScreenProbe(int screen)
     /*
      * Set up the current screen's visuals.
      */
-    __glDDXScreenInfo.pGlxVisual = glAquaScreens[screen].glx_vis;
+    __glDDXScreenInfo.modes = glAquaScreens[screen].modes;
     __glDDXScreenInfo.pVisualPriv = glAquaScreens[screen].priv;
     __glDDXScreenInfo.numVisuals =
-	__glDDXScreenInfo.numUsableVisuals = glAquaScreens[screen].num_vis;
+        __glDDXScreenInfo.numUsableVisuals = glAquaScreens[screen].num_vis;
 
     /*
      * Set the current screen's createContext routine.  This could be
@@ -1231,7 +1298,9 @@ static Bool glAquaScreenProbe(int screen)
      */
     init_screen_visuals(screen);
 
-    // Wrap RealizeWindow and UnrealizeWindow on this screen
+    /*
+     * Wrap RealizeWindow and UnrealizeWindow on this screen
+     */
     pScreen = screenInfo.screens[screen];
     screenPriv = &glAquaScreens[screen];
     screenPriv->RealizeWindow = pScreen->RealizeWindow;
@@ -1253,9 +1322,9 @@ static GLboolean glAquaSwapBuffers(__GLXdrawablePrivate *glxPriv)
 
     if (gc != NULL && gc->ctx != NULL)
     {
-	gl_err = CGLFlushDrawable(gc->ctx);
-	if (gl_err != 0)
-	    ErrorF("CGLFlushDrawable error: %s\n", CGLErrorString(gl_err));
+        gl_err = CGLFlushDrawable(gc->ctx);
+        if (gl_err != 0)
+            ErrorF("CGLFlushDrawable error: %s\n", CGLErrorString(gl_err));
     }
 
     return GL_TRUE;
@@ -1308,24 +1377,24 @@ GLint __glEvalComputeK(GLenum target)
     case GL_MAP2_VERTEX_4:
     case GL_MAP2_COLOR_4:
     case GL_MAP2_TEXTURE_COORD_4:
-	return 4;
+        return 4;
     case GL_MAP1_VERTEX_3:
     case GL_MAP1_TEXTURE_COORD_3:
     case GL_MAP1_NORMAL:
     case GL_MAP2_VERTEX_3:
     case GL_MAP2_TEXTURE_COORD_3:
     case GL_MAP2_NORMAL:
-	return 3;
+        return 3;
     case GL_MAP1_TEXTURE_COORD_2:
     case GL_MAP2_TEXTURE_COORD_2:
-	return 2;
+        return 2;
     case GL_MAP1_TEXTURE_COORD_1:
     case GL_MAP2_TEXTURE_COORD_1:
     case GL_MAP1_INDEX:
     case GL_MAP2_INDEX:
-	return 1;
+        return 1;
     default:
-	return 0;
+        return 0;
     }
 }
 
@@ -1334,8 +1403,8 @@ GLuint __glFloorLog2(GLuint val)
     int c = 0;
 
     while (val > 1) {
-	c++;
-	val >>= 1;
+        c++;
+        val >>= 1;
     }
     return c;
 }
diff --git a/GL/glx/g_disptab.c b/GL/glx/g_disptab.c
index 12d1abe56..8c8dc2ccc 100644
--- a/GL/glx/g_disptab.c
+++ b/GL/glx/g_disptab.c
@@ -54,18 +54,18 @@ __GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
 	__glXQueryExtensionsString,
 	__glXQueryServerString,
 	__glXClientInfo,
-	__glXNoSuchSingleOpcode, /* glXGetFBConfigs */
-	__glXNoSuchSingleOpcode, /* glXCreatePixmap */
-	__glXNoSuchSingleOpcode, /* glXDestroyPixmap */
-	__glXNoSuchSingleOpcode, /* glXCreateNewContext */
+	__glXGetFBConfigs,
+	__glXCreatePixmap,
+	__glXDestroyGLXPixmap, /* glXDestroyPixmap */
+	__glXCreateNewContext,
 	__glXNoSuchSingleOpcode, /* glXQueryContext */
 	__glXMakeContextCurrent,
-	__glXNoSuchSingleOpcode,
-	__glXNoSuchSingleOpcode,
-	__glXNoSuchSingleOpcode,
-	__glXNoSuchSingleOpcode,
-	__glXNoSuchSingleOpcode,
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXCreatePbuffer */
+	__glXNoSuchSingleOpcode, /* glXDestroyPbuffer */
+	__glXNoSuchSingleOpcode, /* glXGetDrawableAttributes */
+	__glXNoSuchSingleOpcode, /* glXChangeDrawableAttributes */
+	__glXNoSuchSingleOpcode, /* glXCreateWindow */
+	__glXNoSuchSingleOpcode, /* glXDestroyWindow */
 	__glXNoSuchSingleOpcode,
 	__glXNoSuchSingleOpcode,
 	__glXNoSuchSingleOpcode,
@@ -455,18 +455,18 @@ __GLXdispatchSingleProcPtr __glXSwapSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
 	__glXSwapQueryExtensionsString,
 	__glXSwapQueryServerString,
 	__glXSwapClientInfo,
-	__glXNoSuchSingleOpcode, /* glXGetFBConfigs */
-	__glXNoSuchSingleOpcode, /* glXCreatePixmap */
-	__glXNoSuchSingleOpcode, /* glXDestroyPixmap */
-	__glXNoSuchSingleOpcode, /* glXCreateNewContext */
+	__glXSwapGetFBConfigs,
+	__glXSwapCreatePixmap,
+	__glXSwapDestroyGLXPixmap, /* glXDestroyPixmap */
+	__glXSwapCreateNewContext,
 	__glXNoSuchSingleOpcode, /* glXQueryContext */
 	__glXSwapMakeContextCurrent,
-	__glXNoSuchSingleOpcode,
-	__glXNoSuchSingleOpcode,
-	__glXNoSuchSingleOpcode,
-	__glXNoSuchSingleOpcode,
-	__glXNoSuchSingleOpcode,
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXCreatePbuffer */
+	__glXNoSuchSingleOpcode, /* glXDestroyPbuffer */
+	__glXNoSuchSingleOpcode, /* glXGetDrawableAttributes */
+	__glXNoSuchSingleOpcode, /* glXChangeDrawableAttributes */
+	__glXNoSuchSingleOpcode, /* glXCreateWindow */
+	__glXNoSuchSingleOpcode, /* glXDestroyWindow */
 	__glXNoSuchSingleOpcode,
 	__glXNoSuchSingleOpcode,
 	__glXNoSuchSingleOpcode,
diff --git a/GL/glx/g_disptab.h b/GL/glx/g_disptab.h
index 25c233ac7..566650bf7 100644
--- a/GL/glx/g_disptab.h
+++ b/GL/glx/g_disptab.h
@@ -52,6 +52,9 @@ extern int __glXQueryExtensionsString(__GLXclientState*, GLbyte*);
 extern int __glXQueryServerString(__GLXclientState*, GLbyte*);
 extern int __glXClientInfo(__GLXclientState*, GLbyte*);
 extern int __glXMakeContextCurrent(__GLXclientState*, GLbyte*);
+extern int __glXGetFBConfigs(__GLXclientState*, GLbyte*);
+extern int __glXCreateNewContext(__GLXclientState*, GLbyte*);
+extern int __glXCreatePixmap(__GLXclientState*, GLbyte*);
 
 extern int __glXDisp_NewList(__GLXclientState*, GLbyte*);
 extern int __glXDisp_EndList(__GLXclientState*, GLbyte*);
@@ -349,6 +352,9 @@ extern int __glXSwapQueryExtensionsString(__GLXclientState*, GLbyte*);
 extern int __glXSwapQueryServerString(__GLXclientState*, GLbyte*);
 extern int __glXSwapClientInfo(__GLXclientState*, GLbyte*);
 extern int __glXSwapMakeContextCurrent(__GLXclientState*, GLbyte*);
+extern int __glXSwapGetFBConfigs(__GLXclientState*, GLbyte*);
+extern int __glXSwapCreateNewContext(__GLXclientState*, GLbyte*);
+extern int __glXSwapCreatePixmap(__GLXclientState*, GLbyte*);
 
 extern int __glXDispSwap_NewList(__GLXclientState*, GLbyte*);
 extern int __glXDispSwap_EndList(__GLXclientState*, GLbyte*);
diff --git a/GL/glx/g_render.c b/GL/glx/g_render.c
index a599423cc..f014e3be5 100644
--- a/GL/glx/g_render.c
+++ b/GL/glx/g_render.c
@@ -2273,7 +2273,6 @@ void __glXDisp_WindowPos3fARB(GLbyte *pc)
 		*(GLfloat *)(pc + 8)
 	);
 }
-
 #endif /* !MISSING_GL_EXTS */
 
 void __glXDisp_SampleCoverageARB(GLbyte *pc)
diff --git a/GL/glx/g_renderswap.c b/GL/glx/g_renderswap.c
index 2a8d0c02f..5c2ed9f58 100644
--- a/GL/glx/g_renderswap.c
+++ b/GL/glx/g_renderswap.c
@@ -3368,7 +3368,6 @@ void __glXDispSwap_WindowPos3fARB(GLbyte *pc)
 		*(GLfloat *)(pc + 8)
 	);
 }
-
 #endif /* !MISSING_GL_EXTS */
 
 void __glXDispSwap_SampleCoverageARB(GLbyte *pc)
diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c
index df4154991..9908e8a2d 100644
--- a/GL/glx/glxcmds.c
+++ b/GL/glx/glxcmds.c
@@ -47,6 +47,7 @@
 #include "glxutil.h"
 #include "glxext.h"
 #include "GL/glx_ansic.h"
+#include "glcontextmodes.h"
 
 /************************************************************************/
 
@@ -68,29 +69,32 @@ static __GLimports imports = {
     NULL
 };
 
-static int DoMakeCurrent( __GLXclientState *cl, GLXDrawable drawId,
- GLXDrawable readId, GLXContextID contextId, GLXContextTag tag );
+static int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
 
 /************************************************************************/
 
-/*
-** Create a GL context with the given properties.
-*/
-int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
+/**
+ * Create a GL context with the given properties.  This routine is used
+ * to implement \c glXCreateContext, \c glXCreateNewContext, and
+ * \c glXCreateContextWithConfigSGIX.  This works becuase of the hack way
+ * that GLXFBConfigs are implemented.  Basically, the FBConfigID is the
+ * same as the VisualID.
+ */
+
+int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
+		    GLXContextID shareList, VisualID visual,
+		    GLuint screen, GLboolean isDirect)
 {
     ClientPtr client = cl->client;
-    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
     VisualPtr pVisual;
     ScreenPtr pScreen;
     __GLXcontext *glxc, *shareglxc;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     __GLXscreenInfo *pGlxScreen;
     __GLinterface *shareGC;
-    GLXContextID gcId = req->context;
-    GLXContextID shareList = req->shareList;
-    VisualID visual = req->visual;
-    GLuint screen = req->screen;
-    GLboolean isDirect = req->isDirect;
     GLint i;
     
     /*
@@ -123,13 +127,9 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
     ** subset of Visuals that are supported by this implementation of the
     ** OpenGL.
     */
-    pGlxVisual = pGlxScreen->pGlxVisual;
-    for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
-	if (pGlxVisual->vid == visual) {
-	    break;
-	}
-    }
-    if (i == pGlxScreen->numVisuals) {
+
+    modes = _gl_context_modes_find_visual( pGlxScreen->modes, visual );
+    if (modes == NULL) {
 	/*
 	** Visual not support on this screen by this OpenGL implementation.
 	*/
@@ -192,22 +192,15 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
     glxc->pScreen = pScreen;
     glxc->pGlxScreen = pGlxScreen;
     glxc->pVisual = pVisual;
-    glxc->pGlxVisual = pGlxVisual;
+    glxc->modes = modes;
 
     if (!isDirect) {
-	__GLcontextModes *modes;
-	/*
-	** first build __GLcontextModes from __GLXvisualConfig
-	*/
-	modes = (__GLcontextModes *) __glXMalloc(sizeof(__GLcontextModes));
-	glxc->modes = modes;
-	__glXFormatGLModes(modes, pGlxVisual);
 
 	/*
 	** Allocate a GL context
 	*/
 	imports.other = (void *)glxc;
-	glxc->gc = (*pGlxScreen->createContext)(&imports, modes, shareGC);
+	glxc->gc = (*pGlxScreen->createContext)(&imports, glxc->modes, shareGC);
 	if (!glxc->gc) {
 	    __glXFree(glxc);
 	    client->errorValue = gcId;
@@ -245,6 +238,31 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
     return Success;
 }
 
+
+int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
+    return DoCreateContext( cl, req->context, req->shareList, req->visual,
+			    req->screen, req->isDirect );
+}
+
+
+int __glXCreateNewContext(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
+    return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
+			    req->screen, req->isDirect );
+}
+
+
+int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateContextWithConfigSGIXReq *req = 
+	(xGLXCreateContextWithConfigSGIXReq *) pc;
+    return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
+			    req->screen, req->isDirect );
+}
+
 /*
 ** Destroy a GL context as an X resource.
 */
@@ -370,24 +388,24 @@ int __glXMakeCurrent(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
 
-   return DoMakeCurrent( cl, req->drawable, req->drawable,
-			 req->context, req->oldContextTag );
+    return DoMakeCurrent( cl, req->drawable, req->drawable,
+			  req->context, req->oldContextTag );
 }
 
 int __glXMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
 
-   return DoMakeCurrent( cl, req->drawable, req->readdrawable,
-			 req->context, req->oldContextTag );
+    return DoMakeCurrent( cl, req->drawable, req->readdrawable,
+			  req->context, req->oldContextTag );
 }
 
 int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
 
-   return DoMakeCurrent( cl, req->drawable, req->readable,
-			 req->context, req->oldContextTag );
+    return DoMakeCurrent( cl, req->drawable, req->readable,
+			  req->context, req->oldContextTag );
 }
 
 
@@ -449,7 +467,7 @@ static int GetDrawableOrPixmap( __GLXcontext *glxc, GLXDrawable drawId,
 	    ** Check if pixmap and context are similar.
 	    */
 	    if (drawPixmap->pScreen != glxc->pScreen ||
-		drawPixmap->pGlxVisual != glxc->pGlxVisual) {
+		drawPixmap->modes->visualID != glxc->modes->visualID) {
 		client->errorValue = drawId;
 		return BadMatch;
 	    }
@@ -471,9 +489,9 @@ static int GetDrawableOrPixmap( __GLXcontext *glxc, GLXDrawable drawId,
 }
 
 
-static int DoMakeCurrent( __GLXclientState *cl,
-			  GLXDrawable drawId, GLXDrawable readId,
-			  GLXContextID contextId, GLXContextTag tag )
+int DoMakeCurrent( __GLXclientState *cl,
+		   GLXDrawable drawId, GLXDrawable readId,
+		   GLXContextID contextId, GLXContextTag tag )
 {
     ClientPtr client = cl->client;
     DrawablePtr pDraw;
@@ -639,7 +657,8 @@ static int DoMakeCurrent( __GLXclientState *cl,
 
     if (prevglxc) {
 	if (prevglxc->drawPixmap) {
-	    if (prevglxc->drawPixmap != prevglxc->readPixmap) {
+	    if (prevglxc->readPixmap &&
+		prevglxc->drawPixmap != prevglxc->readPixmap) {
 		/*
 		** The previous drawable was a glx pixmap, release it.
 		*/
@@ -881,18 +900,19 @@ int __glXCopyContext(__GLXclientState *cl, GLbyte *pc)
     return Success;
 }
 
-int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
+
+int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
+		       GLboolean do_swap)
 {
     ClientPtr client = cl->client;
-    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
     xGLXGetVisualConfigsReply reply;
     __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     CARD32 buf[__GLX_TOTAL_CONFIG];
-    unsigned int screen;
-    int i, p;
+    int p;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
-    screen = req->screen;
     if (screen >= screenInfo.numScreens) {
 	/* The client library must send a valid screen number. */
 	client->errorValue = screen;
@@ -907,77 +927,206 @@ int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
     reply.type = X_Reply;
     reply.sequenceNumber = client->sequence;
 
+    if ( do_swap ) {
+	__GLX_SWAP_SHORT(&reply.sequenceNumber);
+	__GLX_SWAP_INT(&reply.length);
+	__GLX_SWAP_INT(&reply.numVisuals);
+	__GLX_SWAP_INT(&reply.numProps);
+    }
+
     WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);
 
-    for (i=0; i < pGlxScreen->numVisuals; i++) {
-	pGlxVisual = &pGlxScreen->pGlxVisual[i];
-	if (pGlxVisual->vid == 0) {
+    for ( modes = pGlxScreen->modes ; modes != NULL ; modes = modes->next ) {
+	if (modes->visualID == 0) {
 	    /* not a usable visual */
 	    continue;
 	}
 	p = 0;
-	buf[p++] = pGlxVisual->vid;
-	buf[p++] = pGlxVisual->class;
-	buf[p++] = pGlxVisual->rgba;
-
-	buf[p++] = pGlxVisual->redSize;
-	buf[p++] = pGlxVisual->greenSize;
-	buf[p++] = pGlxVisual->blueSize;
-	buf[p++] = pGlxVisual->alphaSize;
-	buf[p++] = pGlxVisual->accumRedSize;
-	buf[p++] = pGlxVisual->accumGreenSize;
-	buf[p++] = pGlxVisual->accumBlueSize;
-	buf[p++] = pGlxVisual->accumAlphaSize;
-
-	buf[p++] = pGlxVisual->doubleBuffer;
-	buf[p++] = pGlxVisual->stereo;
-
-	buf[p++] = pGlxVisual->bufferSize;
-	buf[p++] = pGlxVisual->depthSize;
-	buf[p++] = pGlxVisual->stencilSize;
-	buf[p++] = pGlxVisual->auxBuffers;
-	buf[p++] = pGlxVisual->level;
+	buf[p++] = modes->visualID;
+	buf[p++] = _gl_convert_to_x_visual_type( modes->visualType );
+	buf[p++] = modes->rgbMode;
+
+	buf[p++] = modes->redBits;
+	buf[p++] = modes->greenBits;
+	buf[p++] = modes->blueBits;
+	buf[p++] = modes->alphaBits;
+	buf[p++] = modes->accumRedBits;
+	buf[p++] = modes->accumGreenBits;
+	buf[p++] = modes->accumBlueBits;
+	buf[p++] = modes->accumAlphaBits;
+
+	buf[p++] = modes->doubleBufferMode;
+	buf[p++] = modes->stereoMode;
+
+	buf[p++] = modes->rgbBits;
+	buf[p++] = modes->depthBits;
+	buf[p++] = modes->stencilBits;
+	buf[p++] = modes->numAuxBuffers;
+	buf[p++] = modes->level;
 	/* 
 	** Add token/value pairs for extensions.
 	*/
 	buf[p++] = GLX_VISUAL_CAVEAT_EXT;
-	buf[p++] = pGlxVisual->visualRating;
-	buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
-	buf[p++] = pGlxVisual->transparentPixel;
-	buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentRed;
-	buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentGreen;
-	buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentBlue;
-	buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentAlpha;
-	buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentIndex;
-
+	buf[p++] = modes->visualRating;
+	buf[p++] = GLX_TRANSPARENT_TYPE;
+	buf[p++] = modes->transparentPixel;
+	buf[p++] = GLX_TRANSPARENT_RED_VALUE;
+	buf[p++] = modes->transparentRed;
+	buf[p++] = GLX_TRANSPARENT_GREEN_VALUE;
+	buf[p++] = modes->transparentGreen;
+	buf[p++] = GLX_TRANSPARENT_BLUE_VALUE;
+	buf[p++] = modes->transparentBlue;
+	buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE;
+	buf[p++] = modes->transparentAlpha;
+	buf[p++] = GLX_TRANSPARENT_INDEX_VALUE;
+	buf[p++] = modes->transparentIndex;
+
+	if ( do_swap ) {
+	    __GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);
+	}
 	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, 
 		(char *)buf);
     }
     return Success;
 }
 
+int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
+    return DoGetVisualConfigs( cl, req->screen, GL_FALSE );
+}
+
+
+
+#define __GLX_TOTAL_FBCONFIG_ATTRIBS (28)
+
+/**
+ * Send the set of GLXFBConfigs to the client.  There is not currently
+ * and interface into the driver on the server-side to get GLXFBConfigs,
+ * so we "invent" some based on the \c __GLXvisualConfig structures that
+ * the driver does supply.
+ * 
+ * The reply format for both \c glXGetFBConfigs and \c glXGetFBConfigsSGIX
+ * is the same, so this routine pulls double duty.
+ */
+
+int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap)
+{
+    ClientPtr client = cl->client;
+    xGLXGetFBConfigsReply reply;
+    __GLXscreenInfo *pGlxScreen;
+    CARD32 buf[__GLX_TOTAL_FBCONFIG_ATTRIBS * 2];
+    int p;
+    __GLcontextModes *modes;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+
+    if (screen >= screenInfo.numScreens) {
+	/* The client library must send a valid screen number. */
+	client->errorValue = screen;
+	return BadValue;
+    }
+    pGlxScreen = &__glXActiveScreens[screen];
+
+    reply.numFBConfigs = pGlxScreen->numUsableVisuals;
+    reply.numAttribs = __GLX_TOTAL_FBCONFIG_ATTRIBS;
+    reply.length = (reply.numAttribs * reply.numFBConfigs);
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+
+    if ( do_swap ) {
+	__GLX_SWAP_SHORT(&reply.sequenceNumber);
+	__GLX_SWAP_INT(&reply.length);
+	__GLX_SWAP_INT(&reply.numFBConfigs);
+	__GLX_SWAP_INT(&reply.numAttribs);
+    }
+
+    WriteToClient(client, sz_xGLXGetFBConfigsReply, (char *)&reply);
+
+    for ( modes = pGlxScreen->modes ; modes != NULL ; modes = modes->next ) {
+	if (modes->visualID == 0) {
+	    /* not a usable visual */
+	    continue;
+	}
+	p = 0;
+
+#define WRITE_PAIR(tag,value) \
+    do { buf[p++] = tag ; buf[p++] = value ; } while( 0 )
+
+	WRITE_PAIR( GLX_VISUAL_ID,        modes->visualID );
+	WRITE_PAIR( GLX_FBCONFIG_ID,      modes->visualID );
+	WRITE_PAIR( GLX_X_RENDERABLE,     GL_TRUE );
+
+	WRITE_PAIR( GLX_RGBA,             modes->rgbMode );
+	WRITE_PAIR( GLX_DOUBLEBUFFER,     modes->doubleBufferMode );
+	WRITE_PAIR( GLX_STEREO,           modes->stereoMode );
+
+	WRITE_PAIR( GLX_BUFFER_SIZE,      modes->rgbBits );
+	WRITE_PAIR( GLX_LEVEL,            modes->level );
+	WRITE_PAIR( GLX_AUX_BUFFERS,      modes->numAuxBuffers );
+	WRITE_PAIR( GLX_RED_SIZE,         modes->redBits );
+	WRITE_PAIR( GLX_GREEN_SIZE,       modes->greenBits );
+	WRITE_PAIR( GLX_BLUE_SIZE,        modes->blueBits );
+	WRITE_PAIR( GLX_ALPHA_SIZE,       modes->alphaBits );
+	WRITE_PAIR( GLX_ACCUM_RED_SIZE,   modes->accumRedBits );
+	WRITE_PAIR( GLX_ACCUM_GREEN_SIZE, modes->accumGreenBits );
+	WRITE_PAIR( GLX_ACCUM_BLUE_SIZE,  modes->accumBlueBits );
+	WRITE_PAIR( GLX_ACCUM_ALPHA_SIZE, modes->accumAlphaBits );
+	WRITE_PAIR( GLX_DEPTH_SIZE,       modes->depthBits );
+	WRITE_PAIR( GLX_STENCIL_SIZE,     modes->stencilBits );
+
+	WRITE_PAIR( GLX_X_VISUAL_TYPE,    modes->visualType );
+
+	/* 
+	** Add token/value pairs for extensions.
+	*/
+	WRITE_PAIR( GLX_CONFIG_CAVEAT, modes->visualRating );
+	WRITE_PAIR( GLX_TRANSPARENT_TYPE, modes->transparentPixel );
+	WRITE_PAIR( GLX_TRANSPARENT_RED_VALUE, modes->transparentRed );
+	WRITE_PAIR( GLX_TRANSPARENT_GREEN_VALUE, modes->transparentGreen );
+	WRITE_PAIR( GLX_TRANSPARENT_BLUE_VALUE, modes->transparentBlue );
+	WRITE_PAIR( GLX_TRANSPARENT_ALPHA_VALUE, modes->transparentAlpha );
+	WRITE_PAIR( GLX_TRANSPARENT_INDEX_VALUE, modes->transparentIndex );
+	WRITE_PAIR( GLX_SWAP_METHOD_OML, modes->swapMethod );
+
+	if ( do_swap ) {
+	    __GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_FBCONFIG_ATTRIBS * 2);
+	}
+	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_FBCONFIG_ATTRIBS * 2,
+		      (char *)buf);
+    }
+    return Success;
+}
+
+
+int __glXGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
+    return DoGetFBConfigs( cl, req->screen, GL_FALSE );
+}
+
+
+int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
+    return DoGetFBConfigs( cl, req->screen, GL_FALSE );
+}
+
+
 /*
 ** Create a GLX Pixmap from an X Pixmap.
 */
-int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
+int DoCreateGLXPixmap(__GLXclientState *cl, VisualID visual,
+		      GLuint screenNum, XID pixmapId, XID glxpixmapId)
 {
     ClientPtr client = cl->client;
-    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
-    VisualID visual = req->visual;
-    GLuint screenNum = req->screen;
-    XID pixmapId = req->pixmap;
-    XID glxpixmapId = req->glxpixmap;
     DrawablePtr pDraw;
     ScreenPtr pScreen;
     VisualPtr pVisual;
     __GLXpixmap *pGlxPixmap;
     __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     int i;
 
     pDraw = (DrawablePtr) LookupDrawable(pixmapId, client);
@@ -1018,13 +1167,8 @@ int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     ** Get configuration of the visual.
     */
     pGlxScreen = &__glXActiveScreens[screenNum];
-    pGlxVisual = pGlxScreen->pGlxVisual;
-    for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
-	if (pGlxVisual->vid == visual) {
-	    break;
-	}
-    }
-    if (i == pGlxScreen->numVisuals) {
+    modes = _gl_context_modes_find_visual( pGlxScreen->modes, visual );
+    if (modes == NULL) {
 	/*
 	** Visual not support on this screen by this OpenGL implementation.
 	*/
@@ -1041,11 +1185,12 @@ int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     }
     pGlxPixmap->pDraw = pDraw;
     pGlxPixmap->pGlxScreen = pGlxScreen;
-    pGlxPixmap->pGlxVisual = pGlxVisual;
     pGlxPixmap->pScreen = pScreen;
     pGlxPixmap->idExists = True;
     pGlxPixmap->refcnt = 0;
 
+    pGlxPixmap->modes = modes;
+
     /*
     ** Bump the ref count on the X pixmap so it won't disappear.
     */
@@ -1054,6 +1199,34 @@ int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     return Success;
 }
 
+int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
+    return DoCreateGLXPixmap( cl, req->visual, req->screen,
+			      req->pixmap, req->glxpixmap );
+}
+
+int __glXCreatePixmap(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
+    return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
+			      req->pixmap, req->glxpixmap );
+}
+
+int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateGLXPixmapWithConfigSGIXReq *req = 
+	(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
+    return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
+			      req->pixmap, req->glxpixmap );
+}
+
+
+/**
+ * Destroy a GLX pixmap.  This function is used for both
+ * \c glXDestroyGLXPixmap and \c glXDestroyPixmap.
+ */
+
 int __glXDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
 {
     ClientPtr client = cl->client;
@@ -1592,6 +1765,12 @@ int __glXVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
 	return __glXQueryContextInfoEXT(cl, pc);
       case X_GLXvop_MakeCurrentReadSGI:
 	return __glXMakeCurrentReadSGI(cl, pc);
+      case X_GLXvop_GetFBConfigsSGIX:
+	return __glXGetFBConfigsSGIX(cl, pc);
+      case X_GLXvop_CreateContextWithConfigSGIX:
+	return __glXCreateContextWithConfigSGIX(cl, pc);
+      case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
+	return __glXCreateGLXPixmapWithConfigSGIX(cl, pc);
       default:
 	break;
     }
diff --git a/GL/glx/glxcmdsswap.c b/GL/glx/glxcmdsswap.c
index 8c0f1f091..450b8bb9b 100644
--- a/GL/glx/glxcmdsswap.c
+++ b/GL/glx/glxcmdsswap.c
@@ -47,6 +47,11 @@
 #include "glxext.h"
 #include "GL/glx_ansic.h"
 
+static int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXSwapCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
+
 /************************************************************************/
 
 /*
@@ -67,7 +72,41 @@ int __glXSwapCreateContext(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->screen);
     __GLX_SWAP_INT(&req->shareList);
 
-    return __glXCreateContext(cl, pc);
+    return DoCreateContext( cl, req->context, req->shareList, req->visual,
+			    req->screen, req->isDirect );
+}
+
+int __glXSwapCreateNewContext(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_SHORT(&req->length);
+    __GLX_SWAP_INT(&req->context);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->renderType);
+    __GLX_SWAP_INT(&req->shareList);
+
+    return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
+			    req->screen, req->isDirect );
+}
+
+int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateContextWithConfigSGIXReq *req =
+	(xGLXCreateContextWithConfigSGIXReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_SHORT(&req->length);
+    __GLX_SWAP_INT(&req->context);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->renderType);
+    __GLX_SWAP_INT(&req->shareList);
+
+    return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
+			    req->screen, req->isDirect );
 }
 
 int __glXSwapDestroyContext(__GLXclientState *cl, GLbyte *pc)
@@ -91,7 +130,8 @@ int __glXSwapMakeCurrent(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->context);
     __GLX_SWAP_INT(&req->oldContextTag);
 
-    return __glXMakeCurrent(cl, pc);
+    return DoMakeCurrent( cl, req->drawable, req->drawable,
+			  req->context, req->oldContextTag );
 }
 
 int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
@@ -105,7 +145,8 @@ int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->context);
     __GLX_SWAP_INT(&req->oldContextTag);
 
-    return __glXMakeContextCurrent(cl, pc);
+    return DoMakeCurrent( cl, req->drawable, req->readdrawable,
+			  req->context, req->oldContextTag );
 }
 
 int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
@@ -119,7 +160,8 @@ int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->context);
     __GLX_SWAP_INT(&req->oldContextTag);
 
-    return __glXMakeCurrentReadSGI(cl, pc);
+    return DoMakeCurrent( cl, req->drawable, req->readable,
+			  req->context, req->oldContextTag );
 }
 
 int __glXSwapIsDirect(__GLXclientState *cl, GLbyte *pc)
@@ -182,90 +224,29 @@ int __glXSwapCopyContext(__GLXclientState *cl, GLbyte *pc)
 
 int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
 {
-    ClientPtr client = cl->client;
     xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
-    xGLXGetVisualConfigsReply reply;
-    __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
-    CARD32 buf[__GLX_TOTAL_CONFIG];
-    unsigned int screen;
-    int i, p;
     __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
     __GLX_SWAP_INT(&req->screen);
-    screen = req->screen;
-    if (screen > screenInfo.numScreens) {
-	/* The client library must send a valid screen number. */
-	client->errorValue = screen;
-	return BadValue;
-    }
-    pGlxScreen = &__glXActiveScreens[screen];
-
-    reply.numVisuals = pGlxScreen->numUsableVisuals;
-    reply.numProps = __GLX_TOTAL_CONFIG;
-    reply.length = (pGlxScreen->numUsableVisuals * __GLX_SIZE_CARD32 *
-		    __GLX_TOTAL_CONFIG) >> 2;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    
-    __GLX_SWAP_SHORT(&reply.sequenceNumber);
-    __GLX_SWAP_INT(&reply.length);
-    __GLX_SWAP_INT(&reply.numVisuals);
-    __GLX_SWAP_INT(&reply.numProps);
-    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);
-
-    for (i=0; i < pGlxScreen->numVisuals; i++) {
-	pGlxVisual = &pGlxScreen->pGlxVisual[i];
-	if (pGlxVisual->vid == 0) {
-	    /* not a usable visual */
-	    continue;
-	}
-	p = 0;
-	buf[p++] = pGlxVisual->vid;
-	buf[p++] = pGlxVisual->class;
-	buf[p++] = pGlxVisual->rgba;
-
-	buf[p++] = pGlxVisual->redSize;
-	buf[p++] = pGlxVisual->greenSize;
-	buf[p++] = pGlxVisual->blueSize;
-	buf[p++] = pGlxVisual->alphaSize;
-	buf[p++] = pGlxVisual->accumRedSize;
-	buf[p++] = pGlxVisual->accumGreenSize;
-	buf[p++] = pGlxVisual->accumBlueSize;
-	buf[p++] = pGlxVisual->accumAlphaSize;
-
-	buf[p++] = pGlxVisual->doubleBuffer;
-	buf[p++] = pGlxVisual->stereo;
-
-	buf[p++] = pGlxVisual->bufferSize;
-	buf[p++] = pGlxVisual->depthSize;
-	buf[p++] = pGlxVisual->stencilSize;
-	buf[p++] = pGlxVisual->auxBuffers;
-	buf[p++] = pGlxVisual->level;
-        /*
-        ** Add token/value pairs for extensions.
-        */
-        buf[p++] = GLX_VISUAL_CAVEAT_EXT;
-        buf[p++] = pGlxVisual->visualRating;
-        buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
-        buf[p++] = pGlxVisual->transparentPixel;
-        buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentRed;
-        buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentGreen;
-        buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentBlue;
-        buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentAlpha;
-        buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentIndex;
-
-	__GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);
-	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, 
-			(char *)buf);
-    }
-    return Success;
+    return DoGetVisualConfigs( cl, req->screen, GL_TRUE );
+}
+
+int __glXSwapGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_INT(&req->screen);
+    return DoGetFBConfigs( cl, req->screen, GL_TRUE );
+}
+
+int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_INT(&req->screen);
+    return DoGetFBConfigs( cl, req->screen, GL_TRUE );
 }
 
 int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
@@ -279,7 +260,39 @@ int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->pixmap);
     __GLX_SWAP_INT(&req->glxpixmap);
 
-    return __glXCreateGLXPixmap(cl, pc);
+    return DoCreateGLXPixmap( cl, req->visual, req->screen,
+			      req->pixmap, req->glxpixmap );
+}
+
+int __glXSwapCreatePixmap(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_SHORT(&req->length);
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->pixmap);
+    __GLX_SWAP_INT(&req->glxpixmap);
+
+    return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
+			      req->pixmap, req->glxpixmap );
+}
+
+int __glXSwapCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateGLXPixmapWithConfigSGIXReq *req = 
+	(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_SHORT(&req->length);
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->pixmap);
+    __GLX_SWAP_INT(&req->glxpixmap);
+
+    return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
+			      req->pixmap, req->glxpixmap );
 }
 
 int __glXSwapDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
@@ -806,6 +819,7 @@ int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)
     }
 #endif
 
+
     if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
           (vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT))  {
 	(*__glXSwapVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])(cl, (GLbyte*)req);
@@ -833,6 +847,12 @@ int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
 	return __glXSwapQueryContextInfoEXT(cl, pc);
       case X_GLXvop_MakeCurrentReadSGI:
 	return __glXSwapMakeCurrentReadSGI(cl, pc);
+      case X_GLXvop_GetFBConfigsSGIX:
+	return __glXSwapGetFBConfigsSGIX(cl, pc);
+      case X_GLXvop_CreateContextWithConfigSGIX:
+	return __glXSwapCreateContextWithConfigSGIX(cl, pc);
+      case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
+	return __glXSwapCreateGLXPixmapWithConfigSGIX(cl, pc);
       default:
 	break;
     }
diff --git a/GL/glx/glxcontext.h b/GL/glx/glxcontext.h
index 5eb72177e..9a16851f0 100644
--- a/GL/glx/glxcontext.h
+++ b/GL/glx/glxcontext.h
@@ -80,7 +80,6 @@ struct __GLXcontextRec {
     ** This context is created with respect to this visual.
     */
     VisualRec *pVisual;
-    __GLXvisualConfig *pGlxVisual;
 
     /*
     ** The XID of this context.
diff --git a/GL/glx/glxdrawable.h b/GL/glx/glxdrawable.h
index 972a6045f..1d7f44352 100644
--- a/GL/glx/glxdrawable.h
+++ b/GL/glx/glxdrawable.h
@@ -40,7 +40,7 @@
 typedef struct {
 
     DrawablePtr pDraw;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     __GLXscreenInfo *pGlxScreen;
     ScreenPtr pScreen;
     Bool idExists;
@@ -69,11 +69,12 @@ struct __GLXdrawablePrivateRec {
     /*
     ** Configuration of the visual to which this drawable was created.
     */
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
 
     /*
     ** cached drawable size and origin
     */
+
     GLint xorigin, yorigin;
     GLint width, height;
 
diff --git a/GL/glx/glxext.c b/GL/glx/glxext.c
index 796663e9b..87c9e1448 100644
--- a/GL/glx/glxext.c
+++ b/GL/glx/glxext.c
@@ -30,12 +30,11 @@
 #include "micmap.h"
 
 
-extern __GLXextensionInfo __glDDXExtensionInfo;
 void GlxWrapInitVisuals(miInitVisualsProcPtr *);
 void GlxSetVisualConfigs(int nconfigs, 
                          __GLXvisualConfig *configs, void **privates);
 
-__GLXextensionInfo *__glXExt = &__glDDXExtensionInfo;
+static __GLXextensionInfo *__glXExt /* = &__glDDXExtensionInfo */;
 
 /*
 ** Forward declarations.
@@ -314,6 +313,8 @@ GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc)
 {
     saveInitVisualsProc = *initVisProc;
     *initVisProc = GlxInitVisuals;
+    /* HACK: this shouldn't be done here but it's the earliest time */
+    __glXExt = __glXglDDXExtensionInfo();       /* from GLcore */
 }
 
 /************************************************************************/
diff --git a/GL/glx/glxext.h b/GL/glx/glxext.h
index 210fbb88c..c6cd219c7 100644
--- a/GL/glx/glxext.h
+++ b/GL/glx/glxext.h
@@ -73,8 +73,16 @@ extern void __glXResetLargeCommandStatus(__GLXclientState*);
 extern int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc);
 extern int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc);
 
-extern int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
-extern int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
+extern int DoMakeCurrent( __GLXclientState *cl, GLXDrawable drawId,
+    GLXDrawable readId, GLXContextID contextId, GLXContextTag tag );
+extern int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
+    GLboolean do_swap);
+extern int DoGetFBConfigs(__GLXclientState *cl, unsigned screen,
+    GLboolean do_swap);
+extern int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
+    GLXContextID shareList, VisualID visual, GLuint screen, GLboolean isDirect);
+extern int DoCreateGLXPixmap(__GLXclientState *cl, VisualID visual,
+    GLuint screenNum, XID pixmapId, XID glxpixmapId);
 
 extern void GlxExtensionInit(void);
 
diff --git a/GL/glx/glxscreens.c b/GL/glx/glxscreens.c
index f78b4a284..6ddbfcbd0 100644
--- a/GL/glx/glxscreens.c
+++ b/GL/glx/glxscreens.c
@@ -133,104 +133,34 @@ static char GLXServerExtensions[] =
 			"GLX_EXT_visual_info "
 			"GLX_EXT_visual_rating "
 			"GLX_EXT_import_context "
+			"GLX_OML_swap_method "
 			"GLX_SGI_make_current_read "
 #ifndef __DARWIN__
 			"GLX_SGIS_multisample "
 #endif
+			"GLX_SGIX_fbconfig "
 			;
 
 /*
-** This comes from the GL library that the server will link with.  Right
-** now, that is the DDX Sample OpenGL.
-*/
-extern __GLXscreenInfo __glDDXScreenInfo;
-
-__GLXscreenInfo *__glXScreens[] = {
-    &__glDDXScreenInfo,
+ * __glDDXScreenInfo comes from GLcore, so we can't resolve this symbol at
+ * module open time.  Leave a placeholder, and fill this in when we first
+ * need it (in __glXScreenInit).  XXX Why make this an array?
+ */
+static __GLXscreenInfo *__glXScreens[] = {
+    NULL /* &__glDDXScreenInfo */ ,
 };
 
-GLint __glXNumStaticScreens = (sizeof __glXScreens / sizeof __glXScreens[0]);
+static GLint __glXNumStaticScreens =
+	(sizeof __glXScreens / sizeof __glXScreens[0]);
 
 __GLXscreenInfo *__glXActiveScreens;
 GLint __glXNumActiveScreens;
 
 RESTYPE __glXDrawableRes;
 
-#if 0
-static int
-CountBits(unsigned long mask)
-{
-    int count = 0;
-
-    while(mask) {
-	count += (mask&1);
-	mask >>= 1;
-    }
-
-    return count;
+__GLXscreenInfo *__glXgetActiveScreen(int num) {
+	return &__glXActiveScreens[num];
 }
-#endif
-
-#if 0
-/*
-** A typical implementation would not probably not run through the screen's
-** visuals to find ones that match the visual configs supplied by the DDX
-** Sample OpenGL as we do here; we have done this to make this code easy to
-** drop into an existing X server.
-*/
-static int matchVisuals(__GLXvisualConfig *pGlxVisual, int numVisuals,
-			 int screen)
-{
-    int i, j;
-    __GLXvisualConfig *pvis = pGlxVisual;
-    ScreenPtr pScreen = screenInfo.screens[screen];
-    VisualPtr pVisual;
-    int numMatchingVisuals = 0; 
-    int *used;
-
-    used = (int *)__glXMalloc(pScreen->numVisuals*sizeof(int));
-    __glXMemset(used, 0, pScreen->numVisuals*sizeof(int));
-
-    for (i=0; i < numVisuals; i++, pvis++) {
-	/*
-	** Look through all the server's visuals to see which match.
-	*/
-	pvis->vid = 0;
-	pVisual = pScreen->visuals;
-	for (j=0; j < pScreen->numVisuals; j++, pVisual++) {
-	    if (pvis->class == pVisual->class &&
-		pvis->bufferSize == pVisual->nplanes &&
-		!used[j]) {
-		int rBits, gBits, bBits, aBits;
-
-		/* count bits per rgb */
-		rBits = CountBits(pVisual->redMask);
-		gBits = CountBits(pVisual->greenMask);
-		bBits = CountBits(pVisual->blueMask);
-		aBits = 0;
-		if ((pvis->redSize == rBits) &&
-		    (pvis->greenSize == gBits) &&
-		    (pvis->blueSize == bBits) &&
-		    (pvis->alphaSize == aBits)) {
-		    /*
-		    ** We'll consider this a match.
-		    */
-		    pvis->vid = pVisual->vid;
-		    pvis->redMask = pVisual->redMask;
-		    pvis->greenMask = pVisual->greenMask;
-		    pvis->blueMask = pVisual->blueMask;
-		    pvis->alphaMask = 0;
-		    numMatchingVisuals++;
-		    used[j] = 1;
-		    break;
-		}
-	    }
-	}
-    }
-    __glXFree(used);
-    return numMatchingVisuals;
-}
-#endif
 
 /*
 ** Destroy routine that gets called when a drawable is freed.  A drawable
@@ -346,6 +276,8 @@ void __glXScreenInit(GLint numscreens)
 {
     GLint i,j;
 
+    __glXScreens[0] = __glXglDDXScreenInfo(); /* from GLcore */
+
     /*
     ** This alloc has to work or else the server might as well core dump.
     */
@@ -360,14 +292,7 @@ void __glXScreenInit(GLint numscreens)
 	    if ((*__glXScreens[j]->screenProbe)(i)) {
 		__glXActiveScreens[i] = *__glXScreens[j];
 
-#if 0
-                /* we don't use this since matchVisuals doesn't allow alpha */
-		__glXActiveScreens[i].numUsableVisuals =
-		    matchVisuals(__glXActiveScreens[i].pGlxVisual,
-			         __glXActiveScreens[i].numVisuals, i); 
-#else
 		__glXActiveScreens[i].numUsableVisuals = __glXActiveScreens[i].numVisuals;
-#endif
 		__glXActiveScreens[i].GLextensions = __glXStrdup(GLServerExtensions);
 		__glXActiveScreens[i].GLXvendor = __glXStrdup(GLXServerVendorName);
 		__glXActiveScreens[i].GLXversion = __glXStrdup(GLXServerVersion);
diff --git a/GL/glx/glxscreens.h b/GL/glx/glxscreens.h
index 42dc66e08..c4d237bbc 100644
--- a/GL/glx/glxscreens.h
+++ b/GL/glx/glxscreens.h
@@ -70,7 +70,11 @@ typedef struct {
     */
     void (*createBuffer)(__GLXdrawablePrivate *glxPriv);
 
-    __GLXvisualConfig *pGlxVisual;
+    /**
+     * Linked list of valid context modes for this screen.
+     */
+    __GLcontextModes *modes;
+
     void **pVisualPriv;
     GLint numVisuals;
     GLint numUsableVisuals;
diff --git a/GL/glx/glxserver.h b/GL/glx/glxserver.h
index be9e40f5a..66d681d2d 100644
--- a/GL/glx/glxserver.h
+++ b/GL/glx/glxserver.h
@@ -92,6 +92,7 @@ typedef struct __GLXclientStateRec __GLXclientState;
 
 extern __GLXscreenInfo *__glXActiveScreens;
 extern GLint __glXNumActiveScreens;
+extern __GLXscreenInfo *__glXgetActiveScreen(int num);
 
 /************************************************************************/
 
diff --git a/GL/glx/glxutil.c b/GL/glx/glxutil.c
index 7aafd0065..4512aa5e9 100644
--- a/GL/glx/glxutil.c
+++ b/GL/glx/glxutil.c
@@ -44,6 +44,9 @@
 #include "glxutil.h"
 #include "glxbuf.h"
 #include "GL/glx_ansic.h"
+#include "GL/internal/glcore.h"
+#include "GL/glxint.h"
+#include "glcontextmodes.h"
 
 /************************************************************************/
 
@@ -214,53 +217,6 @@ __glXResizeDrawable(__GLdrawablePrivate *glPriv)
 }
 
 
-/************************************************************************/
-
-void
-__glXFormatGLModes(__GLcontextModes *modes, __GLXvisualConfig *config)
-{
-    __glXMemset(modes, 0, sizeof(__GLcontextModes));
-
-    modes->rgbMode = (config->rgba != 0);
-    modes->colorIndexMode = !(modes->rgbMode);
-    modes->doubleBufferMode = (config->doubleBuffer != 0);
-    modes->stereoMode = (config->stereo != 0);
-
-    modes->haveAccumBuffer = ((config->accumRedSize +
-			       config->accumGreenSize +
-			       config->accumBlueSize +
-			       config->accumAlphaSize) > 0);
-    modes->haveDepthBuffer = (config->depthSize > 0);
-    modes->haveStencilBuffer = (config->stencilSize > 0);
-
-    modes->redBits = config->redSize;
-    modes->greenBits = config->greenSize;
-    modes->blueBits = config->blueSize;
-    modes->alphaBits = config->alphaSize;
-    modes->redMask = config->redMask;
-    modes->greenMask = config->greenMask;
-    modes->blueMask = config->blueMask;
-    modes->alphaMask = config->alphaMask;
-#if 0
-    modes->rgbBits = modes->redBits + modes->greenBits + 
-	modes->blueBits + modes->alphaBits;
-#endif
-    assert( !modes->rgbMode || ((config->bufferSize & 0x7) == 0) );
-    modes->rgbBits = config->bufferSize;
-    modes->indexBits = config->bufferSize;
-
-    modes->accumRedBits = config->accumRedSize;
-    modes->accumGreenBits = config->accumGreenSize;
-    modes->accumBlueBits = config->accumBlueSize;
-    modes->accumAlphaBits = config->accumAlphaSize;
-    modes->depthBits = config->depthSize;
-    modes->stencilBits = config->stencilSize;
-
-    modes->numAuxBuffers = 0;	/* XXX: should be picked up from the visual */
-
-    modes->level = config->level;
-}
-
 /*****************************************************************************/
 /* accessing the drawable private */
 
@@ -382,21 +338,13 @@ __glXCreateDrawablePrivate(DrawablePtr pDraw, XID drawId,
 
     pGlxScreen = &__glXActiveScreens[pDraw->pScreen->myNum];
 
-    /* allocate the buffers */
     if (glxPriv->type == DRAWABLE_WINDOW) {
-	int i;
 	VisualID vid = wVisual((WindowPtr)pDraw);
-	__GLXvisualConfig *pGlxVisual = pGlxScreen->pGlxVisual;
 
-	for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
-	    if (pGlxVisual->vid == vid) {
-		glxPriv->pGlxVisual = pGlxVisual;
-		break;
-	    }
-	}
+	glxPriv->modes = _gl_context_modes_find_visual( pGlxScreen->modes, vid );
 	__glXFBInitDrawable(glxPriv, modes);
     } else {
-	glxPriv->pGlxVisual = glxPriv->pGlxPixmap->pGlxVisual;
+	glxPriv->modes = glxPriv->pGlxPixmap->modes;
 	__glXPixInitDrawable(glxPriv, modes);
     }
 
diff --git a/GL/glx/glxutil.h b/GL/glx/glxutil.h
index 67bfb06f9..dbf7084b5 100644
--- a/GL/glx/glxutil.h
+++ b/GL/glx/glxutil.h
@@ -55,7 +55,6 @@ extern void __glXGetDrawableSize(__GLdrawablePrivate *glPriv,
 				 GLuint *width, GLuint *height);
 extern GLboolean __glXResizeDrawable(__GLdrawablePrivate *glPriv);
 extern GLboolean __glXResizeDrawableBuffers(__GLXdrawablePrivate *glxPriv);
-extern void __glXFormatGLModes(__GLcontextModes *modes, __GLXvisualConfig *config);
 
 /* drawable management */
 extern void __glXRefDrawablePrivate(__GLXdrawablePrivate *glxPriv);
@@ -73,6 +72,9 @@ extern void __glXCacheDrawableSize(__GLXdrawablePrivate *glxPriv);
 /* context helper routines */
 extern __GLXcontext *__glXLookupContextByTag(__GLXclientState*, GLXContextTag);
 
+/* init helper routines */
+extern void *__glXglDDXScreenInfo(void);
+extern void *__glXglDDXExtensionInfo(void);
 
 #endif /* _glxcmds_h_ */
 
diff --git a/GL/glx/render2.c b/GL/glx/render2.c
index d4c523fea..2629a7025 100644
--- a/GL/glx/render2.c
+++ b/GL/glx/render2.c
@@ -234,16 +234,14 @@ void __glXDisp_DrawArrays(GLbyte *pc)
 	    glEnableClientState(GL_EDGE_FLAG_ARRAY);
 	    glEdgeFlagPointer(stride, (const GLboolean *)pc);
 	    break;
-#ifndef MISSING_GL_EXTS
 	  case GL_SECONDARY_COLOR_ARRAY:
 	    glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
 	    glSecondaryColorPointer(numVals, datatype, stride, pc);
 	    break;
-	  case GL_FOG_COORDINATE_ARRAY:
-	    glEnableClientState(GL_FOG_COORDINATE_ARRAY);
+	  case GL_FOG_COORD_ARRAY:
+	    glEnableClientState(GL_FOG_COORD_ARRAY);
 	    glFogCoordPointer(datatype, stride, pc);
 	    break;
-#endif
 	  default:
 	    break;
 	}
@@ -261,7 +259,7 @@ void __glXDisp_DrawArrays(GLbyte *pc)
     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
     glDisableClientState(GL_EDGE_FLAG_ARRAY);
     glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
-    glDisableClientState(GL_FOG_COORDINATE_ARRAY);
+    glDisableClientState(GL_FOG_COORD_ARRAY);
 }
 
 void __glXDisp_DrawArraysEXT(GLbyte *pc)
diff --git a/GL/glx/rensize.c b/GL/glx/rensize.c
index aa784b5fc..5d7c7b367 100644
--- a/GL/glx/rensize.c
+++ b/GL/glx/rensize.c
@@ -558,7 +558,7 @@ int __glXDrawArraysSize( GLbyte *pc, Bool swap )
 		return -1;
 	    }
 	    break;
-	  case GL_FOG_COORDINATE_ARRAY:
+	  case GL_FOG_COORD_ARRAY:
 	  case GL_INDEX_ARRAY:
 	    if (numVals != 1) {
 		/* bad size */
diff --git a/GL/glx/singlesize.c b/GL/glx/singlesize.c
index 448fa1aef..3baf03517 100644
--- a/GL/glx/singlesize.c
+++ b/GL/glx/singlesize.c
@@ -81,7 +81,7 @@ GLint __glGetTexEnvfv_size(GLenum pname)
       case GL_ALPHA_SCALE:
 	
       /* GL_ARB_point_sprite / GL_NV_point_sprite */
-      case GL_COORD_REPLACE_NV:
+      case GL_COORD_REPLACE_ARB:
 
       /* GL_NV_texture_env_combine4 */
       case GL_SOURCE3_RGB_NV:
@@ -179,6 +179,9 @@ GLint __glGetTexParameterfv_size(GLenum pname)
 
       /* GL_EXT_texture_filter_anisotropic */
       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+
+      /* GL_NV_texture_expand_normal */
+      case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
 	return 1;
 
       default:
@@ -898,11 +901,11 @@ GLint __glGet_size(GLenum sq)
       case GL_BLEND_SRC_ALPHA:
 
       /* GL_EXT_fog_coord / GL 1.4 */
-      case GL_CURRENT_FOG_COORDINATE:
-      case GL_FOG_COORDINATE_ARRAY_TYPE:
-      case GL_FOG_COORDINATE_ARRAY_STRIDE:
-      case GL_FOG_COORDINATE_ARRAY:
-      case GL_FOG_COORDINATE_SOURCE:
+      case GL_CURRENT_FOG_COORD:
+      case GL_FOG_COORD_ARRAY_TYPE:
+      case GL_FOG_COORD_ARRAY_STRIDE:
+      case GL_FOG_COORD_ARRAY:
+      case GL_FOG_COORD_SRC:
 
       /* GL_EXT_secondary_color / GL 1.4 */
       case GL_COLOR_SUM:
@@ -915,7 +918,7 @@ GLint __glGet_size(GLenum sq)
       case GL_MAX_TEXTURE_LOD_BIAS:
 
       /* GL_ARB_point_sprite */
-      case GL_POINT_SPRITE_NV:
+      case GL_POINT_SPRITE_ARB:
 
       /* GL_ARB_vertex_blend */
       case GL_MAX_VERTEX_UNITS_ARB:
@@ -942,6 +945,9 @@ GLint __glGet_size(GLenum sq)
       /* GL_EXT_clip_volume_hint */
       case GL_CLIP_VOLUME_CLIPPING_HINT_EXT:
 
+      /* GL_EXT_depth_bounds_test */
+      case GL_DEPTH_BOUNDS_TEST_EXT:
+
       /* GL_EXT_stencil_two_size */
       case GL_STENCIL_TEST_TWO_SIDE_EXT:
       case GL_ACTIVE_STENCIL_FACE_EXT:
@@ -958,9 +964,38 @@ GLint __glGet_size(GLenum sq)
       /* case GL_MODELVIEW0_STACK_DEPTH_EXT: */ /* alias */
       case GL_MODELVIEW1_STACK_DEPTH_EXT:
 
+      /* GL_EXT_blend_equation_separate */
+      /* case GL_BLEND_EQUATION_RGB_EXT: */ /* alias */
+      case GL_BLEND_EQUATION_ALPHA_EXT:
+
       /* GL_ATI_vertex_streams */
       case GL_MAX_VERTEX_STREAMS_ATI:
 
+      /* GL_ATI_draw_buffers */
+      case GL_MAX_DRAW_BUFFERS_ATI:
+      case GL_DRAW_BUFFER0_ATI:
+      case GL_DRAW_BUFFER1_ATI:
+      case GL_DRAW_BUFFER2_ATI:
+      case GL_DRAW_BUFFER3_ATI:
+      case GL_DRAW_BUFFER4_ATI:
+      case GL_DRAW_BUFFER5_ATI:
+      case GL_DRAW_BUFFER6_ATI:
+      case GL_DRAW_BUFFER7_ATI:
+      case GL_DRAW_BUFFER8_ATI:
+      case GL_DRAW_BUFFER9_ATI:
+      case GL_DRAW_BUFFER10_ATI:
+      case GL_DRAW_BUFFER11_ATI:
+      case GL_DRAW_BUFFER12_ATI:
+      case GL_DRAW_BUFFER13_ATI:
+      case GL_DRAW_BUFFER14_ATI:
+      case GL_DRAW_BUFFER15_ATI:
+
+      /* GL_ATI_separate_stencil */
+      case GL_STENCIL_BACK_FUNC_ATI:
+      case GL_STENCIL_BACK_FAIL_ATI:
+      case GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI:
+      case GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI:
+
       /* GL_NV_depth_clamp */
       case GL_DEPTH_CLAMP_NV:
 
@@ -978,6 +1013,10 @@ GLint __glGet_size(GLenum sq)
       /* case GL_POINT_SPRITE_NV: */ /* alias */
       case GL_POINT_SPRITE_R_MODE_NV:
 
+      /* GL_NV_primitive_restart */
+      case GL_PRIMITIVE_RESTART_NV:
+      case GL_PRIMITIVE_RESTART_INDEX_NV:
+
       /* GL_NV_register_combiners */
       case GL_REGISTER_COMBINERS_NV:
       case GL_NUM_GENERAL_COMBINERS_NV:
@@ -993,6 +1032,10 @@ GLint __glGet_size(GLenum sq)
       case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
 	return 1;
 
+      /* GL_EXT_depth_bounds_test */
+      case GL_DEPTH_BOUNDS_EXT:
+	return 2;
+
       /* GL_EXT_secondary_color / GL 1.4 */
       case GL_CURRENT_SECONDARY_COLOR:
 
diff --git a/GL/windows/ChangeLog b/GL/windows/ChangeLog
index 2b049ee73..9732e8c86 100644
--- a/GL/windows/ChangeLog
+++ b/GL/windows/ChangeLog
@@ -1,3 +1,11 @@
+2004-08-13  Alexander Gottwald  <ago@freedesktop.org>
+
+	* Imakefile: Added $(MESASRCDIR)/src/mesa/glapi to INCLUDES.
+	Removed $(SERVERSRC)/mi from INCLUDES.
+	Rearranged INCLUDES for better readability.
+	* glwindows.h: Removed mipointrst.h and miscstruct.h from #include 
+	since they are not used anymore.
+
 2004-05-27  Alexander Gottwald  <ago@freedesktop.org>
 
 	* glwindows.h: write current function and line in debug output
diff --git a/GL/windows/glwindows.h b/GL/windows/glwindows.h
index 1bfdcb715..aa984099c 100644
--- a/GL/windows/glwindows.h
+++ b/GL/windows/glwindows.h
@@ -4,8 +4,6 @@
 #include <glxserver.h>
 #include <glxext.h>
 
-#include <mipointrst.h>
-#include <miscstruct.h>
 #include <windowstr.h>
 #include <resource.h>
 #include <GL/glxint.h>
@@ -35,7 +33,7 @@ extern glWinDebugSettingsRec glWinDebugSettings;
 
 typedef struct {
     int num_vis;
-    __GLXvisualConfig *glx_vis;
+    __GLcontextModes *modes;
     void **priv;
 
     /* wrapped screen functions */
diff --git a/GL/windows/indirect.c b/GL/windows/indirect.c
index 80aec7ee9..11dc0c092 100755
--- a/GL/windows/indirect.c
+++ b/GL/windows/indirect.c
@@ -43,6 +43,7 @@
 
 
 #include "glwindows.h"
+#include <glcontextmodes.h>
 
 #include "../../hw/xwin/winpriv.h"
 
@@ -171,7 +172,7 @@ static void glWinResetExtension(void);
  * struct.  In particular, the contextCreate, pGlxVisual, numVisuals,
  * and numUsableVisuals fields must be initialized.
  */
-__GLXscreenInfo __glDDXScreenInfo = {
+static __GLXscreenInfo __glDDXScreenInfo = {
     glWinScreenProbe,   /* Must be generic and handle all screens */
     glWinCreateContext, /* Substitute screen's createContext routine */
     glWinCreateBuffer,  /* Substitute screen's createBuffer routine */
@@ -185,13 +186,21 @@ __GLXscreenInfo __glDDXScreenInfo = {
     NULL                  /* WrappedPositionWindow is overwritten */
 };
 
-__GLXextensionInfo __glDDXExtensionInfo = {
+void *__glXglDDXScreenInfo(void) {
+    return &__glDDXScreenInfo;
+}
+
+static __GLXextensionInfo __glDDXExtensionInfo = {
     GL_CORE_WINDOWS,
     glWinResetExtension,
     glWinInitVisuals,
     glWinSetVisualConfigs
 };
 
+void *__glXglDDXExtensionInfo(void) {
+    return &__glDDXExtensionInfo;
+}
+
 /* prototypes */
 
 static GLboolean glWinDestroyContext(__GLcontext *gc);
@@ -863,27 +872,6 @@ static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
   }
 };
 
-static __GLXvisualConfig NullConfig = {
-    -1,                 /* vid */
-    -1,                 /* class */
-    False,              /* rgba */
-    -1, -1, -1, 0,      /* rgba sizes */
-    -1, -1, -1, 0,      /* rgba masks */
-     0,  0,  0, 0,      /* rgba accum sizes */
-    False,              /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    0,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE_EXT,       /* visualRating */
-    0,                  /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-};
-
-
 static inline int count_bits(uint32_t x)
 {
     x = x - ((x >> 1) & 0x55555555);
@@ -908,7 +896,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     VisualPtr pVisual = *visualp;
     VisualPtr pVisualNew = NULL;
     VisualID *orig_vid = NULL;
-    __GLXvisualConfig *glXVisualPtr = NULL;
+    __GLcontextModes *modes = NULL;
     __GLXvisualConfig *pNewVisualConfigs = NULL;
     void **glXVisualPriv;
     void **pNewVisualPriv;
@@ -990,9 +978,8 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     }
 
     /* Alloc space for the list of glXVisuals */
-    glXVisualPtr = (__GLXvisualConfig *)__glXMalloc(numNewVisuals *
-						    sizeof(__GLXvisualConfig));
-    if (!glXVisualPtr) {
+    modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes));
+    if (modes == NULL) {
 	__glXFree(orig_vid);
 	__glXFree(pNewVisualPriv);
 	__glXFree(pNewVisualConfigs);
@@ -1002,7 +989,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     /* Alloc space for the list of glXVisualPrivates */
     glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *));
     if (!glXVisualPriv) {
-	__glXFree(glXVisualPtr);
+	_gl_context_modes_destroy( modes );
 	__glXFree(orig_vid);
 	__glXFree(pNewVisualPriv);
 	__glXFree(pNewVisualConfigs);
@@ -1013,7 +1000,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec));
     if (!pVisualNew) {
 	__glXFree(glXVisualPriv);
-	__glXFree(glXVisualPtr);
+	_gl_context_modes_destroy( modes );
 	__glXFree(orig_vid);
 	__glXFree(pNewVisualPriv);
 	__glXFree(pNewVisualConfigs);
@@ -1022,10 +1009,12 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 
     /* Initialize the new visuals */
     found_default = FALSE;
+    glWinScreens[screenInfo.numScreens-1].modes = modes;
     for (i = j = 0; i < numVisuals; i++) {
         int is_rgb = (pVisual[i].class == TrueColor ||
 		      pVisual[i].class == DirectColor);
 
+#if 0
 	if (!is_rgb)
 	{
 	    /* We don't support non-rgb visuals for GL. But we don't
@@ -1052,11 +1041,14 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 
 	    continue;
 	}
+#endif
 
 	for (k = 0; k < numNewConfigs; k++) {
 	    if (pNewVisualConfigs[k].rgba != is_rgb)
 		continue;
 
+            assert( modes != NULL );
+
 	    /* Initialize the new visual */
 	    pVisualNew[j] = pVisual[i];
 	    pVisualNew[j].vid = FakeClientID(0);
@@ -1071,8 +1063,8 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 	    orig_vid[j] = pVisual[i].vid;
 
 	    /* Initialize the glXVisual */
-	    glXVisualPtr[j] = pNewVisualConfigs[k];
-	    glXVisualPtr[j].vid = pVisualNew[j].vid;
+	    _gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] );
+	    modes->visualID = pVisualNew[j].vid;
 
 	    /*
 	     * If the class is -1, then assume the X visual information
@@ -1080,23 +1072,27 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 	     * visual.  NOTE: if class != -1, then all other fields MUST
 	     * be initialized.
 	     */
-	    if (glXVisualPtr[j].class == -1) {
-		glXVisualPtr[j].class      = pVisual[i].class;
-		glXVisualPtr[j].redSize    = count_bits(pVisual[i].redMask);
-		glXVisualPtr[j].greenSize  = count_bits(pVisual[i].greenMask);
-		glXVisualPtr[j].blueSize   = count_bits(pVisual[i].blueMask);
-		glXVisualPtr[j].alphaSize  = glXVisualPtr[j].alphaSize;
-		glXVisualPtr[j].redMask    = pVisual[i].redMask;
-		glXVisualPtr[j].greenMask  = pVisual[i].greenMask;
-		glXVisualPtr[j].blueMask   = pVisual[i].blueMask;
-		glXVisualPtr[j].alphaMask  = glXVisualPtr[j].alphaMask;
-		glXVisualPtr[j].bufferSize = rootDepth;
+	    if (modes->visualType == GLX_NONE) {
+		modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class );
+		modes->redBits    = count_bits(pVisual[i].redMask);
+		modes->greenBits  = count_bits(pVisual[i].greenMask);
+		modes->blueBits   = count_bits(pVisual[i].blueMask);
+		modes->alphaBits  = modes->alphaBits;
+		modes->redMask    = pVisual[i].redMask;
+		modes->greenMask  = pVisual[i].greenMask;
+		modes->blueMask   = pVisual[i].blueMask;
+		modes->alphaMask  = modes->alphaMask;
+		modes->rgbBits = (is_rgb)
+		    ? (modes->redBits + modes->greenBits +
+		       modes->blueBits + modes->alphaBits)
+		    : rootDepth;
 	    }
 
 	    /* Save the device-dependent private for this visual */
 	    glXVisualPriv[j] = pNewVisualPriv[k];
 
 	    j++;
+            modes = modes->next;
 	}
     }
 
@@ -1104,7 +1100,6 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 
     /* Save the GLX visuals in the screen structure */
     glWinScreens[screenInfo.numScreens-1].num_vis = numNewVisuals;
-    glWinScreens[screenInfo.numScreens-1].glx_vis = glXVisualPtr;
     glWinScreens[screenInfo.numScreens-1].priv = glXVisualPriv;
 
     /* Set up depth's VisualIDs */
@@ -1159,29 +1154,30 @@ static void fixup_visuals(int screen)
 {
     ScreenPtr pScreen = screenInfo.screens[screen];
     glWinScreenRec *pScr = &glWinScreens[screen];
-    __GLXvisualConfig *pGLXVis  = pScr->glx_vis;
-    VisualPtr pVis;
-    int i, j;
+    __GLcontextModes *modes;
+    int j;
 
     GLWIN_DEBUG_MSG("fixup_visuals\n");
 
-    for (i = 0; i < pScr->num_vis; i++, pGLXVis++) {
-	pVis = pScreen->visuals;
+    for (modes = pScr->modes; modes != NULL; modes = modes->next ) {
+	const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
+	const int nplanes = (modes->rgbBits - modes->alphaBits);
+        VisualPtr pVis = pScreen->visuals;
 
 	/* Find a visual that matches the GLX visual's class and size */
-	for (j = 0; j < pScreen->numVisuals; j++, pVis++) {
-	    if (pVis->class == pGLXVis->class &&
-		pVis->nplanes == pGLXVis->bufferSize) {
+	for (j = 0; j < pScreen->numVisuals; j++) {
+	    if (pVis[j].class == vis_class &&
+		pVis[j].nplanes == nplanes) {
 
 		/* Fixup the masks */
-		pGLXVis->redMask   = pVis->redMask;
-		pGLXVis->greenMask = pVis->greenMask;
-		pGLXVis->blueMask  = pVis->blueMask;
+		modes->redMask   = pVis[j].redMask;
+		modes->greenMask = pVis[j].greenMask;
+		modes->blueMask  = pVis[j].blueMask;
 
 		/* Recalc the sizes */
-		pGLXVis->redSize   = count_bits(pGLXVis->redMask);
-		pGLXVis->greenSize = count_bits(pGLXVis->greenMask);
-		pGLXVis->blueSize  = count_bits(pGLXVis->blueMask);
+		modes->redBits   = count_bits(modes->redMask);
+		modes->greenBits = count_bits(modes->greenMask);
+		modes->blueBits  = count_bits(modes->blueMask);
 	    }
 	}
     }
@@ -1190,67 +1186,75 @@ static void fixup_visuals(int screen)
 static void init_screen_visuals(int screen)
 {
     ScreenPtr pScreen = screenInfo.screens[screen];
-    __GLXvisualConfig *pGLXVis = glWinScreens[screen].glx_vis;
-    /* XMesaVisual *pXMesaVisual; */
-    VisualPtr pVis;
+    __GLcontextModes *modes;
     int *used;
     int i, j;
 
     GLWIN_DEBUG_MSG("init_screen_visuals\n");
 
-    /* Alloc space for the list of XMesa visuals */
-#if 0
-     pXMesaVisual = (XMesaVisual *)__glXMalloc(MESAScreens[screen].num_vis *
-    					      sizeof(XMesaVisual));
-     __glXMemset(pXMesaVisual, 0,
-    		MESAScreens[screen].num_vis * sizeof(XMesaVisual));
-#endif
-
     used = (int *)__glXMalloc(pScreen->numVisuals * sizeof(int));
     __glXMemset(used, 0, pScreen->numVisuals * sizeof(int));
 
-    for (i = 0; i < glWinScreens[screen].num_vis; i++, pGLXVis++) {
-	pVis = pScreen->visuals;
-	for (j = 0; j < pScreen->numVisuals; j++, pVis++) {
-
-	    if (pVis->class == pGLXVis->class &&
-		pVis->nplanes == pGLXVis->bufferSize &&
+    i = 0;
+    for ( modes = glWinScreens[screen].modes
+          ; modes != NULL
+          ; modes = modes->next) {
+        const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
+        const int nplanes = (modes->rgbBits - modes->alphaBits);
+        const VisualPtr pVis = pScreen->visuals;
+
+	for (j = 0; j < pScreen->numVisuals; j++) {
+
+            if (pVis[j].class     == vis_class &&
+		pVis[j].nplanes   == nplanes &&
+		pVis[j].redMask   == modes->redMask &&
+		pVis[j].greenMask == modes->greenMask &&
+		pVis[j].blueMask  == modes->blueMask &&
 		!used[j]) {
 
-		if (pVis->redMask   == pGLXVis->redMask &&
-		    pVis->greenMask == pGLXVis->greenMask &&
-		    pVis->blueMask  == pGLXVis->blueMask) {
-
-		    /* Create the XMesa visual */
 #if 0
-		    pXMesaVisual[i] =
-                         XMesaCreateVisual(pScreen,
-					   pVis,
-					   pGLXVis->rgba,
-					   (pGLXVis->alphaSize > 0),
-					   pGLXVis->doubleBuffer,
-					   pGLXVis->stereo,
-					   GL_TRUE, /* ximage_flag */
-					   pGLXVis->depthSize,
-					   pGLXVis->stencilSize,
-					   pGLXVis->accumRedSize,
-					   pGLXVis->accumGreenSize,
-					   pGLXVis->accumBlueSize,
-					   pGLXVis->accumAlphaSize,
-                                           0,  /* numSamples */
-					   pGLXVis->level,
-                                           pGLXVis->visualRating );
+		/* Create the XMesa visual */
+		pXMesaVisual[i] =
+		    XMesaCreateVisual(pScreen,
+				      pVis,
+				      modes->rgbMode,
+				      (modes->alphaBits > 0),
+				      modes->doubleBufferMode,
+				      modes->stereoMode,
+				      GL_TRUE, /* ximage_flag */
+				      modes->depthBits,
+				      modes->stencilBits,
+				      modes->accumRedBits,
+				      modes->accumGreenBits,
+				      modes->accumBlueBits,
+				      modes->accumAlphaBits,
+				      modes->samples,
+				      modes->level,
+				      modes->visualRating);
 #endif
+                
+		/* Set the VisualID */
+		modes->visualID = pVis[j].vid;
 
-		    /* Set the VisualID */
-		    pGLXVis->vid = pVis->vid;
+                /* Mark this visual used */
+                used[j] = 1;
+                break;
+            }
+        }
 
-		    /* Mark this visual used */
-		    used[j] = 1;
-		    break;
-		}
-	    }
+        if ( j == pScreen->numVisuals ) {
+            ErrorF("No matching visual for __GLcontextMode with "
+                   "visual class = %d (%d), nplanes = %u\n",
+                   vis_class, 
+		   modes->visualType,
+		   (modes->rgbBits - modes->alphaBits) );
+	}
+	else if ( modes->visualID == -1 ) {
+	    FatalError( "Matching visual found, but visualID still -1!\n" );
 	}
+
+	i++;
+        
     }
 
     __glXFree(used);
@@ -1268,7 +1272,7 @@ static Bool glWinScreenProbe(int screen)
     /*
      * Set up the current screen's visuals.
      */
-    __glDDXScreenInfo.pGlxVisual = glWinScreens[screen].glx_vis;
+    __glDDXScreenInfo.modes = glWinScreens[screen].modes;
     __glDDXScreenInfo.pVisualPriv = glWinScreens[screen].priv;
     __glDDXScreenInfo.numVisuals =
 	__glDDXScreenInfo.numUsableVisuals = glWinScreens[screen].num_vis;