Merge branch 'master' into mpx

6 files changed, 2323 insertions, 5 deletions

diff --git a/hw/xwin/InitOutput.c b/hw/xwin/InitOutput.c
index d2159813c..abc35b943 100644
--- a/hw/xwin/InitOutput.c
+++ b/hw/xwin/InitOutput.c
@@ -920,11 +920,6 @@ ddxUseMsg(void)
 		  MB_ICONINFORMATION);
 }
 
-/* ddxInitGlobals - called by |InitGlobals| from os/util.c */
-void ddxInitGlobals(void)
-{
-}
-
 /* See Porting Layer Definition - p. 20 */
 /*
  * Do any global initialization, then initialize each screen.
diff --git a/hw/xwin/Makefile.am b/hw/xwin/Makefile.am
index 5ffba1274..a88528901 100644
--- a/hw/xwin/Makefile.am
+++ b/hw/xwin/Makefile.am
@@ -167,7 +167,14 @@ AM_CFLAGS = -DHAVE_XWIN_CONFIG_H $(DIX_CFLAGS) \
 
 dist_man1_MANS = XWin.man XWinrc.man
 
+GLX_EXTRAS = \
+	windows/ChangeLog \
+	windows/glwindows.h \
+	windows/glwrap.c \
+	windows/indirect.c
+
 EXTRA_DIST = \
+	$(GLX_EXTRAS) \
 	_usr_X11R6_lib_X11_system.XWinrc \
 	X-boxed.ico \
 	X.ico \
diff --git a/hw/xwin/glx/ChangeLog b/hw/xwin/glx/ChangeLog
new file mode 100644
index 000000000..43a817d6a
--- /dev/null
+++ b/hw/xwin/glx/ChangeLog
@@ -0,0 +1,64 @@
+2005-09-27  Ian Romanick  <idr@us.ibm.com>
+
+	* indirect.c:
+	Remove __glEvalComputeK.  It is no longer used.	
+
+
+2005-04-09  Alexander Gottwald  <ago at freedesktop dot org>
+
+	* indirect.c:
+	Fix passing of non-RGB visuals. The old code did not initialize the
+	structure properly which lead to a crash in 8bpp mode
+
+2005-03-01  Alexander Gottwald  <ago at freedesktop dot org>
+
+	* indirect.c:
+	* glwindows.h:
+	If a context is already attached copy it instead of reattaching to keep
+	displaylists and share displaylists
+	Enable tracing of often called functions with GLWIN_ENABLE_TRACE        
+	ForceCurrent is a no-op now
+
+2005-02-02  Alexander Gottwald  <ago at freedesktop dot org>
+
+	* Imakefile: 
+	Bugzilla #1866 (https://bugs.freedesktop.org/show_bug.cgi?id=1866)
+	attachment #1819 (https://bugs.freedesktop.org/attachment.cgi?id=1819):
+	Define APIENTRY on windows to prevent <GL/gl.h> from loading <windows.h>
+
+2005-02-02  Alexander Gottwald  <ago at freedesktop dot org>
+
+	* glwrap.c:
+	* glwindows.h:
+	Bugzilla #1866 (https://bugs.freedesktop.org/show_bug.cgi?id=1866)
+	attachment #1818 (https://bugs.freedesktop.org/attachment.cgi?id=1818):
+	Include Xwindows.h before GL/gl.h to prevent loading windows.h which
+	pollutes our namespace with some symbols.    
+
+2005-01-27  Alexander Gottwald  <ago at freedesktop dot org>
+
+	* glwrap.c:
+	Functions like glGenTextures and glBindTexture are in OpenGL 1.1
+	and can be resolved at linktime.
+
+2004-11-15  Alexander Gottwald  <ago at freedesktop dot org>
+
+	* indirect.c:
+	Bugzilla #1802, http://freedesktop.org/bugzilla/show_bug.cgi?id=1802
+	Added mingw (Win32) port     
+
+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
+	* indirect.c: moved actual setup and creation of windows GL context to 
+	glWinCreateContextReal. 
+	* indirect.c (glWinCreateContext): Deferred context creation to attach.   
+	* indirect.c (glWinMakeCurrent): Check if context is NULL. Fixes segfault.
diff --git a/hw/xwin/glx/glwindows.h b/hw/xwin/glx/glwindows.h
new file mode 100644
index 000000000..74e81f24f
--- /dev/null
+++ b/hw/xwin/glx/glwindows.h
@@ -0,0 +1,64 @@
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/Xwindows.h>
+#include <GL/gl.h>
+#include <GL/glext.h>
+
+#include <glxserver.h>
+#include <glxext.h>
+
+#include <windowstr.h>
+#include <resource.h>
+#include <GL/glxint.h>
+#include <GL/glxtokens.h>
+#include <scrnintstr.h>
+#include <glxserver.h>
+#include <glxscreens.h>
+#include <glxdrawable.h>
+#include <glxcontext.h>
+#include <glxext.h>
+#include <glxutil.h>
+#include <glxscreens.h>
+#include <GL/internal/glcore.h>
+#include <stdlib.h>
+
+
+typedef struct {
+    unsigned enableDebug : 1;
+    unsigned enableTrace : 1;
+    unsigned dumpPFD : 1;
+    unsigned dumpHWND : 1;
+    unsigned dumpDC : 1;
+} glWinDebugSettingsRec, *glWinDebugSettingsPtr;
+extern glWinDebugSettingsRec glWinDebugSettings;
+
+typedef struct {
+    int num_vis;
+    __GLcontextModes *modes;
+    void **priv;
+
+    /* wrapped screen functions */
+    RealizeWindowProcPtr RealizeWindow;
+    UnrealizeWindowProcPtr UnrealizeWindow;
+    CopyWindowProcPtr CopyWindow;
+} glWinScreenRec;
+
+extern glWinScreenRec glWinScreens[MAXSCREENS];
+
+#define glWinGetScreenPriv(pScreen)  &glWinScreens[pScreen->myNum]
+#define glWinScreenPriv(pScreen) glWinScreenRec *pScreenPriv = glWinGetScreenPriv(pScreen);
+
+#if 1
+#define GLWIN_TRACE() if (glWinDebugSettings.enableTrace) ErrorF("%s:%d: Trace\n", __FUNCTION__, __LINE__ )
+#define GLWIN_TRACE_MSG(msg, args...) if (glWinDebugSettings.enableTrace) ErrorF("%s:%d: " msg, __FUNCTION__, __LINE__, ##args )
+#define GLWIN_DEBUG_MSG(msg, args...) if (glWinDebugSettings.enableDebug) ErrorF("%s:%d: " msg, __FUNCTION__, __LINE__, ##args )
+#define GLWIN_DEBUG_MSG2(msg, args...) if (glWinDebugSettings.enableDebug) ErrorF(msg, ##args )
+#else
+#define GLWIN_TRACE()
+#define GLWIN_TRACE_MSG(a, ...)
+#define GLWIN_DEBUG_MSG(a, ...)
+#define GLWIN_DEBUG_MSG2(a, ...)
+#endif
+
diff --git a/hw/xwin/glx/glwrap.c b/hw/xwin/glx/glwrap.c
new file mode 100755
index 000000000..f0b38b228
--- /dev/null
+++ b/hw/xwin/glx/glwrap.c
@@ -0,0 +1,583 @@
+/*
+ * GLX implementation that uses Win32's OpenGL
+ * Wrapper functions for Win32's OpenGL
+ *
+ * Authors: Alexander Gottwald
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/Xwindows.h>
+#include <GL/gl.h>
+#include <GL/glext.h>
+#include <glxserver.h>
+#include <glxext.h>
+
+#define RESOLVE_RET(procname, symbol, retval) \
+    static Bool init = TRUE; \
+    static procname proc = NULL; \
+    if (init) { \
+        proc = (procname)wglGetProcAddress(symbol); \
+        init = FALSE; \
+        if (proc == NULL) { \
+            ErrorF("glwrap: Can't resolve \"%s\"\n", symbol); \
+        } else \
+            ErrorF("glwrap: resolved \"%s\"\n", symbol); \
+    } \
+    if (proc == NULL) { \
+        __glXErrorCallBack(NULL, 0); \
+        return retval; \
+    }
+#define RESOLVE(procname, symbol) RESOLVE_RET(procname, symbol,)
+        
+        
+/*
+ * GL_ARB_imaging
+ */
+
+
+GLAPI void GLAPIENTRY glColorTable( GLenum target, GLenum internalformat,
+                                    GLsizei width, GLenum format,
+                                    GLenum type, const GLvoid *table )
+{
+    RESOLVE(PFNGLCOLORTABLEPROC, "glColorTable");
+    proc(target, internalformat, width, format, type, table);
+}
+
+GLAPI void GLAPIENTRY glColorSubTable( GLenum target,
+                                       GLsizei start, GLsizei count,
+                                       GLenum format, GLenum type,
+                                       const GLvoid *data )
+{
+    RESOLVE(PFNGLCOLORSUBTABLEPROC, "glColorSubTable");
+    proc(target, start, count, format, type, data);
+}
+
+GLAPI void GLAPIENTRY glColorTableParameteriv(GLenum target, GLenum pname,
+                                              const GLint *params)
+{
+    RESOLVE(PFNGLCOLORTABLEPARAMETERIVPROC, "glColorTableParameteriv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glColorTableParameterfv(GLenum target, GLenum pname,
+                                              const GLfloat *params)
+{
+    RESOLVE(PFNGLCOLORTABLEPARAMETERFVPROC, "glColorTableParameterfv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glCopyColorSubTable( GLenum target, GLsizei start,
+                                           GLint x, GLint y, GLsizei width )
+{
+    RESOLVE(PFNGLCOPYCOLORSUBTABLEPROC, "glCopyColorSubTable");
+    proc(target, start, x, y, width);
+}
+
+GLAPI void GLAPIENTRY glCopyColorTable( GLenum target, GLenum internalformat,
+                                        GLint x, GLint y, GLsizei width )
+{
+    RESOLVE(PFNGLCOPYCOLORTABLEPROC, "glCopyColorTable");
+    proc(target, internalformat, x, y, width);
+}
+
+
+GLAPI void GLAPIENTRY glGetColorTable( GLenum target, GLenum format,
+                                       GLenum type, GLvoid *table )
+{
+    RESOLVE(PFNGLGETCOLORTABLEPROC, "glGetColorTable");
+    proc(target, format, type, table);
+}
+
+GLAPI void GLAPIENTRY glGetColorTableParameterfv( GLenum target, GLenum pname,
+                                                  GLfloat *params )
+{
+    RESOLVE(PFNGLGETCOLORTABLEPARAMETERFVPROC, "glGetColorTableParameterfv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glGetColorTableParameteriv( GLenum target, GLenum pname,
+                                                  GLint *params )
+{
+    RESOLVE(PFNGLGETCOLORTABLEPARAMETERIVPROC, "glGetColorTableParameteriv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glBlendEquation( GLenum mode )
+{
+    RESOLVE(PFNGLBLENDEQUATIONPROC, "glBlendEquation");
+    proc(mode);
+}
+
+GLAPI void GLAPIENTRY glBlendColor( GLclampf red, GLclampf green,
+                                    GLclampf blue, GLclampf alpha )
+{
+    RESOLVE(PFNGLBLENDCOLORPROC, "glBlendColor");
+    proc(red, green, blue, alpha);
+}
+
+GLAPI void GLAPIENTRY glHistogram( GLenum target, GLsizei width,
+				   GLenum internalformat, GLboolean sink )
+{
+    RESOLVE(PFNGLHISTOGRAMPROC, "glHistogram");
+    proc(target, width, internalformat, sink);
+}
+
+GLAPI void GLAPIENTRY glResetHistogram( GLenum target )
+{
+    RESOLVE(PFNGLRESETHISTOGRAMPROC, "glResetHistogram");
+    proc(target);
+}
+
+GLAPI void GLAPIENTRY glGetHistogram( GLenum target, GLboolean reset,
+				      GLenum format, GLenum type,
+				      GLvoid *values )
+{
+    RESOLVE(PFNGLGETHISTOGRAMPROC, "glGetHistogram");
+    proc(target, reset, format, type, values);
+};
+
+GLAPI void GLAPIENTRY glGetHistogramParameterfv( GLenum target, GLenum pname,
+						 GLfloat *params )
+{
+    RESOLVE(PFNGLGETHISTOGRAMPARAMETERFVPROC, "glGetHistogramParameterfv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glGetHistogramParameteriv( GLenum target, GLenum pname,
+						 GLint *params )
+{
+    RESOLVE(PFNGLGETHISTOGRAMPARAMETERIVPROC, "glGetHistogramParameteriv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glMinmax( GLenum target, GLenum internalformat,
+				GLboolean sink )
+{
+    RESOLVE(PFNGLMINMAXPROC, "glMinmax");
+    proc(target, internalformat, sink);
+}
+
+GLAPI void GLAPIENTRY glResetMinmax( GLenum target )
+{
+    RESOLVE(PFNGLRESETMINMAXPROC, "glResetMinmax");
+    proc(target);
+}
+
+GLAPI void GLAPIENTRY glGetMinmax( GLenum target, GLboolean reset,
+                                   GLenum format, GLenum types,
+                                   GLvoid *values )
+{
+    RESOLVE(PFNGLGETMINMAXPROC, "glGetMinmax");
+    proc(target, reset, format, types, values);
+}
+
+GLAPI void GLAPIENTRY glGetMinmaxParameterfv( GLenum target, GLenum pname,
+					      GLfloat *params )
+{
+    RESOLVE(PFNGLGETMINMAXPARAMETERFVPROC, "glGetMinmaxParameterfv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glGetMinmaxParameteriv( GLenum target, GLenum pname,
+					      GLint *params )
+{
+    RESOLVE(PFNGLGETMINMAXPARAMETERIVPROC, "glGetMinmaxParameteriv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glConvolutionFilter1D( GLenum target,
+	GLenum internalformat, GLsizei width, GLenum format, GLenum type,
+	const GLvoid *image )
+{
+    RESOLVE(PFNGLCONVOLUTIONFILTER1DPROC, "glConvolutionFilter1D");
+    proc(target, internalformat, width, format, type, image);
+}
+
+GLAPI void GLAPIENTRY glConvolutionFilter2D( GLenum target,
+	GLenum internalformat, GLsizei width, GLsizei height, GLenum format,
+	GLenum type, const GLvoid *image )
+{
+    RESOLVE(PFNGLCONVOLUTIONFILTER2DPROC, "glConvolutionFilter2D");
+    proc(target, internalformat, width, height, format, type, image);
+}
+
+GLAPI void GLAPIENTRY glConvolutionParameterf( GLenum target, GLenum pname,
+	GLfloat params )
+{
+    RESOLVE(PFNGLCONVOLUTIONPARAMETERFPROC, "glConvolutionParameterf");
+    proc(target, pname, params); 
+}
+
+GLAPI void GLAPIENTRY glConvolutionParameterfv( GLenum target, GLenum pname,
+	const GLfloat *params )
+{
+    RESOLVE(PFNGLCONVOLUTIONPARAMETERFVPROC, "glConvolutionParameterfv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glConvolutionParameteri( GLenum target, GLenum pname,
+	GLint params )
+{
+    RESOLVE(PFNGLCONVOLUTIONPARAMETERIPROC, "glConvolutionParameteri");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glConvolutionParameteriv( GLenum target, GLenum pname,
+	const GLint *params )
+{
+    RESOLVE(PFNGLCONVOLUTIONPARAMETERIVPROC, "glConvolutionParameteriv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glCopyConvolutionFilter1D( GLenum target,
+	GLenum internalformat, GLint x, GLint y, GLsizei width )
+{
+    RESOLVE(PFNGLCOPYCONVOLUTIONFILTER1DPROC, "glCopyConvolutionFilter1D");
+    proc(target, internalformat, x, y, width);
+}
+
+GLAPI void GLAPIENTRY glCopyConvolutionFilter2D( GLenum target,
+	GLenum internalformat, GLint x, GLint y, GLsizei width,
+	GLsizei height)
+{
+    RESOLVE(PFNGLCOPYCONVOLUTIONFILTER2DPROC, "glCopyConvolutionFilter2D");
+    proc(target, internalformat, x, y, width, height);
+}
+
+GLAPI void GLAPIENTRY glGetConvolutionFilter( GLenum target, GLenum format,
+	GLenum type, GLvoid *image )
+{
+    RESOLVE(PFNGLGETCONVOLUTIONFILTERPROC, "glGetConvolutionFilter");
+    proc(target, format, type, image);
+}
+
+GLAPI void GLAPIENTRY glGetConvolutionParameterfv( GLenum target, GLenum pname,
+	GLfloat *params )
+{
+    RESOLVE(PFNGLGETCONVOLUTIONPARAMETERFVPROC, "glGetConvolutionParameterfv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glGetConvolutionParameteriv( GLenum target, GLenum pname,
+	GLint *params )
+{
+    RESOLVE(PFNGLGETCONVOLUTIONPARAMETERIVPROC, "glGetConvolutionParameteriv");
+    proc(target, pname, params);
+}
+
+GLAPI void GLAPIENTRY glSeparableFilter2D( GLenum target,
+	GLenum internalformat, GLsizei width, GLsizei height, GLenum format,
+	GLenum type, const GLvoid *row, const GLvoid *column )
+{
+    RESOLVE(PFNGLSEPARABLEFILTER2DPROC, "glSeparableFilter2D");
+    proc(target, internalformat, width, height, format, type, row, column);
+}
+
+GLAPI void GLAPIENTRY glGetSeparableFilter( GLenum target, GLenum format,
+	GLenum type, GLvoid *row, GLvoid *column, GLvoid *span )
+{
+    RESOLVE(PFNGLGETSEPARABLEFILTERPROC, "glGetSeparableFilter");
+    proc(target, format, type, row, column, span);
+}
+
+/*
+ * OpenGL 1.2
+ */
+
+GLAPI void GLAPIENTRY glTexImage3D( GLenum target, GLint level,
+                                      GLint internalFormat,
+                                      GLsizei width, GLsizei height,
+                                      GLsizei depth, GLint border,
+                                      GLenum format, GLenum type,
+                                      const GLvoid *pixels )
+{
+    RESOLVE(PFNGLTEXIMAGE3DPROC, "glTexImage3D");
+    proc(target, level, internalFormat, width, height, depth, border, format, type, pixels);
+}
+
+GLAPI void GLAPIENTRY glTexSubImage3D( GLenum target, GLint level,
+                                         GLint xoffset, GLint yoffset,
+                                         GLint zoffset, GLsizei width,
+                                         GLsizei height, GLsizei depth,
+                                         GLenum format,
+                                         GLenum type, const GLvoid *pixels)
+{
+    RESOLVE(PFNGLTEXSUBIMAGE3DPROC, "glTexSubImage3D");
+    proc(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+}
+
+GLAPI void GLAPIENTRY glCopyTexSubImage3D( GLenum target, GLint level,
+                                             GLint xoffset, GLint yoffset,
+                                             GLint zoffset, GLint x,
+                                             GLint y, GLsizei width,
+                                             GLsizei height )
+{
+    RESOLVE(PFNGLCOPYTEXSUBIMAGE3DPROC, "glCopyTexSubImage3D");
+    proc(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+}
+
+
+/*
+ * 20. GL_EXT_texture_object
+ */
+GLAPI void GLAPIENTRY glGenTexturesEXT( GLsizei n, GLuint *textures )
+{
+    glGenTextures(n, textures);
+}
+
+GLAPI void GLAPIENTRY glDeleteTexturesEXT( GLsizei n, const GLuint *textures)
+{
+    glDeleteTextures(n, textures);
+}
+
+GLAPI void GLAPIENTRY glBindTextureEXT( GLenum target, GLuint texture )
+{
+    glBindTexture(target, target);
+}
+
+GLAPI void GLAPIENTRY glPrioritizeTexturesEXT( GLsizei n, const GLuint *textures, const GLclampf *priorities )
+{
+    glPrioritizeTextures(n, textures, priorities);
+}
+
+GLAPI GLboolean GLAPIENTRY glAreTexturesResidentEXT( GLsizei n, const GLuint *textures, GLboolean *residences )
+{
+    return glAreTexturesResident(n, textures, residences);
+}
+
+GLAPI GLboolean GLAPIENTRY glIsTextureEXT( GLuint texture )
+{
+    return glIsTexture(texture); 
+}
+
+/*
+ * GL_ARB_multitexture (ARB extension 1 and OpenGL 1.2.1)
+ */
+
+GLAPI void GLAPIENTRY glActiveTextureARB(GLenum texture)
+{
+    RESOLVE(PFNGLACTIVETEXTUREARBPROC, "glActiveTextureARB");
+    proc(texture);
+}
+
+GLAPI void GLAPIENTRY glMultiTexCoord1dvARB(GLenum target, const GLdouble *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD1DVARBPROC, "glMultiTexCoord1dvARB");
+    proc(target, v);
+}
+
+GLAPI void GLAPIENTRY glMultiTexCoord1fvARB(GLenum target, const GLfloat *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD1FVARBPROC, "glMultiTexCoord1fvARB");
+    proc(target, v);
+}
+
+GLAPI void GLAPIENTRY glMultiTexCoord1ivARB(GLenum target, const GLint *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD1IVARBPROC, "glMultiTexCoord1ivARB");
+    proc(target, v);
+}
+
+GLAPI void GLAPIENTRY glMultiTexCoord1svARB(GLenum target, const GLshort *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD1SVARBPROC, "glMultiTexCoord1svARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord2dvARB(GLenum target, const GLdouble *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD2DVARBPROC, "glMultiTexCoord2dvARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord2fvARB(GLenum target, const GLfloat *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD2FVARBPROC, "glMultiTexCoord2fvARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord2ivARB(GLenum target, const GLint *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD2IVARBPROC, "glMultiTexCoord2ivARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord2svARB(GLenum target, const GLshort *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD1SVARBPROC, "glMultiTexCoord1svARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord3dvARB(GLenum target, const GLdouble *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD3DVARBPROC, "glMultiTexCoord3dvARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord3fvARB(GLenum target, const GLfloat *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD3FVARBPROC, "glMultiTexCoord3fvARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord3ivARB(GLenum target, const GLint *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD3IVARBPROC, "glMultiTexCoord3ivARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord3svARB(GLenum target, const GLshort *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD1SVARBPROC, "glMultiTexCoord1svARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord4dvARB(GLenum target, const GLdouble *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD4DVARBPROC, "glMultiTexCoord4dvARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord4fvARB(GLenum target, const GLfloat *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD4FVARBPROC, "glMultiTexCoord4fvARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord4ivARB(GLenum target, const GLint *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD4IVARBPROC, "glMultiTexCoord4ivARB");
+    proc(target, v);
+}
+GLAPI void GLAPIENTRY glMultiTexCoord4svARB(GLenum target, const GLshort *v)
+{
+    RESOLVE(PFNGLMULTITEXCOORD1SVARBPROC, "glMultiTexCoord1svARB");
+    proc(target, v);
+}
+
+
+GLAPI void GLAPIENTRY glActiveStencilFaceEXT(GLenum face)
+{
+    RESOLVE(PFNGLACTIVESTENCILFACEEXTPROC, "glActiveStencilFaceEXT");
+    proc(face);
+}
+
+GLAPI void APIENTRY glPointParameterfARB(GLenum pname, GLfloat param)
+{
+    RESOLVE(PFNGLPOINTPARAMETERFARBPROC, "glPointParameterfARB");
+    proc(pname, param);
+}
+
+GLAPI void APIENTRY glPointParameterfvARB(GLenum pname, const GLfloat *params)
+{
+    RESOLVE(PFNGLPOINTPARAMETERFVARBPROC, "glPointParameterfvARB");
+    proc(pname, params);
+}
+
+
+GLAPI void APIENTRY glWindowPos3fARB(GLfloat x, GLfloat y, GLfloat z)
+{
+    RESOLVE(PFNGLWINDOWPOS3FARBPROC, "glWindowPos3fARB");
+    proc(x, y, z);
+}
+
+GLAPI void APIENTRY glPointParameteri(GLenum pname, GLint param)
+{
+    RESOLVE(PFNGLPOINTPARAMETERIPROC, "glPointParameteri");
+    proc(pname, param);
+}
+
+GLAPI void APIENTRY glPointParameteriv(GLenum pname, const GLint *params)
+{
+    RESOLVE(PFNGLPOINTPARAMETERIVPROC, "glPointParameteriv");
+    proc(pname, params);
+}
+
+GLAPI void APIENTRY glPointParameteriNV(GLenum pname, GLint param)
+{
+    RESOLVE(PFNGLPOINTPARAMETERINVPROC, "glPointParameteriNV");
+    proc(pname, param);
+}
+
+GLAPI void APIENTRY glPointParameterivNV(GLenum pname, const GLint *params)
+{
+    RESOLVE(PFNGLPOINTPARAMETERIVNVPROC, "glPointParameterivNV");
+    proc(pname, params);
+}
+
+GLAPI void APIENTRY glSecondaryColor3bv(const GLbyte *v)
+{
+    RESOLVE(PFNGLSECONDARYCOLOR3BVPROC, "glSecondaryColor3bv");
+    proc(v);
+}
+GLAPI void APIENTRY glSecondaryColor3dv(const GLdouble *v)
+{
+    RESOLVE(PFNGLSECONDARYCOLOR3DVPROC, "glSecondaryColor3dv");
+    proc(v);
+}
+GLAPI void APIENTRY glSecondaryColor3fv(const GLfloat *v)
+{
+    RESOLVE(PFNGLSECONDARYCOLOR3FVPROC, "glSecondaryColor3fv");
+    proc(v);
+}
+GLAPI void APIENTRY glSecondaryColor3iv(const GLint *v)
+{
+    RESOLVE(PFNGLSECONDARYCOLOR3IVPROC, "glSecondaryColor3iv");
+    proc(v);
+}
+GLAPI void APIENTRY glSecondaryColor3sv(const GLshort *v)
+{
+    RESOLVE(PFNGLSECONDARYCOLOR3SVPROC, "glSecondaryColor3sv");
+    proc(v);
+}
+GLAPI void APIENTRY glSecondaryColor3ubv(const GLubyte *v)
+{
+    RESOLVE(PFNGLSECONDARYCOLOR3UBVPROC, "glSecondaryColor3ubv");
+    proc(v);
+}
+GLAPI void APIENTRY glSecondaryColor3uiv(const GLuint *v)
+{
+    RESOLVE(PFNGLSECONDARYCOLOR3UIVPROC, "glSecondaryColor3uiv");
+    proc(v);
+}
+GLAPI void APIENTRY glSecondaryColor3usv(const GLushort *v)
+{
+    RESOLVE(PFNGLSECONDARYCOLOR3USVPROC, "glSecondaryColor3usv");
+    proc(v);
+}
+GLAPI void APIENTRY glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+    RESOLVE(PFNGLSECONDARYCOLORPOINTERPROC, "glSecondaryColorPointer");
+    proc(size, type, stride, pointer);
+}
+
+
+GLAPI void APIENTRY glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+{
+    RESOLVE(PFNGLBLENDFUNCSEPARATEPROC, "glBlendFuncSeparate");
+    proc(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+}
+GLAPI void APIENTRY glFogCoordfv(const GLfloat *coord)
+{
+    RESOLVE(PFNGLFOGCOORDFVPROC, "glFogCoordfv");
+    proc(coord);
+}
+GLAPI void APIENTRY glFogCoorddv(const GLdouble *coord)
+{
+    RESOLVE(PFNGLFOGCOORDDVPROC, "glFogCoorddv");
+    proc(coord);
+}
+GLAPI void APIENTRY glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+    RESOLVE(PFNGLFOGCOORDPOINTERPROC, "glFogCoordPointer");
+    proc(type, stride, pointer);
+}
+
+
+GLAPI void APIENTRY glSampleCoverageARB(GLclampf value, GLboolean invert)
+{
+    RESOLVE(PFNGLSAMPLECOVERAGEARBPROC, "glSampleCoverageARB");
+    proc(value, invert);
+}
+GLAPI void APIENTRY glSampleMaskSGIS(GLclampf value, GLboolean invert)
+{
+    RESOLVE(PFNGLSAMPLEMASKSGISPROC, "glSampleMaskSGIS");
+    proc(value, invert);
+}
+GLAPI void APIENTRY glSamplePatternSGIS(GLenum pattern)
+{
+    RESOLVE(PFNGLSAMPLEPATTERNSGISPROC, "glSamplePatternSGIS");
+    proc(pattern);
+}
diff --git a/hw/xwin/glx/indirect.c b/hw/xwin/glx/indirect.c
new file mode 100755
index 000000000..5e12022f4
--- /dev/null
+++ b/hw/xwin/glx/indirect.c
@@ -0,0 +1,1605 @@
+/*
+ * GLX implementation that uses Windows OpenGL library
+ * (Indirect rendering path)
+ *
+ * Authors: Alexander Gottwald 
+ */
+/* 
+ * Portions of this file are copied from GL/apple/indirect.c,
+ * which contains the following copyright:
+ *  
+ * Copyright (c) 2002 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002 Apple Computer, Inc.
+ *
+ * Portions of this file are copied from xf86glx.c,
+ * which contains the following copyright:
+ *
+ * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name(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.
+ */
+
+
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "glwindows.h"
+#include <glcontextmodes.h>
+#include <stdint.h>
+
+#include <winpriv.h>
+
+#define GLWIN_DEBUG_HWND(hwnd)  \
+    if (glWinDebugSettings.dumpHWND) { \
+        char buffer[1024]; \
+        if (GetWindowText(hwnd, buffer, sizeof(buffer))==0) *buffer=0; \
+        GLWIN_DEBUG_MSG("Got HWND %s (%p)\n", buffer, hwnd); \
+    }
+
+
+/* ggs: needed to call back to glx with visual configs */
+extern void GlxSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs, void **configprivs);
+
+glWinDebugSettingsRec glWinDebugSettings = { 1, 0, 0, 0, 0};
+
+static void glWinInitDebugSettings(void) 
+{
+    char *envptr;
+
+    envptr = getenv("GLWIN_ENABLE_DEBUG");
+    if (envptr != NULL)
+        glWinDebugSettings.enableDebug = (atoi(envptr) == 1);
+
+    envptr = getenv("GLWIN_ENABLE_TRACE");
+    if (envptr != NULL)
+        glWinDebugSettings.enableTrace = (atoi(envptr) == 1);
+
+    envptr = getenv("GLWIN_DUMP_PFD");
+    if (envptr != NULL)
+        glWinDebugSettings.dumpPFD = (atoi(envptr) == 1);
+        
+    envptr = getenv("GLWIN_DUMP_HWND");
+    if (envptr != NULL)
+        glWinDebugSettings.dumpHWND = (atoi(envptr) == 1);
+
+    envptr = getenv("GLWIN_DUMP_DC");
+    if (envptr != NULL)
+        glWinDebugSettings.dumpDC = (atoi(envptr) == 1);
+}
+
+static char errorbuffer[1024];
+const char *glWinErrorMessage(void)
+{
+    if (!FormatMessage( 
+                FORMAT_MESSAGE_FROM_SYSTEM | 
+                FORMAT_MESSAGE_IGNORE_INSERTS,
+                NULL,
+                GetLastError(),
+                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                (LPTSTR) &errorbuffer,
+                sizeof(errorbuffer),
+                NULL ))
+    {
+        snprintf(errorbuffer, sizeof(errorbuffer), "Unknown error in FormatMessage: %08x!\n", (unsigned)GetLastError()); 
+    }
+    return errorbuffer; 
+}
+
+/*
+ * GLX implementation that uses Win32's OpenGL
+ */
+
+/*
+ * Server-side GLX uses these functions which are normally defined
+ * in the OpenGL SI.
+ */
+
+GLuint __glFloorLog2(GLuint val)
+{
+    int c = 0;
+
+    while (val > 1) {
+        c++;
+        val >>= 1;
+    }
+    return c;
+}
+
+/* some prototypes */
+static Bool glWinScreenProbe(int screen);
+static Bool glWinInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
+                              int *nvisualp, int *ndepthp,
+                              int *rootDepthp, VisualID *defaultVisp,
+                              unsigned long sizes, int bitsPerRGB);
+static void glWinSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
+                                   void **privates);
+static __GLinterface *glWinCreateContext(__GLimports *imports,
+                                          __GLcontextModes *mode,
+                                          __GLinterface *shareGC);
+static void glWinCreateBuffer(__GLXdrawablePrivate *glxPriv);
+static void glWinResetExtension(void);
+
+/*
+ * This structure is statically allocated in the __glXScreens[]
+ * structure.  This struct is not used anywhere other than in
+ * __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,
+ * and numUsableVisuals fields must be initialized.
+ */
+static __GLXscreenInfo __glDDXScreenInfo = {
+    glWinScreenProbe,   /* Must be generic and handle all screens */
+    glWinCreateContext, /* Substitute screen's createContext routine */
+    glWinCreateBuffer,  /* Substitute screen's createBuffer routine */
+    NULL,                 /* Set up pGlxVisual in probe */
+    NULL,                 /* Set up pVisualPriv in probe */
+    0,                    /* Set up numVisuals in probe */
+    0,                    /* Set up numUsableVisuals in probe */
+    "Vendor String",      /* GLXvendor is overwritten by __glXScreenInit */
+    "Version String",     /* GLXversion is overwritten by __glXScreenInit */
+    "Extensions String",  /* GLXextensions is overwritten by __glXScreenInit */
+    NULL                  /* WrappedPositionWindow is overwritten */
+};
+
+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);
+static GLboolean glWinLoseCurrent(__GLcontext *gc);
+static GLboolean glWinMakeCurrent(__GLcontext *gc);
+static GLboolean glWinShareContext(__GLcontext *gc, __GLcontext *gcShare);
+static GLboolean glWinCopyContext(__GLcontext *dst, const __GLcontext *src,
+                            GLuint mask);
+static GLboolean glWinForceCurrent(__GLcontext *gc);
+
+/* Drawing surface notification callbacks */
+static GLboolean glWinNotifyResize(__GLcontext *gc);
+static void glWinNotifyDestroy(__GLcontext *gc);
+static void glWinNotifySwapBuffers(__GLcontext *gc);
+
+/* Dispatch table override control for external agents like libGLS */
+static struct __GLdispatchStateRec* glWinDispatchExec(__GLcontext *gc);
+static void glWinBeginDispatchOverride(__GLcontext *gc);
+static void glWinEndDispatchOverride(__GLcontext *gc);
+
+/* Debug output */
+static void pfdOut(const PIXELFORMATDESCRIPTOR *pfd);
+
+static __GLexports glWinExports = {
+    glWinDestroyContext,
+    glWinLoseCurrent,
+    glWinMakeCurrent,
+    glWinShareContext,
+    glWinCopyContext,
+    glWinForceCurrent,
+
+    glWinNotifyResize,
+    glWinNotifyDestroy,
+    glWinNotifySwapBuffers,
+
+    glWinDispatchExec,
+    glWinBeginDispatchOverride,
+    glWinEndDispatchOverride
+};
+
+glWinScreenRec glWinScreens[MAXSCREENS];
+
+/* __GLdrawablePrivate->private */
+typedef struct {
+    DrawablePtr pDraw;
+  /*    xp_surface_id sid; */
+} GLWinDrawableRec;
+
+struct __GLcontextRec {
+  struct __GLinterfaceRec interface; /* required to be first */
+
+  HGLRC ctx;                         /* Windows GL Context */
+  
+  HDC dc;                            /* Windows Device Context */
+  winWindowInfoRec winInfo;          /* Window info from XWin */
+  
+  PIXELFORMATDESCRIPTOR pfd;         /* Pixelformat flags */
+  int pixelFormat;                   /* Pixelformat index */
+
+  unsigned isAttached :1;            /* Flag to track if context is attached */
+};
+
+static HDC glWinMakeDC(__GLcontext *gc)
+{
+    HDC dc;
+
+    /*if (gc->winInfo.hrgn == NULL) 
+    {
+        GLWIN_DEBUG_MSG("Creating region from RECT(%ld,%ld,%ld,%ld):",
+                gc->winInfo.rect.left,
+                gc->winInfo.rect.top,
+                gc->winInfo.rect.right,
+                gc->winInfo.rect.bottom);
+        gc->winInfo.hrgn = CreateRectRgnIndirect(&gc->winInfo.rect);
+        GLWIN_DEBUG_MSG2("%p\n", gc->winInfo.hrgn);
+    }*/
+
+    if (glWinDebugSettings.enableTrace)
+        GLWIN_DEBUG_HWND(gc->winInfo.hwnd);
+
+    dc = GetDC(gc->winInfo.hwnd); 
+    /*dc = GetDCEx(gc->winInfo.hwnd, gc->winInfo.hrgn, 
+            DCX_WINDOW | DCX_NORESETATTRS ); */
+
+    if (dc == NULL)
+        ErrorF("GetDC error: %s\n", glWinErrorMessage());
+    return dc;
+}
+
+static void unattach(__GLcontext *gc)
+{
+    BOOL ret;
+    GLWIN_DEBUG_MSG("unattach (ctx %p)\n", gc->ctx);
+    if (!gc->isAttached) 
+    {
+        ErrorF("called unattach on an unattached context\n");
+        return;
+    }
+
+    if (gc->ctx) 
+    {
+        ret = wglDeleteContext(gc->ctx);
+        if (!ret)
+            ErrorF("wglDeleteContext error: %s\n", glWinErrorMessage());
+        gc->ctx = NULL;
+    }
+
+    if (gc->winInfo.hrgn)
+    {
+        ret = DeleteObject(gc->winInfo.hrgn);
+        if (!ret)
+            ErrorF("DeleteObject error: %s\n", glWinErrorMessage());
+        gc->winInfo.hrgn = NULL;
+    }
+
+    gc->isAttached = 0;
+}
+
+static BOOL glWinAdjustHWND(__GLcontext *gc, WindowPtr pWin)
+{
+    HDC dc;
+    BOOL ret;
+    HGLRC newctx;
+    HWND oldhwnd;
+
+    GLWIN_DEBUG_MSG("glWinAdjustHWND (ctx %p, pWin %p)\n", gc->ctx, pWin);
+
+    if (pWin == NULL)
+    {
+        GLWIN_DEBUG_MSG("Deferring until window is created\n");
+        return FALSE;
+    }
+
+    oldhwnd = gc->winInfo.hwnd;
+    winGetWindowInfo(pWin, &gc->winInfo);
+    
+    GLWIN_DEBUG_HWND(gc->winInfo.hwnd);
+    if (gc->winInfo.hwnd == NULL)
+    {
+        GLWIN_DEBUG_MSG("Deferring until window is created\n");
+        return FALSE;
+    }
+
+    dc = glWinMakeDC(gc);
+    
+    if (glWinDebugSettings.dumpDC)
+        GLWIN_DEBUG_MSG("Got HDC %p\n", dc);
+    
+    gc->pixelFormat = ChoosePixelFormat(dc, &gc->pfd);
+    if (gc->pixelFormat == 0)
+    {
+        ErrorF("ChoosePixelFormat error: %s\n", glWinErrorMessage());
+        ReleaseDC(gc->winInfo.hwnd, dc);
+        return FALSE;  
+    }
+    
+    ret = SetPixelFormat(dc, gc->pixelFormat, &gc->pfd);
+    if (!ret) {
+        ErrorF("SetPixelFormat error: %s\n", glWinErrorMessage());
+        ReleaseDC(gc->winInfo.hwnd, dc);
+        return FALSE;
+    }
+    
+    newctx = wglCreateContext(dc);
+    if (newctx == NULL) {
+        ErrorF("wglCreateContext error: %s\n", glWinErrorMessage());
+        ReleaseDC(gc->winInfo.hwnd, dc);
+        return FALSE;
+    }
+    
+    GLWIN_DEBUG_MSG("wglCreateContext (ctx %p)\n", newctx);
+
+    if (!wglShareLists(gc->ctx, newctx))
+    {
+        ErrorF("wglShareLists error: %s\n", glWinErrorMessage());
+        ReleaseDC(gc->winInfo.hwnd, dc);
+        return FALSE;
+    }
+    
+    if (oldhwnd != gc->winInfo.hwnd)
+    {
+        GLWIN_DEBUG_MSG("Trying wglCopyContext\n");
+        if (!wglCopyContext(gc->ctx, newctx, GL_ALL_ATTRIB_BITS))
+        {
+            ErrorF("wglCopyContext error: %s\n", glWinErrorMessage());
+            ReleaseDC(gc->winInfo.hwnd, dc);
+            return FALSE;
+        }
+    }
+
+    if (!wglDeleteContext(gc->ctx))
+    {
+        ErrorF("wglDeleteContext error: %s\n", glWinErrorMessage());
+    }
+
+    gc->ctx = newctx;
+
+    if (!wglMakeCurrent(dc, gc->ctx)) {
+        ErrorF("glMakeCurrent error: %s\n", glWinErrorMessage());
+        ReleaseDC(gc->winInfo.hwnd, dc);
+        return FALSE;
+    }
+
+    ReleaseDC(gc->winInfo.hwnd, dc);
+
+    return TRUE;
+}
+
+static BOOL glWinCreateContextReal(__GLcontext *gc, WindowPtr pWin)
+{
+    HDC dc;
+    BOOL ret;
+
+    GLWIN_DEBUG_MSG("glWinCreateContextReal (pWin %p)\n", pWin);
+
+    if (pWin == NULL)
+    {
+        GLWIN_DEBUG_MSG("Deferring until window is created\n");
+        return FALSE;
+    }
+
+    winGetWindowInfo(pWin, &gc->winInfo);
+    
+    GLWIN_DEBUG_HWND(gc->winInfo.hwnd);
+    if (gc->winInfo.hwnd == NULL)
+    {
+        GLWIN_DEBUG_MSG("Deferring until window is created\n");
+        return FALSE;
+    }
+
+    
+    dc = glWinMakeDC(gc);
+    
+    if (glWinDebugSettings.dumpDC)
+        GLWIN_DEBUG_MSG("Got HDC %p\n", dc);
+    
+    gc->pixelFormat = ChoosePixelFormat(dc, &gc->pfd);
+    if (gc->pixelFormat == 0)
+    {
+        ErrorF("ChoosePixelFormat error: %s\n", glWinErrorMessage());
+        ReleaseDC(gc->winInfo.hwnd, dc);
+        return FALSE;  
+    }
+    
+    ret = SetPixelFormat(dc, gc->pixelFormat, &gc->pfd);
+    if (!ret) {
+        ErrorF("SetPixelFormat error: %s\n", glWinErrorMessage());
+        ReleaseDC(gc->winInfo.hwnd, dc);
+        return FALSE;
+    }
+    
+    gc->ctx = wglCreateContext(dc);
+    if (gc->ctx == NULL) {
+        ErrorF("wglCreateContext error: %s\n", glWinErrorMessage());
+        ReleaseDC(gc->winInfo.hwnd, dc);
+        return FALSE;
+    }
+
+    GLWIN_DEBUG_MSG("glWinCreateContextReal (ctx %p)\n", gc->ctx);
+
+    if (!wglMakeCurrent(dc, gc->ctx)) {
+        ErrorF("glMakeCurrent error: %s\n", glWinErrorMessage());
+        ReleaseDC(gc->winInfo.hwnd, dc);
+        return FALSE;
+    }
+
+    ReleaseDC(gc->winInfo.hwnd, dc);
+
+    return TRUE;
+}
+
+static void attach(__GLcontext *gc, __GLdrawablePrivate *glPriv)
+{
+    __GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *)glPriv->other;
+
+    GLWIN_DEBUG_MSG("attach (ctx %p)\n", gc->ctx);
+
+    if (gc->isAttached)
+    {
+        ErrorF("called attach on an attached context\n");
+        return;
+    }
+
+    if (glxPriv->type == DRAWABLE_WINDOW)
+    {
+        WindowPtr pWin = (WindowPtr) glxPriv->pDraw;
+        if (pWin == NULL)
+        {
+            GLWIN_DEBUG_MSG("Deferring ChoosePixelFormat until window is created\n");
+        } else
+        {
+            if (glWinCreateContextReal(gc, pWin))
+            {
+                gc->isAttached = TRUE;
+                GLWIN_DEBUG_MSG("attached\n");
+            }
+        }
+    }
+}
+
+static GLboolean glWinLoseCurrent(__GLcontext *gc)
+{
+    GLWIN_TRACE_MSG("glWinLoseCurrent (ctx %p)\n", gc->ctx);
+
+    __glXLastContext = NULL; /* Mesa does this; why? */
+
+    return GL_TRUE;
+}
+
+/* Context manipulation; return GL_FALSE on failure */
+static GLboolean glWinDestroyContext(__GLcontext *gc)
+{
+    GLWIN_DEBUG_MSG("glWinDestroyContext (ctx %p)\n", gc->ctx);
+
+    if (gc != NULL)
+    {
+        if (gc->isAttached)
+            unattach(gc);
+        if (gc->dc != NULL)
+            DeleteDC(gc->dc);
+        free(gc);
+    }
+
+    return GL_TRUE;
+}
+
+static GLboolean glWinMakeCurrent(__GLcontext *gc)
+{
+    __GLdrawablePrivate *glPriv = gc->interface.imports.getDrawablePrivate(gc);
+    BOOL ret;
+    HDC dc;
+
+    GLWIN_TRACE_MSG(" (ctx %p)\n", gc->ctx);
+
+    if (!gc->isAttached)
+        attach(gc, glPriv);
+
+    if (gc->ctx == NULL) {
+        ErrorF("Context is NULL\n");
+        return GL_FALSE;
+    }
+
+    dc = glWinMakeDC(gc);
+    ret = wglMakeCurrent(dc, gc->ctx);
+    if (!ret)
+        ErrorF("glMakeCurrent error: %s\n", glWinErrorMessage());
+    ReleaseDC(gc->winInfo.hwnd, dc);
+
+    return ret?GL_TRUE:GL_FALSE;
+}
+
+static GLboolean glWinShareContext(__GLcontext *gc, __GLcontext *gcShare)
+{
+  GLWIN_DEBUG_MSG("glWinShareContext unimplemented\n");
+
+  return GL_TRUE;
+}
+
+static GLboolean glWinCopyContext(__GLcontext *dst, const __GLcontext *src,
+                                   GLuint mask)
+{
+    BOOL ret;
+
+    GLWIN_DEBUG_MSG("glWinCopyContext\n");
+    
+    ret = wglCopyContext(src->ctx, dst->ctx, mask);
+    if (!ret) 
+    {
+        ErrorF("wglCopyContext error: %s\n", glWinErrorMessage());
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+static GLboolean glWinForceCurrent(__GLcontext *gc)
+{
+    GLWIN_TRACE_MSG(" (ctx %p)\n", gc->ctx);
+
+    return GL_TRUE;
+}
+
+/* Drawing surface notification callbacks */
+
+static GLboolean glWinNotifyResize(__GLcontext *gc)
+{
+    GLWIN_DEBUG_MSG("unimplemented glWinNotifyResize");
+    return GL_TRUE;
+}
+
+static void glWinNotifyDestroy(__GLcontext *gc)
+{
+    GLWIN_DEBUG_MSG("unimplemented glWinNotifyDestroy");
+}
+
+static void glWinNotifySwapBuffers(__GLcontext *gc)
+{
+    GLWIN_DEBUG_MSG("unimplemented glWinNotifySwapBuffers");
+}
+
+/* Dispatch table override control for external agents like libGLS */
+static struct __GLdispatchStateRec* glWinDispatchExec(__GLcontext *gc)
+{
+    GLWIN_DEBUG_MSG("unimplemented glWinDispatchExec");
+    return NULL;
+}
+
+static void glWinBeginDispatchOverride(__GLcontext *gc)
+{
+    GLWIN_DEBUG_MSG("unimplemented glWinBeginDispatchOverride");
+}
+
+static void glWinEndDispatchOverride(__GLcontext *gc)
+{
+    GLWIN_DEBUG_MSG("unimplemented glWinEndDispatchOverride");
+}
+
+#define DUMP_PFD_FLAG(flag) \
+    if (pfd->dwFlags & flag) { \
+        ErrorF("%s%s", pipesym, #flag); \
+        pipesym = " | "; \
+    }
+        
+static void pfdOut(const PIXELFORMATDESCRIPTOR *pfd)
+{
+    const char *pipesym = ""; /* will be set after first flag dump */
+    ErrorF("PIXELFORMATDESCRIPTOR:\n");
+    ErrorF("nSize = %u\n", pfd->nSize);
+    ErrorF("nVersion = %u\n", pfd->nVersion);
+    ErrorF("dwFlags = %lu = {", pfd->dwFlags);
+        DUMP_PFD_FLAG(PFD_MAIN_PLANE);
+        DUMP_PFD_FLAG(PFD_OVERLAY_PLANE);
+        DUMP_PFD_FLAG(PFD_UNDERLAY_PLANE);
+        DUMP_PFD_FLAG(PFD_DOUBLEBUFFER);
+        DUMP_PFD_FLAG(PFD_STEREO);
+        DUMP_PFD_FLAG(PFD_DRAW_TO_WINDOW);
+        DUMP_PFD_FLAG(PFD_DRAW_TO_BITMAP);
+        DUMP_PFD_FLAG(PFD_SUPPORT_GDI);
+        DUMP_PFD_FLAG(PFD_SUPPORT_OPENGL);
+        DUMP_PFD_FLAG(PFD_GENERIC_FORMAT);
+        DUMP_PFD_FLAG(PFD_NEED_PALETTE);
+        DUMP_PFD_FLAG(PFD_NEED_SYSTEM_PALETTE);
+        DUMP_PFD_FLAG(PFD_SWAP_EXCHANGE);
+        DUMP_PFD_FLAG(PFD_SWAP_COPY);
+        DUMP_PFD_FLAG(PFD_SWAP_LAYER_BUFFERS);
+        DUMP_PFD_FLAG(PFD_GENERIC_ACCELERATED);
+        DUMP_PFD_FLAG(PFD_DEPTH_DONTCARE);
+        DUMP_PFD_FLAG(PFD_DOUBLEBUFFER_DONTCARE);
+        DUMP_PFD_FLAG(PFD_STEREO_DONTCARE);
+    ErrorF("}\n");
+    
+    ErrorF("iPixelType = %hu = %s\n", pfd->iPixelType, 
+            (pfd->iPixelType == PFD_TYPE_RGBA ? "PFD_TYPE_RGBA" : "PFD_TYPE_COLORINDEX"));
+    ErrorF("cColorBits = %hhu\n", pfd->cColorBits);
+    ErrorF("cRedBits = %hhu\n", pfd->cRedBits);
+    ErrorF("cRedShift = %hhu\n", pfd->cRedShift);
+    ErrorF("cGreenBits = %hhu\n", pfd->cGreenBits);
+    ErrorF("cGreenShift = %hhu\n", pfd->cGreenShift);
+    ErrorF("cBlueBits = %hhu\n", pfd->cBlueBits);
+    ErrorF("cBlueShift = %hhu\n", pfd->cBlueShift);
+    ErrorF("cAlphaBits = %hhu\n", pfd->cAlphaBits);
+    ErrorF("cAlphaShift = %hhu\n", pfd->cAlphaShift);
+    ErrorF("cAccumBits = %hhu\n", pfd->cAccumBits);
+    ErrorF("cAccumRedBits = %hhu\n", pfd->cAccumRedBits);
+    ErrorF("cAccumGreenBits = %hhu\n", pfd->cAccumGreenBits);
+    ErrorF("cAccumBlueBits = %hhu\n", pfd->cAccumBlueBits);
+    ErrorF("cAccumAlphaBits = %hhu\n", pfd->cAccumAlphaBits);
+    ErrorF("cDepthBits = %hhu\n", pfd->cDepthBits);
+    ErrorF("cStencilBits = %hhu\n", pfd->cStencilBits);
+    ErrorF("cAuxBuffers = %hhu\n", pfd->cAuxBuffers);
+    ErrorF("iLayerType = %hhu\n", pfd->iLayerType);
+    ErrorF("bReserved = %hhu\n", pfd->bReserved);
+    ErrorF("dwLayerMask = %lu\n", pfd->dwLayerMask);
+    ErrorF("dwVisibleMask = %lu\n", pfd->dwVisibleMask);
+    ErrorF("dwDamageMask = %lu\n", pfd->dwDamageMask);
+    ErrorF("\n");
+}    
+
+static int makeFormat(__GLcontextModes *mode, PIXELFORMATDESCRIPTOR *pfdret)
+{
+    PIXELFORMATDESCRIPTOR pfd = {
+      sizeof(PIXELFORMATDESCRIPTOR),   /* size of this pfd */
+      1,                     /* version number */
+      PFD_DRAW_TO_WINDOW |   /* support window */
+      PFD_SUPPORT_OPENGL,    /* support OpenGL */
+      PFD_TYPE_RGBA,         /* RGBA type */
+      24,                    /* 24-bit color depth */
+      0, 0, 0, 0, 0, 0,      /* color bits ignored */
+      0,                     /* no alpha buffer */
+      0,                     /* shift bit ignored */
+      0,                     /* no accumulation buffer */
+      0, 0, 0, 0,            /* accum bits ignored */
+      0,                     /* 32-bit z-buffer */
+      0,                     /* no stencil buffer */
+      0,                     /* no auxiliary buffer */
+      PFD_MAIN_PLANE,        /* main layer */
+      0,                     /* reserved */
+      0, 0, 0                /* layer masks ignored */
+    }, *result = &pfd;
+
+    /* disable anything but rgba. must get rgba to work first */
+    if (!mode->rgbMode) 
+        return -1; 
+    
+    if (mode->stereoMode) {
+        result->dwFlags |= PFD_STEREO;
+    }
+    if (mode->doubleBufferMode) {
+        result->dwFlags |= PFD_DOUBLEBUFFER;
+    }
+
+    if (mode->colorIndexMode) {
+        /* ignored, see above */
+        result->iPixelType = PFD_TYPE_COLORINDEX; 
+        result->cColorBits = mode->redBits + mode->greenBits + mode->blueBits;
+        result->cRedBits = mode->redBits;
+        result->cRedShift = 0; /* FIXME */
+        result->cGreenBits = mode->greenBits;
+        result->cGreenShift = 0; /* FIXME  */
+        result->cBlueBits = mode->blueBits;
+        result->cBlueShift = 0; /* FIXME */
+        result->cAlphaBits = mode->alphaBits;
+        result->cAlphaShift = 0; /* FIXME */
+    }
+
+    if (mode->rgbMode) {
+        result->iPixelType = PFD_TYPE_RGBA;
+        result->cColorBits = mode->redBits + mode->greenBits + mode->blueBits;
+        result->cRedBits = mode->redBits;
+        result->cRedShift = 0; /* FIXME */
+        result->cGreenBits = mode->greenBits;
+        result->cGreenShift = 0; /* FIXME  */
+        result->cBlueBits = mode->blueBits;
+        result->cBlueShift = 0; /* FIXME */
+        result->cAlphaBits = mode->alphaBits;
+        result->cAlphaShift = 0; /* FIXME */
+    }
+
+    if (mode->haveAccumBuffer) {
+        result->cAccumBits = mode->accumRedBits + mode->accumGreenBits
+            + mode->accumBlueBits + mode->accumAlphaBits;
+        result->cAccumRedBits = mode->accumRedBits;
+        result->cAccumGreenBits = mode->accumGreenBits;
+        result->cAccumBlueBits = mode->accumBlueBits;
+        result->cAccumAlphaBits = mode->accumAlphaBits;
+    }
+    
+    if (mode->haveDepthBuffer) {
+        result->cDepthBits = mode->depthBits;
+    }
+    if (mode->haveStencilBuffer) {
+        result->cStencilBits = mode->stencilBits;
+    }
+
+    /* result->cAuxBuffers = mode->numAuxBuffers; */
+
+    /* mode->level ignored */
+
+    /* mode->pixmapMode ? */
+
+    *pfdret = pfd;
+
+    return 0;
+}
+
+static __GLinterface *glWinCreateContext(__GLimports *imports,
+                                          __GLcontextModes *mode,
+                                          __GLinterface *shareGC)
+{
+    __GLcontext *result;
+
+    GLWIN_DEBUG_MSG("glWinCreateContext\n");
+
+    result = (__GLcontext *)calloc(1, sizeof(__GLcontext));
+    if (!result) 
+        return NULL;
+
+    result->interface.imports = *imports;
+    result->interface.exports = glWinExports;
+
+    if (makeFormat(mode, &result->pfd))
+    {
+        ErrorF("makeFormat failed\n");
+        free(result);
+        return NULL;
+    }
+
+    if (glWinDebugSettings.dumpPFD)
+        pfdOut(&result->pfd);
+
+    GLWIN_DEBUG_MSG("glWinCreateContext done\n");
+    return (__GLinterface *)result;
+}
+
+Bool
+glWinRealizeWindow(WindowPtr pWin)
+{
+    /* If this window has GL contexts, tell them to reattach */
+    /* reattaching is bad: display lists and parameters get lost */
+    Bool result;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    glWinScreenRec *screenPriv = &glWinScreens[pScreen->myNum];
+    __GLXdrawablePrivate *glxPriv;
+
+    GLWIN_DEBUG_MSG("glWinRealizeWindow\n");
+
+    /* Allow the window to be created (RootlessRealizeWindow is inside our wrap) */
+    pScreen->RealizeWindow = screenPriv->RealizeWindow;
+    result = pScreen->RealizeWindow(pWin);
+    pScreen->RealizeWindow = glWinRealizeWindow;
+
+    /* Re-attach this window's GL contexts, if any. */
+    glxPriv = __glXFindDrawablePrivate(pWin->drawable.id);
+    if (glxPriv) {
+        __GLXcontext *gx;
+        __GLcontext *gc;
+        __GLdrawablePrivate *glPriv = &glxPriv->glPriv;
+        GLWIN_DEBUG_MSG("glWinRealizeWindow is GL drawable!\n");
+
+        /* GL contexts bound to this window for drawing */
+        for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->next) {
+            gc = (__GLcontext *)gx->gc;
+            if (gc->isAttached)
+#if 1
+            {
+                GLWIN_DEBUG_MSG("context is already bound! Adjusting HWND.\n");
+                glWinAdjustHWND(gc, pWin);
+                continue;
+            }
+#else
+                unattach(gc);
+#endif
+            attach(gc, glPriv);
+        }
+
+        /* GL contexts bound to this window for reading */
+        for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->next) {
+            gc = (__GLcontext *)gx->gc;
+            if (gc->isAttached)
+#if 1
+            {
+                GLWIN_DEBUG_MSG("context is already bound! Adjusting HWND.\n");
+                glWinAdjustHWND(gc, pWin);
+                continue;
+            }
+#else
+                unattach(gc);
+#endif
+            attach(gc, glPriv);
+        }
+    }
+
+    return result;
+}
+
+
+void 
+glWinCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
+{
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+    glWinScreenRec *screenPriv = &glWinScreens[pScreen->myNum];
+    __GLXdrawablePrivate *glxPriv;
+    
+    GLWIN_TRACE_MSG(" (pWindow %p)\n", pWindow);
+    
+    /* Check if the window is attached and discard any drawing request */
+    glxPriv = __glXFindDrawablePrivate(pWindow->drawable.id);
+    if (glxPriv) {
+        __GLXcontext *gx;
+
+        /* GL contexts bound to this window for drawing */
+        for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->next) {
+/*            
+            GLWIN_DEBUG_MSG("glWinCopyWindow - calling glDrawBuffer\n");
+            glDrawBuffer(GL_FRONT);
+ */           
+ 
+            return;
+        }
+
+        /* GL contexts bound to this window for reading */
+        for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->next) {
+            return;
+        }
+    }
+
+    GLWIN_DEBUG_MSG("glWinCopyWindow - passing to hw layer\n");
+
+    pScreen->CopyWindow = screenPriv->CopyWindow;
+    pScreen->CopyWindow(pWindow, ptOldOrg, prgnSrc);
+    pScreen->CopyWindow = glWinCopyWindow;
+}
+
+Bool
+glWinUnrealizeWindow(WindowPtr pWin)
+{
+    /* If this window has GL contexts, tell them to unattach */
+    Bool result;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    glWinScreenRec *screenPriv = &glWinScreens[pScreen->myNum];
+    __GLXdrawablePrivate *glxPriv;
+
+    GLWIN_DEBUG_MSG("glWinUnrealizeWindow\n");
+
+    /* The Aqua window may have already been destroyed (windows
+     * are unrealized from top down)
+     */
+    
+    /* Unattach this window's GL contexts, if any. */
+    glxPriv = __glXFindDrawablePrivate(pWin->drawable.id);
+    if (glxPriv) {
+        __GLXcontext *gx;
+        __GLcontext *gc;
+        GLWIN_DEBUG_MSG("glWinUnealizeWindow is GL drawable!\n");
+
+        /* GL contexts bound to this window for drawing */
+        for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->next) {
+            gc = (__GLcontext *)gx->gc;
+            unattach(gc);
+        }
+
+        /* GL contexts bound to this window for reading */
+        for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->next) {
+            gc = (__GLcontext *)gx->gc;
+            unattach(gc);
+        }
+    }
+
+    pScreen->UnrealizeWindow = screenPriv->UnrealizeWindow;
+    result = pScreen->UnrealizeWindow(pWin);
+    pScreen->UnrealizeWindow = glWinUnrealizeWindow;
+
+    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
+static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
+  {
+    -1,                 /* vid */
+    -1,                 /* class */
+    True,               /* rgba */
+    -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_EXT,       /* visualRating */
+    0,                  /* transparentPixel */
+    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
+    0                   /* transparentIndex */
+  },
+  {
+    -1,                 /* vid */
+    -1,                 /* class */
+    True,               /* rgba */
+    -1, -1, -1, 0,      /* rgba sizes */
+    -1, -1, -1, 0,      /* rgba masks */
+    16, 16, 16, 0,      /* rgba accum sizes */
+    True,               /* doubleBuffer */
+    False,              /* stereo */
+    -1,                 /* bufferSize */
+    16,                 /* depthSize */
+    8,                  /* 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 __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);
+    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+    x = (x + (x >> 4)) & 0x0f0f0f0f;
+    x = x + (x >> 8);
+    x = x + (x >> 16);
+    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)
+{
+    int numRGBconfigs;
+    int numCIconfigs;
+    int numVisuals = *nvisualp;
+    int numNewVisuals;
+    int numNewConfigs;
+    VisualPtr pVisual = *visualp;
+    VisualPtr pVisualNew = NULL;
+    VisualID *orig_vid = NULL;
+    __GLcontextModes *modes = NULL;
+    __GLXvisualConfig *pNewVisualConfigs = NULL;
+    void **glXVisualPriv;
+    void **pNewVisualPriv;
+    int found_default;
+    int i, j, k;
+
+    GLWIN_DEBUG_MSG("init_visuals\n");
+
+    if (numConfigs > 0)
+        numNewConfigs = numConfigs;
+    else
+        numNewConfigs = NUM_FALLBACK_CONFIGS;
+
+    /* Alloc space for the list of new GLX visuals */
+    pNewVisualConfigs = (__GLXvisualConfig *)
+                     __glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig));
+    if (!pNewVisualConfigs) {
+        return FALSE;
+    }
+
+    /* Alloc space for the list of new GLX visual privates */
+    pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *));
+    if (!pNewVisualPriv) {
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
+    }
+
+    /*
+    ** If SetVisualConfigs was not called, then use default GLX
+    ** visual configs.
+    */
+    if (numConfigs == 0) {
+        memcpy(pNewVisualConfigs, FallbackConfigs,
+               NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig));
+        memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
+    }
+    else {
+        /* copy driver's visual config info */
+        for (i = 0; i < numConfigs; i++) {
+            pNewVisualConfigs[i] = visualConfigs[i];
+            pNewVisualPriv[i] = visualPrivates[i];
+        }
+    }
+
+    /* Count the number of RGB and CI visual configs */
+    numRGBconfigs = 0;
+    numCIconfigs = 0;
+    for (i = 0; i < numNewConfigs; i++) {
+        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;
+
+        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 */
+    visualConfigs = NULL;
+    numConfigs = 0;
+
+    /* 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;
+    }
+
+    /* Alloc space for the list of glXVisuals */
+    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) {
+        _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);
+        _gl_context_modes_destroy( modes );
+        __glXFree(orig_vid);
+        __glXFree(pNewVisualPriv);
+        __glXFree(pNewVisualConfigs);
+        return FALSE;
+    }
+
+    /* 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 (!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 */
+    glWinScreens[screenInfo.numScreens-1].num_vis = numNewVisuals;
+    glWinScreens[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;
+    }
+
+    /* Update the X server's visuals */
+    *nvisualp = numNewVisuals;
+    *visualp = pVisualNew;
+
+    /* Free the old list of the X server's visuals */
+    __glXFree(pVisual);
+
+    /* Clean up temporary allocations */
+    __glXFree(orig_vid);
+    __glXFree(pNewVisualPriv);
+    __glXFree(pNewVisualConfigs);
+
+    /* Free the private list created by DDX HW driver */
+    if (visualPrivates)
+        xfree(visualPrivates);
+    visualPrivates = NULL;
+
+    return TRUE;
+}
+
+
+static void fixup_visuals(int screen)
+{
+    ScreenPtr pScreen = screenInfo.screens[screen];
+    glWinScreenRec *pScr = &glWinScreens[screen];
+    __GLcontextModes *modes;
+    int j;
+
+    GLWIN_DEBUG_MSG("fixup_visuals\n");
+
+    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++) {
+            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];
+    __GLcontextModes *modes;
+    int *used;
+    int i, j;
+
+    GLWIN_DEBUG_MSG("init_screen_visuals\n");
+
+    used = (int *)__glXMalloc(pScreen->numVisuals * sizeof(int));
+    __glXMemset(used, 0, pScreen->numVisuals * sizeof(int));
+
+    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 0
+                /* 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;
+
+                /* 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);
+
+    /* glWinScreens[screen].xm_vis = pXMesaVisual; */
+}
+
+static Bool glWinScreenProbe(int screen)
+{
+    ScreenPtr pScreen;
+    glWinScreenRec *screenPriv;
+
+    GLWIN_DEBUG_MSG("glWinScreenProbe\n");
+
+    /*
+     * Set up the current screen's visuals.
+     */
+    __glDDXScreenInfo.modes = glWinScreens[screen].modes;
+    __glDDXScreenInfo.pVisualPriv = glWinScreens[screen].priv;
+    __glDDXScreenInfo.numVisuals =
+        __glDDXScreenInfo.numUsableVisuals = glWinScreens[screen].num_vis;
+
+    /*
+     * Set the current screen's createContext routine.  This could be
+     * wrapped by a DDX GLX context creation routine.
+     */
+    __glDDXScreenInfo.createContext = glWinCreateContext;
+
+    /*
+     * The ordering of the rgb compenents might have been changed by the
+     * driver after mi initialized them.
+     */
+    fixup_visuals(screen);
+
+    /*
+     * Find the GLX visuals that are supported by this screen and create
+     * XMesa's visuals.
+     */
+    init_screen_visuals(screen);
+
+    /* Wrap RealizeWindow and UnrealizeWindow on this screen */
+    pScreen = screenInfo.screens[screen];
+    screenPriv = &glWinScreens[screen];
+    screenPriv->RealizeWindow = pScreen->RealizeWindow;
+    pScreen->RealizeWindow = glWinRealizeWindow;
+    screenPriv->UnrealizeWindow = pScreen->UnrealizeWindow;
+    pScreen->UnrealizeWindow = glWinUnrealizeWindow;
+    screenPriv->CopyWindow = pScreen->CopyWindow;
+    pScreen->CopyWindow = glWinCopyWindow;
+
+    return TRUE;
+}
+
+static GLboolean glWinSwapBuffers(__GLXdrawablePrivate *glxPriv)
+{
+  /* swap buffers on only *one* of the contexts
+   * (e.g. the last one for drawing)
+   */
+    __GLcontext *gc = (__GLcontext *)glxPriv->drawGlxc->gc;
+    HDC dc;
+    BOOL ret;
+
+    GLWIN_TRACE_MSG("glWinSwapBuffers (ctx %p)\n", (gc!=NULL?gc->ctx:NULL));
+
+    if (gc != NULL && gc->ctx != NULL)
+    {
+        dc = glWinMakeDC(gc);
+        if (dc == NULL)
+            return GL_FALSE;
+
+        ret = SwapBuffers(dc);
+        if (!ret)
+            ErrorF("SwapBuffers failed: %s\n", glWinErrorMessage());
+        
+        ReleaseDC(gc->winInfo.hwnd, dc);
+        if (!ret)
+            return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+static void glWinDestroyDrawablePrivate(__GLdrawablePrivate *glPriv)
+{
+    GLWIN_DEBUG_MSG("glWinDestroyDrawablePrivate\n");
+
+    /* It doesn't work to call DRIDestroySurface here, the drawable's
+       already gone.. But dri.c notices the window destruction and
+       frees the surface itself. */
+
+    free(glPriv->private);
+    glPriv->private = NULL;
+}
+
+
+static void glWinCreateBuffer(__GLXdrawablePrivate *glxPriv)
+{
+    GLWinDrawableRec *winPriv = malloc(sizeof(GLWinDrawableRec));
+    __GLdrawablePrivate *glPriv = &glxPriv->glPriv;
+
+    /*winPriv->sid = 0; */
+    winPriv->pDraw = NULL;
+
+    GLWIN_DEBUG_MSG("glWinCreateBuffer\n");
+
+    /* replace swapBuffers (original is never called) */
+    glxPriv->swapBuffers = glWinSwapBuffers;
+
+    /* stash private data */
+    glPriv->private = winPriv;
+    glPriv->freePrivate = glWinDestroyDrawablePrivate;
+}
+
+static void glWinResetExtension(void)
+{
+    GLWIN_DEBUG_MSG("glWinResetExtension\n");
+}
+
+/* based on code in apples/indirect.c which is based on i830_dri.c */
+static void
+glWinInitVisualConfigs(void)
+{
+    int                 lclNumConfigs     = 0;
+    __GLXvisualConfig  *lclVisualConfigs  = NULL;
+    void              **lclVisualPrivates = NULL;
+
+    int depth, aux, buffers, stencil, accum;
+    int i = 0;
+
+    GLWIN_DEBUG_MSG("glWinInitVisualConfigs ");
+        
+    /* 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)
+        GLWIN_DEBUG_MSG("glWinInitVisualConfigs failed to alloc visual configs");
+
+    GlxSetVisualConfigs(lclNumConfigs, lclVisualConfigs, lclVisualPrivates);
+}
+
+/* Copied from Mesa */
+static void glWinSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
+                                   void **privates)
+{
+    GLWIN_DEBUG_MSG("glWinSetVisualConfigs\n");
+
+    numConfigs = nconfigs;
+    visualConfigs = configs;
+    visualPrivates = privates;
+}
+
+/* Copied from Mesa */
+static Bool glWinInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
+                              int *nvisualp, int *ndepthp,
+                              int *rootDepthp, VisualID *defaultVisp,
+                              unsigned long sizes, int bitsPerRGB)
+{
+    glWinInitDebugSettings();
+
+    GLWIN_DEBUG_MSG("glWinInitVisuals\n");
+
+    if (0 == numConfigs) /* if no configs */
+        glWinInitVisualConfigs(); /* ensure the visula configs are setup */
+
+    /*
+     * Setup the visuals supported by this particular screen.
+     */
+    return init_visuals(nvisualp, visualp, defaultVisp,
+                        *ndepthp, *depthp, *rootDepthp);
+}