gdi: Reimplement using the WGL statetracker.

7 files changed, 352 insertions, 2464 deletions

diff --git a/src/gallium/winsys/gdi/SConscript b/src/gallium/winsys/gdi/SConscript
index dce81ec1ca..b463fa6505 100644
--- a/src/gallium/winsys/gdi/SConscript
+++ b/src/gallium/winsys/gdi/SConscript
@@ -8,32 +8,28 @@ if env['platform'] == 'windows':
 	env = env.Clone()
 
 	env.Append(CPPPATH = [
-		'#src/mesa/glapi',
-		'#src/mesa',
-		'#src/mesa/main',
+		'#src/mesa/state_tracker/wgl',
 	])
 
 	env.Append(CPPDEFINES = [
-		'__GL_EXPORTS',
-		'BUILD_GL32',
-		'_GNU_H_WINDOWS32_DEFINES',
 	])
 
 	sources = [
-		'opengl32.def',
-		'wgl.c',
-		'wmesa.c',
+		'#src/mesa/state_tracker/wgl/opengl32.def',
+		'gdi_softpipe_winsys.c',
 	]
 		
 	drivers = [
 		softpipe,
 	]
 
-	env.Append(LIBS = ['gdi32', 'user32'])
+	env.Append(LIBS = [
+		'gdi32', 
+		'user32'
+	])
 
-	# TODO: write a wrapper function http://www.scons.org/wiki/WrapperFunctions
 	env.SharedLibrary(
 		target ='opengl32',
 		source = sources,
-		LIBS = glapi + mesa + drivers + auxiliaries + env['LIBS'],
+		LIBS = wgl + glapi + mesa + drivers + auxiliaries + env['LIBS'],
 	)
diff --git a/src/gallium/winsys/gdi/colors.h b/src/gallium/winsys/gdi/colors.h
deleted file mode 100644
index 03e512c1fa..0000000000
--- a/src/gallium/winsys/gdi/colors.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/* Values for wmesa->pixelformat: */
-
-#define PF_8A8B8G8R	3	/* 32-bit TrueColor:  8-A, 8-B, 8-G, 8-R */
-#define PF_8R8G8B	4	/* 32-bit TrueColor:  8-R, 8-G, 8-B */
-#define PF_5R6G5B	5	/* 16-bit TrueColor:  5-R, 6-G, 5-B bits */
-#define PF_DITHER8	6	/* Dithered RGB using a lookup table */
-#define PF_LOOKUP	7	/* Undithered RGB using a lookup table */
-#define PF_GRAYSCALE	10	/* Grayscale or StaticGray */
-#define PF_BADFORMAT	11
-#define PF_INDEX8	12
-
-
-#define BGR8(r,g,b) (unsigned)(((BYTE)((b & 0xc0) | ((g & 0xe0)>>2) | \
-                                      ((r & 0xe0)>>5))))
-
-/* Windows uses 5,5,5 for 16-bit */
-#define BGR16(r,g,b) (  (((unsigned short)b       ) >> 3) | \
-                        (((unsigned short)g & 0xf8) << 2) | \
-                        (((unsigned short)r & 0xf8) << 7) )
-
-#define BGR24(r,g,b) (unsigned long)((DWORD)(((BYTE)(b)| \
-                                    ((WORD)((BYTE)(g))<<8))| \
-                                    (((DWORD)(BYTE)(r))<<16)))
-
-#define BGR32(r,g,b) (unsigned long)((DWORD)(((BYTE)(b)| \
-                                    ((WORD)((BYTE)(g))<<8))| \
-                                    (((DWORD)(BYTE)(r))<<16)))
-
-
diff --git a/src/gallium/winsys/gdi/gdi_softpipe_winsys.c b/src/gallium/winsys/gdi/gdi_softpipe_winsys.c
new file mode 100644
index 0000000000..e66ce48f2d
--- /dev/null
+++ b/src/gallium/winsys/gdi/gdi_softpipe_winsys.c
@@ -0,0 +1,344 @@
+/**************************************************************************
+ *
+ * Copyright 2008 Tungsten Graphics, Inc., Bismarck, ND., USA
+ * 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, sub license, 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 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS 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.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ *
+ **************************************************************************/
+
+/**
+ * @file
+ * Softpipe support.
+ *
+ * @author Keith Whitwell
+ * @author Brian Paul
+ * @author Jose Fonseca
+ */
+
+
+#include <windows.h>
+
+#include "pipe/p_winsys.h"
+#include "pipe/p_format.h"
+#include "pipe/p_context.h"
+#include "pipe/p_inlines.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
+#include "softpipe/sp_winsys.h"
+#include "stw_winsys.h"
+
+
+struct gdi_softpipe_buffer
+{
+   struct pipe_buffer base;
+   boolean userBuffer;  /** Is this a user-space buffer? */
+   void *data;
+   void *mapped;
+};
+
+
+/** Cast wrapper */
+static INLINE struct gdi_softpipe_buffer *
+gdi_softpipe_buffer( struct pipe_buffer *buf )
+{
+   return (struct gdi_softpipe_buffer *)buf;
+}
+
+
+static void *
+gdi_softpipe_buffer_map(struct pipe_winsys *winsys,
+                        struct pipe_buffer *buf,
+                        unsigned flags)
+{
+   struct gdi_softpipe_buffer *gdi_softpipe_buf = gdi_softpipe_buffer(buf);
+   gdi_softpipe_buf->mapped = gdi_softpipe_buf->data;
+   return gdi_softpipe_buf->mapped;
+}
+
+
+static void
+gdi_softpipe_buffer_unmap(struct pipe_winsys *winsys,
+                          struct pipe_buffer *buf)
+{
+   struct gdi_softpipe_buffer *gdi_softpipe_buf = gdi_softpipe_buffer(buf);
+   gdi_softpipe_buf->mapped = NULL;
+}
+
+
+static void
+gdi_softpipe_buffer_destroy(struct pipe_winsys *winsys,
+                            struct pipe_buffer *buf)
+{
+   struct gdi_softpipe_buffer *oldBuf = gdi_softpipe_buffer(buf);
+
+   if (oldBuf->data) {
+      if (!oldBuf->userBuffer)
+         align_free(oldBuf->data);
+
+      oldBuf->data = NULL;
+   }
+
+   FREE(oldBuf);
+}
+
+
+static const char *
+gdi_softpipe_get_name(struct pipe_winsys *winsys)
+{
+   return "softpipe";
+}
+
+
+static struct pipe_buffer *
+gdi_softpipe_buffer_create(struct pipe_winsys *winsys,
+                           unsigned alignment,
+                           unsigned usage,
+                           unsigned size)
+{
+   struct gdi_softpipe_buffer *buffer = CALLOC_STRUCT(gdi_softpipe_buffer);
+
+   buffer->base.refcount = 1;
+   buffer->base.alignment = alignment;
+   buffer->base.usage = usage;
+   buffer->base.size = size;
+
+   buffer->data = align_malloc(size, alignment);
+
+   return &buffer->base;
+}
+
+
+/**
+ * Create buffer which wraps user-space data.
+ */
+static struct pipe_buffer *
+gdi_softpipe_user_buffer_create(struct pipe_winsys *winsys,
+                               void *ptr,
+                               unsigned bytes)
+{
+   struct gdi_softpipe_buffer *buffer;
+
+   buffer = CALLOC_STRUCT(gdi_softpipe_buffer);
+   if(!buffer)
+      return NULL;
+
+   buffer->base.refcount = 1;
+   buffer->base.size = bytes;
+   buffer->userBuffer = TRUE;
+   buffer->data = ptr;
+
+   return &buffer->base;
+}
+
+
+/**
+ * Round n up to next multiple.
+ */
+static INLINE unsigned
+round_up(unsigned n, unsigned multiple)
+{
+   return (n + multiple - 1) & ~(multiple - 1);
+}
+
+
+static int
+gdi_softpipe_surface_alloc_storage(struct pipe_winsys *winsys,
+                                   struct pipe_surface *surf,
+                                   unsigned width, unsigned height,
+                                   enum pipe_format format,
+                                   unsigned flags,
+                                   unsigned tex_usage)
+{
+   const unsigned alignment = 64;
+
+   surf->width = width;
+   surf->height = height;
+   surf->format = format;
+   pf_get_block(format, &surf->block);
+   surf->nblocksx = pf_get_nblocksx(&surf->block, width);
+   surf->nblocksy = pf_get_nblocksy(&surf->block, height);
+   surf->stride = round_up(surf->nblocksx * surf->block.size, alignment);
+   surf->usage = flags;
+
+   assert(!surf->buffer);
+   surf->buffer = winsys->buffer_create(winsys, alignment,
+                                        PIPE_BUFFER_USAGE_PIXEL,
+                                        surf->stride * surf->nblocksy);
+   if(!surf->buffer)
+      return -1;
+
+   return 0;
+}
+
+
+static struct pipe_surface *
+gdi_softpipe_surface_alloc(struct pipe_winsys *winsys)
+{
+   struct pipe_surface *surface = CALLOC_STRUCT(pipe_surface);
+
+   assert(winsys);
+
+   surface->refcount = 1;
+   surface->winsys = winsys;
+
+   return surface;
+}
+
+
+static void
+gdi_softpipe_surface_release(struct pipe_winsys *winsys,
+                             struct pipe_surface **s)
+{
+   struct pipe_surface *surf = *s;
+   assert(!surf->texture);
+   surf->refcount--;
+   if (surf->refcount == 0) {
+      if (surf->buffer)
+	winsys_buffer_reference(winsys, &surf->buffer, NULL);
+      free(surf);
+   }
+   *s = NULL;
+}
+
+
+static void
+gdi_softpipe_dummy_flush_frontbuffer(struct pipe_winsys *winsys,
+                                     struct pipe_surface *surface,
+                                     void *context_private)
+{
+   assert(0);
+}
+
+
+static void
+gdi_softpipe_fence_reference(struct pipe_winsys *winsys,
+                             struct pipe_fence_handle **ptr,
+                             struct pipe_fence_handle *fence)
+{
+}
+
+
+static int
+gdi_softpipe_fence_signalled(struct pipe_winsys *winsys,
+                             struct pipe_fence_handle *fence,
+                             unsigned flag)
+{
+   return 0;
+}
+
+
+static int
+gdi_softpipe_fence_finish(struct pipe_winsys *winsys,
+                          struct pipe_fence_handle *fence,
+                          unsigned flag)
+{
+   return 0;
+}
+
+
+static void
+gdi_softpipe_destroy(struct pipe_winsys *winsys)
+{
+   FREE(winsys);
+}
+
+
+static struct pipe_screen *
+gdi_softpipe_screen_create(void)
+{
+   static struct pipe_winsys *winsys;
+   struct pipe_screen *screen;
+
+   winsys = CALLOC_STRUCT(pipe_winsys);
+   if(!winsys)
+      return NULL;
+
+   winsys->destroy = gdi_softpipe_destroy;
+
+   winsys->buffer_create = gdi_softpipe_buffer_create;
+   winsys->user_buffer_create = gdi_softpipe_user_buffer_create;
+   winsys->buffer_map = gdi_softpipe_buffer_map;
+   winsys->buffer_unmap = gdi_softpipe_buffer_unmap;
+   winsys->buffer_destroy = gdi_softpipe_buffer_destroy;
+
+   winsys->surface_alloc = gdi_softpipe_surface_alloc;
+   winsys->surface_alloc_storage = gdi_softpipe_surface_alloc_storage;
+   winsys->surface_release = gdi_softpipe_surface_release;
+
+   winsys->fence_reference = gdi_softpipe_fence_reference;
+   winsys->fence_signalled = gdi_softpipe_fence_signalled;
+   winsys->fence_finish = gdi_softpipe_fence_finish;
+
+   winsys->flush_frontbuffer = gdi_softpipe_dummy_flush_frontbuffer;
+   winsys->get_name = gdi_softpipe_get_name;
+
+   screen = softpipe_create_screen(winsys);
+   if(!screen)
+      gdi_softpipe_destroy(winsys);
+
+   return screen;
+}
+
+
+static struct pipe_context *
+gdi_softpipe_context_create(struct pipe_screen *screen)
+{
+   return softpipe_create(screen, screen->winsys, NULL);
+}
+
+
+static void
+gdi_softpipe_flush_frontbuffer(struct pipe_winsys *winsys,
+                               struct pipe_surface *surface,
+                               HDC hDC)
+{
+    struct gdi_softpipe_buffer *buffer;
+    BITMAPINFO bmi;
+
+    buffer = gdi_softpipe_buffer(surface->buffer);
+
+    memset(&bmi, 0, sizeof(BITMAPINFO));
+    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    bmi.bmiHeader.biWidth = surface->stride / pf_get_size(surface->format);
+    bmi.bmiHeader.biHeight= -surface->height;
+    bmi.bmiHeader.biPlanes = 1;
+    bmi.bmiHeader.biBitCount = pf_get_bits(surface->format);
+    bmi.bmiHeader.biCompression = BI_RGB;
+    bmi.bmiHeader.biSizeImage = 0;
+    bmi.bmiHeader.biXPelsPerMeter = 0;
+    bmi.bmiHeader.biYPelsPerMeter = 0;
+    bmi.bmiHeader.biClrUsed = 0;
+    bmi.bmiHeader.biClrImportant = 0;
+
+    StretchDIBits(hDC,
+                  0, 0, surface->width, surface->height,
+                  0, 0, surface->width, surface->height,
+                  buffer->data, &bmi, 0, SRCCOPY);
+}
+
+
+const struct stw_winsys stw_winsys = {
+   &gdi_softpipe_screen_create,
+   &gdi_softpipe_context_create,
+   &gdi_softpipe_flush_frontbuffer
+};
diff --git a/src/gallium/winsys/gdi/opengl32.def b/src/gallium/winsys/gdi/opengl32.def
deleted file mode 100644
index 54e72f57b1..0000000000
--- a/src/gallium/winsys/gdi/opengl32.def
+++ /dev/null
@@ -1,859 +0,0 @@
-; DO NOT EDIT - This file generated automatically by mesadef.py script
-;DESCRIPTION 'Mesa (OpenGL work-alike) for Win32'
-VERSION 6.5
-;
-; Module definition file for Mesa (OPENGL32.DLL)
-;
-; Note: The OpenGL functions use the STDCALL
-; function calling convention.  Microsoft's
-; OPENGL32 uses this convention and so must the
-; Mesa OPENGL32 so that the Mesa DLL can be used
-; as a drop-in replacement.
-;
-; The linker exports STDCALL entry points with
-; 'decorated' names; e.g., _glBegin@0, where the
-; trailing number is the number of bytes of 
-; parameter data pushed onto the stack.  The
-; callee is responsible for popping this data
-; off the stack, usually via a RETF n instruction.
-;
-; However, the Microsoft OPENGL32.DLL does not export
-; the decorated names, even though the calling convention
-; is STDCALL.  So, this module definition file is
-; needed to force the Mesa OPENGL32.DLL to export the
-; symbols in the same manner as the Microsoft DLL.
-; Were it not for this problem, this file would not
-; be needed (for the gl* functions) since the entry
-; points are compiled with dllexport declspec.
-;
-; However, this file is still needed to export "internal"
-; Mesa symbols for the benefit of the OSMESA32.DLL.
-;
-EXPORTS
-	glNewList
-	glEndList
-	glCallList
-	glCallLists
-	glDeleteLists
-	glGenLists
-	glListBase
-	glBegin
-	glBitmap
-	glColor3b
-	glColor3bv
-	glColor3d
-	glColor3dv
-	glColor3f
-	glColor3fv
-	glColor3i
-	glColor3iv
-	glColor3s
-	glColor3sv
-	glColor3ub
-	glColor3ubv
-	glColor3ui
-	glColor3uiv
-	glColor3us
-	glColor3usv
-	glColor4b
-	glColor4bv
-	glColor4d
-	glColor4dv
-	glColor4f
-	glColor4fv
-	glColor4i
-	glColor4iv
-	glColor4s
-	glColor4sv
-	glColor4ub
-	glColor4ubv
-	glColor4ui
-	glColor4uiv
-	glColor4us
-	glColor4usv
-	glEdgeFlag
-	glEdgeFlagv
-	glEnd
-	glIndexd
-	glIndexdv
-	glIndexf
-	glIndexfv
-	glIndexi
-	glIndexiv
-	glIndexs
-	glIndexsv
-	glNormal3b
-	glNormal3bv
-	glNormal3d
-	glNormal3dv
-	glNormal3f
-	glNormal3fv
-	glNormal3i
-	glNormal3iv
-	glNormal3s
-	glNormal3sv
-	glRasterPos2d
-	glRasterPos2dv
-	glRasterPos2f
-	glRasterPos2fv
-	glRasterPos2i
-	glRasterPos2iv
-	glRasterPos2s
-	glRasterPos2sv
-	glRasterPos3d
-	glRasterPos3dv
-	glRasterPos3f
-	glRasterPos3fv
-	glRasterPos3i
-	glRasterPos3iv
-	glRasterPos3s
-	glRasterPos3sv
-	glRasterPos4d
-	glRasterPos4dv
-	glRasterPos4f
-	glRasterPos4fv
-	glRasterPos4i
-	glRasterPos4iv
-	glRasterPos4s
-	glRasterPos4sv
-	glRectd
-	glRectdv
-	glRectf
-	glRectfv
-	glRecti
-	glRectiv
-	glRects
-	glRectsv
-	glTexCoord1d
-	glTexCoord1dv
-	glTexCoord1f
-	glTexCoord1fv
-	glTexCoord1i
-	glTexCoord1iv
-	glTexCoord1s
-	glTexCoord1sv
-	glTexCoord2d
-	glTexCoord2dv
-	glTexCoord2f
-	glTexCoord2fv
-	glTexCoord2i
-	glTexCoord2iv
-	glTexCoord2s
-	glTexCoord2sv
-	glTexCoord3d
-	glTexCoord3dv
-	glTexCoord3f
-	glTexCoord3fv
-	glTexCoord3i
-	glTexCoord3iv
-	glTexCoord3s
-	glTexCoord3sv
-	glTexCoord4d
-	glTexCoord4dv
-	glTexCoord4f
-	glTexCoord4fv
-	glTexCoord4i
-	glTexCoord4iv
-	glTexCoord4s
-	glTexCoord4sv
-	glVertex2d
-	glVertex2dv
-	glVertex2f
-	glVertex2fv
-	glVertex2i
-	glVertex2iv
-	glVertex2s
-	glVertex2sv
-	glVertex3d
-	glVertex3dv
-	glVertex3f
-	glVertex3fv
-	glVertex3i
-	glVertex3iv
-	glVertex3s
-	glVertex3sv
-	glVertex4d
-	glVertex4dv
-	glVertex4f
-	glVertex4fv
-	glVertex4i
-	glVertex4iv
-	glVertex4s
-	glVertex4sv
-	glClipPlane
-	glColorMaterial
-	glCullFace
-	glFogf
-	glFogfv
-	glFogi
-	glFogiv
-	glFrontFace
-	glHint
-	glLightf
-	glLightfv
-	glLighti
-	glLightiv
-	glLightModelf
-	glLightModelfv
-	glLightModeli
-	glLightModeliv
-	glLineStipple
-	glLineWidth
-	glMaterialf
-	glMaterialfv
-	glMateriali
-	glMaterialiv
-	glPointSize
-	glPolygonMode
-	glPolygonStipple
-	glScissor
-	glShadeModel
-	glTexParameterf
-	glTexParameterfv
-	glTexParameteri
-	glTexParameteriv
-	glTexImage1D
-	glTexImage2D
-	glTexEnvf
-	glTexEnvfv
-	glTexEnvi
-	glTexEnviv
-	glTexGend
-	glTexGendv
-	glTexGenf
-	glTexGenfv
-	glTexGeni
-	glTexGeniv
-	glFeedbackBuffer
-	glSelectBuffer
-	glRenderMode
-	glInitNames
-	glLoadName
-	glPassThrough
-	glPopName
-	glPushName
-	glDrawBuffer
-	glClear
-	glClearAccum
-	glClearIndex
-	glClearColor
-	glClearStencil
-	glClearDepth
-	glStencilMask
-	glColorMask
-	glDepthMask
-	glIndexMask
-	glAccum
-	glDisable
-	glEnable
-	glFinish
-	glFlush
-	glPopAttrib
-	glPushAttrib
-	glMap1d
-	glMap1f
-	glMap2d
-	glMap2f
-	glMapGrid1d
-	glMapGrid1f
-	glMapGrid2d
-	glMapGrid2f
-	glEvalCoord1d
-	glEvalCoord1dv
-	glEvalCoord1f
-	glEvalCoord1fv
-	glEvalCoord2d
-	glEvalCoord2dv
-	glEvalCoord2f
-	glEvalCoord2fv
-	glEvalMesh1
-	glEvalPoint1
-	glEvalMesh2
-	glEvalPoint2
-	glAlphaFunc
-	glBlendFunc
-	glLogicOp
-	glStencilFunc
-	glStencilOp
-	glDepthFunc
-	glPixelZoom
-	glPixelTransferf
-	glPixelTransferi
-	glPixelStoref
-	glPixelStorei
-	glPixelMapfv
-	glPixelMapuiv
-	glPixelMapusv
-	glReadBuffer
-	glCopyPixels
-	glReadPixels
-	glDrawPixels
-	glGetBooleanv
-	glGetClipPlane
-	glGetDoublev
-	glGetError
-	glGetFloatv
-	glGetIntegerv
-	glGetLightfv
-	glGetLightiv
-	glGetMapdv
-	glGetMapfv
-	glGetMapiv
-	glGetMaterialfv
-	glGetMaterialiv
-	glGetPixelMapfv
-	glGetPixelMapuiv
-	glGetPixelMapusv
-	glGetPolygonStipple
-	glGetString
-	glGetTexEnvfv
-	glGetTexEnviv
-	glGetTexGendv
-	glGetTexGenfv
-	glGetTexGeniv
-	glGetTexImage
-	glGetTexParameterfv
-	glGetTexParameteriv
-	glGetTexLevelParameterfv
-	glGetTexLevelParameteriv
-	glIsEnabled
-	glIsList
-	glDepthRange
-	glFrustum
-	glLoadIdentity
-	glLoadMatrixf
-	glLoadMatrixd
-	glMatrixMode
-	glMultMatrixf
-	glMultMatrixd
-	glOrtho
-	glPopMatrix
-	glPushMatrix
-	glRotated
-	glRotatef
-	glScaled
-	glScalef
-	glTranslated
-	glTranslatef
-	glViewport
-	glArrayElement
-	glColorPointer
-	glDisableClientState
-	glDrawArrays
-	glDrawElements
-	glEdgeFlagPointer
-	glEnableClientState
-	glGetPointerv
-	glIndexPointer
-	glInterleavedArrays
-	glNormalPointer
-	glTexCoordPointer
-	glVertexPointer
-	glPolygonOffset
-	glCopyTexImage1D
-	glCopyTexImage2D
-	glCopyTexSubImage1D
-	glCopyTexSubImage2D
-	glTexSubImage1D
-	glTexSubImage2D
-	glAreTexturesResident
-	glBindTexture
-	glDeleteTextures
-	glGenTextures
-	glIsTexture
-	glPrioritizeTextures
-	glIndexub
-	glIndexubv
-	glPopClientAttrib
-	glPushClientAttrib
-	glBlendColor
-	glBlendEquation
-	glDrawRangeElements
-	glColorTable
-	glColorTableParameterfv
-	glColorTableParameteriv
-	glCopyColorTable
-	glGetColorTable
-	glGetColorTableParameterfv
-	glGetColorTableParameteriv
-	glColorSubTable
-	glCopyColorSubTable
-	glConvolutionFilter1D
-	glConvolutionFilter2D
-	glConvolutionParameterf
-	glConvolutionParameterfv
-	glConvolutionParameteri
-	glConvolutionParameteriv
-	glCopyConvolutionFilter1D
-	glCopyConvolutionFilter2D
-	glGetConvolutionFilter
-	glGetConvolutionParameterfv
-	glGetConvolutionParameteriv
-	glGetSeparableFilter
-	glSeparableFilter2D
-	glGetHistogram
-	glGetHistogramParameterfv
-	glGetHistogramParameteriv
-	glGetMinmax
-	glGetMinmaxParameterfv
-	glGetMinmaxParameteriv
-	glHistogram
-	glMinmax
-	glResetHistogram
-	glResetMinmax
-	glTexImage3D
-	glTexSubImage3D
-	glCopyTexSubImage3D
-	glActiveTextureARB
-	glClientActiveTextureARB
-	glMultiTexCoord1dARB
-	glMultiTexCoord1dvARB
-	glMultiTexCoord1fARB
-	glMultiTexCoord1fvARB
-	glMultiTexCoord1iARB
-	glMultiTexCoord1ivARB
-	glMultiTexCoord1sARB
-	glMultiTexCoord1svARB
-	glMultiTexCoord2dARB
-	glMultiTexCoord2dvARB
-	glMultiTexCoord2fARB
-	glMultiTexCoord2fvARB
-	glMultiTexCoord2iARB
-	glMultiTexCoord2ivARB
-	glMultiTexCoord2sARB
-	glMultiTexCoord2svARB
-	glMultiTexCoord3dARB
-	glMultiTexCoord3dvARB
-	glMultiTexCoord3fARB
-	glMultiTexCoord3fvARB
-	glMultiTexCoord3iARB
-	glMultiTexCoord3ivARB
-	glMultiTexCoord3sARB
-	glMultiTexCoord3svARB
-	glMultiTexCoord4dARB
-	glMultiTexCoord4dvARB
-	glMultiTexCoord4fARB
-	glMultiTexCoord4fvARB
-	glMultiTexCoord4iARB
-	glMultiTexCoord4ivARB
-	glMultiTexCoord4sARB
-	glMultiTexCoord4svARB
-	glLoadTransposeMatrixfARB
-	glLoadTransposeMatrixdARB
-	glMultTransposeMatrixfARB
-	glMultTransposeMatrixdARB
-	glSampleCoverageARB
-	glCompressedTexImage3DARB
-	glCompressedTexImage2DARB
-	glCompressedTexImage1DARB
-	glCompressedTexSubImage3DARB
-	glCompressedTexSubImage2DARB
-	glCompressedTexSubImage1DARB
-	glGetCompressedTexImageARB
-	glActiveTexture
-	glClientActiveTexture
-	glMultiTexCoord1d
-	glMultiTexCoord1dv
-	glMultiTexCoord1f
-	glMultiTexCoord1fv
-	glMultiTexCoord1i
-	glMultiTexCoord1iv
-	glMultiTexCoord1s
-	glMultiTexCoord1sv
-	glMultiTexCoord2d
-	glMultiTexCoord2dv
-	glMultiTexCoord2f
-	glMultiTexCoord2fv
-	glMultiTexCoord2i
-	glMultiTexCoord2iv
-	glMultiTexCoord2s
-	glMultiTexCoord2sv
-	glMultiTexCoord3d
-	glMultiTexCoord3dv
-	glMultiTexCoord3f
-	glMultiTexCoord3fv
-	glMultiTexCoord3i
-	glMultiTexCoord3iv
-	glMultiTexCoord3s
-	glMultiTexCoord3sv
-	glMultiTexCoord4d
-	glMultiTexCoord4dv
-	glMultiTexCoord4f
-	glMultiTexCoord4fv
-	glMultiTexCoord4i
-	glMultiTexCoord4iv
-	glMultiTexCoord4s
-	glMultiTexCoord4sv
-	glLoadTransposeMatrixf
-	glLoadTransposeMatrixd
-	glMultTransposeMatrixf
-	glMultTransposeMatrixd
-	glSampleCoverage
-	glCompressedTexImage3D
-	glCompressedTexImage2D
-	glCompressedTexImage1D
-	glCompressedTexSubImage3D
-	glCompressedTexSubImage2D
-	glCompressedTexSubImage1D
-	glGetCompressedTexImage
-	glBlendColorEXT
-	glPolygonOffsetEXT
-	glTexImage3DEXT
-	glTexSubImage3DEXT
-	glTexSubImage1DEXT
-	glTexSubImage2DEXT
-	glCopyTexImage1DEXT
-	glCopyTexImage2DEXT
-	glCopyTexSubImage1DEXT
-	glCopyTexSubImage2DEXT
-	glCopyTexSubImage3DEXT
-	glAreTexturesResidentEXT
-	glBindTextureEXT
-	glDeleteTexturesEXT
-	glGenTexturesEXT
-	glIsTextureEXT
-	glPrioritizeTexturesEXT
-	glArrayElementEXT
-	glColorPointerEXT
-	glDrawArraysEXT
-	glEdgeFlagPointerEXT
-	glGetPointervEXT
-	glIndexPointerEXT
-	glNormalPointerEXT
-	glTexCoordPointerEXT
-	glVertexPointerEXT
-	glBlendEquationEXT
-	glPointParameterfEXT
-	glPointParameterfvEXT
-	glPointParameterfARB
-	glPointParameterfvARB
-	glColorTableEXT
-	glGetColorTableEXT
-	glGetColorTableParameterivEXT
-	glGetColorTableParameterfvEXT
-	glLockArraysEXT
-	glUnlockArraysEXT
-	glDrawRangeElementsEXT
-	glSecondaryColor3bEXT
-	glSecondaryColor3bvEXT
-	glSecondaryColor3dEXT
-	glSecondaryColor3dvEXT
-	glSecondaryColor3fEXT
-	glSecondaryColor3fvEXT
-	glSecondaryColor3iEXT
-	glSecondaryColor3ivEXT
-	glSecondaryColor3sEXT
-	glSecondaryColor3svEXT
-	glSecondaryColor3ubEXT
-	glSecondaryColor3ubvEXT
-	glSecondaryColor3uiEXT
-	glSecondaryColor3uivEXT
-	glSecondaryColor3usEXT
-	glSecondaryColor3usvEXT
-	glSecondaryColorPointerEXT
-	glMultiDrawArraysEXT
-	glMultiDrawElementsEXT
-	glFogCoordfEXT
-	glFogCoordfvEXT
-	glFogCoorddEXT
-	glFogCoorddvEXT
-	glFogCoordPointerEXT
-	glBlendFuncSeparateEXT
-	glFlushVertexArrayRangeNV
-	glVertexArrayRangeNV
-	glCombinerParameterfvNV
-	glCombinerParameterfNV
-	glCombinerParameterivNV
-	glCombinerParameteriNV
-	glCombinerInputNV
-	glCombinerOutputNV
-	glFinalCombinerInputNV
-	glGetCombinerInputParameterfvNV
-	glGetCombinerInputParameterivNV
-	glGetCombinerOutputParameterfvNV
-	glGetCombinerOutputParameterivNV
-	glGetFinalCombinerInputParameterfvNV
-	glGetFinalCombinerInputParameterivNV
-	glResizeBuffersMESA
-	glWindowPos2dMESA
-	glWindowPos2dvMESA
-	glWindowPos2fMESA
-	glWindowPos2fvMESA
-	glWindowPos2iMESA
-	glWindowPos2ivMESA
-	glWindowPos2sMESA
-	glWindowPos2svMESA
-	glWindowPos3dMESA
-	glWindowPos3dvMESA
-	glWindowPos3fMESA
-	glWindowPos3fvMESA
-	glWindowPos3iMESA
-	glWindowPos3ivMESA
-	glWindowPos3sMESA
-	glWindowPos3svMESA
-	glWindowPos4dMESA
-	glWindowPos4dvMESA
-	glWindowPos4fMESA
-	glWindowPos4fvMESA
-	glWindowPos4iMESA
-	glWindowPos4ivMESA
-	glWindowPos4sMESA
-	glWindowPos4svMESA
-	glWindowPos2dARB
-	glWindowPos2fARB
-	glWindowPos2iARB
-	glWindowPos2sARB
-	glWindowPos2dvARB
-	glWindowPos2fvARB
-	glWindowPos2ivARB
-	glWindowPos2svARB
-	glWindowPos3dARB
-	glWindowPos3fARB
-	glWindowPos3iARB
-	glWindowPos3sARB
-	glWindowPos3dvARB
-	glWindowPos3fvARB
-	glWindowPos3ivARB
-	glWindowPos3svARB
-	glAreProgramsResidentNV
-	glBindProgramNV
-	glDeleteProgramsNV
-	glExecuteProgramNV
-	glGenProgramsNV
-	glGetProgramParameterdvNV
-	glGetProgramParameterfvNV
-	glGetProgramivNV
-	glGetProgramStringNV
-	glGetTrackMatrixivNV
-	glGetVertexAttribdvNV
-	glGetVertexAttribfvNV
-	glGetVertexAttribivNV
-	glGetVertexAttribPointervNV
-	glIsProgramNV
-	glLoadProgramNV
-	glProgramParameter4dNV
-	glProgramParameter4dvNV
-	glProgramParameter4fNV
-	glProgramParameter4fvNV
-	glProgramParameters4dvNV
-	glProgramParameters4fvNV
-	glRequestResidentProgramsNV
-	glTrackMatrixNV
-	glVertexAttribPointerNV
-	glVertexAttrib1dNV
-	glVertexAttrib1dvNV
-	glVertexAttrib1fNV
-	glVertexAttrib1fvNV
-	glVertexAttrib1sNV
-	glVertexAttrib1svNV
-	glVertexAttrib2dNV
-	glVertexAttrib2dvNV
-	glVertexAttrib2fNV
-	glVertexAttrib2fvNV
-	glVertexAttrib2sNV
-	glVertexAttrib2svNV
-	glVertexAttrib3dNV
-	glVertexAttrib3dvNV
-	glVertexAttrib3fNV
-	glVertexAttrib3fvNV
-	glVertexAttrib3sNV
-	glVertexAttrib3svNV
-	glVertexAttrib4dNV
-	glVertexAttrib4dvNV
-	glVertexAttrib4fNV
-	glVertexAttrib4fvNV
-	glVertexAttrib4sNV
-	glVertexAttrib4svNV
-	glVertexAttrib4ubNV
-	glVertexAttrib4ubvNV
-	glVertexAttribs1dvNV
-	glVertexAttribs1fvNV
-	glVertexAttribs1svNV
-	glVertexAttribs2dvNV
-	glVertexAttribs2fvNV
-	glVertexAttribs2svNV
-	glVertexAttribs3dvNV
-	glVertexAttribs3fvNV
-	glVertexAttribs3svNV
-	glVertexAttribs4dvNV
-	glVertexAttribs4fvNV
-	glVertexAttribs4svNV
-	glVertexAttribs4ubvNV
-	glPointParameteriNV
-	glPointParameterivNV
-	glFogCoordf
-	glFogCoordfv
-	glFogCoordd
-	glFogCoorddv
-	glFogCoordPointer
-	glMultiDrawArrays
-	glMultiDrawElements
-	glPointParameterf
-	glPointParameterfv
-	glPointParameteri
-	glPointParameteriv
-	glSecondaryColor3b
-	glSecondaryColor3bv
-	glSecondaryColor3d
-	glSecondaryColor3dv
-	glSecondaryColor3f
-	glSecondaryColor3fv
-	glSecondaryColor3i
-	glSecondaryColor3iv
-	glSecondaryColor3s
-	glSecondaryColor3sv
-	glSecondaryColor3ub
-	glSecondaryColor3ubv
-	glSecondaryColor3ui
-	glSecondaryColor3uiv
-	glSecondaryColor3us
-	glSecondaryColor3usv
-	glSecondaryColorPointer
-	glWindowPos2d
-	glWindowPos2dv
-	glWindowPos2f
-	glWindowPos2fv
-	glWindowPos2i
-	glWindowPos2iv
-	glWindowPos2s
-	glWindowPos2sv
-	glWindowPos3d
-	glWindowPos3dv
-	glWindowPos3f
-	glWindowPos3fv
-	glWindowPos3i
-	glWindowPos3iv
-	glWindowPos3s
-	glWindowPos3sv
-	glVertexAttrib1sARB
-	glVertexAttrib1fARB
-	glVertexAttrib1dARB
-	glVertexAttrib2sARB
-	glVertexAttrib2fARB
-	glVertexAttrib2dARB
-	glVertexAttrib3sARB
-	glVertexAttrib3fARB
-	glVertexAttrib3dARB
-	glVertexAttrib4sARB
-	glVertexAttrib4fARB
-	glVertexAttrib4dARB
-	glVertexAttrib4NubARB
-	glVertexAttrib1svARB
-	glVertexAttrib1fvARB
-	glVertexAttrib1dvARB
-	glVertexAttrib2svARB
-	glVertexAttrib2fvARB
-	glVertexAttrib2dvARB
-	glVertexAttrib3svARB
-	glVertexAttrib3fvARB
-	glVertexAttrib3dvARB
-	glVertexAttrib4bvARB
-	glVertexAttrib4svARB
-	glVertexAttrib4ivARB
-	glVertexAttrib4ubvARB
-	glVertexAttrib4usvARB
-	glVertexAttrib4uivARB
-	glVertexAttrib4fvARB
-	glVertexAttrib4dvARB
-	glVertexAttrib4NbvARB
-	glVertexAttrib4NsvARB
-	glVertexAttrib4NivARB
-	glVertexAttrib4NubvARB
-	glVertexAttrib4NusvARB
-	glVertexAttrib4NuivARB
-	glVertexAttribPointerARB
-	glEnableVertexAttribArrayARB
-	glDisableVertexAttribArrayARB
-	glProgramStringARB
-	glBindProgramARB
-	glDeleteProgramsARB
-	glGenProgramsARB
-	glIsProgramARB
-	glProgramEnvParameter4dARB
-	glProgramEnvParameter4dvARB
-	glProgramEnvParameter4fARB
-	glProgramEnvParameter4fvARB
-	glProgramLocalParameter4dARB
-	glProgramLocalParameter4dvARB
-	glProgramLocalParameter4fARB
-	glProgramLocalParameter4fvARB
-	glGetProgramEnvParameterdvARB
-	glGetProgramEnvParameterfvARB
-	glGetProgramLocalParameterdvARB
-	glGetProgramLocalParameterfvARB
-	glGetProgramivARB
-	glGetProgramStringARB
-	glGetVertexAttribdvARB
-	glGetVertexAttribfvARB
-	glGetVertexAttribivARB
-	glGetVertexAttribPointervARB
-	glProgramNamedParameter4fNV
-	glProgramNamedParameter4dNV
-	glProgramNamedParameter4fvNV
-	glProgramNamedParameter4dvNV
-	glGetProgramNamedParameterfvNV
-	glGetProgramNamedParameterdvNV
-	glBindBufferARB
-	glBufferDataARB
-	glBufferSubDataARB
-	glDeleteBuffersARB
-	glGenBuffersARB
-	glGetBufferParameterivARB
-	glGetBufferPointervARB
-	glGetBufferSubDataARB
-	glIsBufferARB
-	glMapBufferARB
-	glUnmapBufferARB
-	glGenQueriesARB
-	glDeleteQueriesARB
-	glIsQueryARB
-	glBeginQueryARB
-	glEndQueryARB
-	glGetQueryivARB
-	glGetQueryObjectivARB
-	glGetQueryObjectuivARB
-	glBindBuffer
-	glBufferData
-	glBufferSubData
-	glDeleteBuffers
-	glGenBuffers
-	glGetBufferParameteriv
-	glGetBufferPointerv
-	glGetBufferSubData
-	glIsBuffer
-	glMapBuffer
-	glUnmapBuffer
-	glGenQueries
-	glDeleteQueries
-	glIsQuery
-	glBeginQuery
-	glEndQuery
-	glGetQueryiv
-	glGetQueryObjectiv
-	glGetQueryObjectuiv
-;
-; WGL API
-	wglChoosePixelFormat
-	wglCopyContext
-	wglCreateContext
-	wglCreateLayerContext
-	wglDeleteContext
-	wglDescribeLayerPlane
-	wglDescribePixelFormat
-	wglGetCurrentContext
-	wglGetCurrentDC
-	wglGetLayerPaletteEntries
-	wglGetPixelFormat
-	wglGetProcAddress
-	wglMakeCurrent
-	wglRealizeLayerPalette
-	wglSetLayerPaletteEntries
-	wglSetPixelFormat
-	wglShareLists
-	wglSwapBuffers
-	wglSwapLayerBuffers
-	wglUseFontBitmapsA
-	wglUseFontBitmapsW
-	wglUseFontOutlinesA
-	wglUseFontOutlinesW
-	wglGetExtensionsStringARB
diff --git a/src/gallium/winsys/gdi/wgl.c b/src/gallium/winsys/gdi/wgl.c
deleted file mode 100644
index 3ce470480d..0000000000
--- a/src/gallium/winsys/gdi/wgl.c
+++ /dev/null
@@ -1,701 +0,0 @@
-/*
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-/*
- * File name 	: wgl.c
- * WGL stuff. Added by Oleg Letsinsky, ajl@ultersys.ru
- * Some things originated from the 3Dfx WGL functions
- */
-
-/* 
- * This file contains the implementation of the wgl* functions for
- * Mesa on Windows.  Since these functions are provided by Windows in
- * GDI/OpenGL, we must supply our versions that work with Mesa here.
- */
-
-
-/* We're essentially building part of GDI here, so define this so that
- * we get the right export linkage. */
-#ifdef __MINGW32__
-
-#include <stdarg.h>
-#include <windef.h>
-#include <wincon.h>
-#include <winbase.h>
-
-#  if defined(BUILD_GL32)
-#    define WINGDIAPI __declspec(dllexport)	
-#  else
-#    define __W32API_USE_DLLIMPORT__
-#  endif
-
-#include <wingdi.h>
-#include "GL/mesa_wgl.h"
-#include <stdlib.h>
-
-#else
-
-#define _GDI32_
-#include <windows.h>
-
-#endif
-
-#include "glapi.h"
-#include "GL/wmesa.h"   /* protos for wmesa* functions */
-
-/*
- * Pixel Format Descriptors
- */
-
-/* Extend the PFD to include DB flag */
-struct __pixelformat__
-{
-    PIXELFORMATDESCRIPTOR pfd;
-    GLboolean doubleBuffered;
-};
-
-/* These are the PFD's supported by this driver. */
-struct __pixelformat__	pfd[] =
-{
-    /* Double Buffer, alpha */
-    {	
-	{	
-	    sizeof(PIXELFORMATDESCRIPTOR),	1,
-	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|
-	    PFD_GENERIC_FORMAT|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,
-	    PFD_TYPE_RGBA,
-	    24,	
-	    8, 0,	
-	    8, 8,	
-	    8, 16,	
-	    8, 24,
-	    0, 0, 0, 0, 0,	
-	    16,	8,	
-	    0, 0, 0,	
-	    0, 0, 0 
-	},
-        GL_TRUE
-    },
-    /* Single Buffer, alpha */
-    {	
-	{	
-	    sizeof(PIXELFORMATDESCRIPTOR),	1,
-	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|
-	    PFD_GENERIC_FORMAT,
-	    PFD_TYPE_RGBA,
-	    24,	
-	    8, 0,	
-	    8, 8,	
-	    8, 16,	
-	    8, 24,
-	    0, 0, 0, 0,	0,	
-	    16,	8,
-	    0, 0, 0,	
-	    0, 0, 0
-	},
-        GL_FALSE
-    },
-    /* Double Buffer, no alpha */
-    {	
-	{	
-	    sizeof(PIXELFORMATDESCRIPTOR),	1,
-	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|
-	    PFD_GENERIC_FORMAT|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,
-	    PFD_TYPE_RGBA,
-	    24,	
-	    8, 0,
-	    8, 8,
-	    8, 16,
-	    0, 0,
-	    0, 0, 0, 0,	0,
-	    16,	8,
-	    0, 0, 0, 
-	    0, 0, 0 
-	},
-        GL_TRUE
-    },
-    /* Single Buffer, no alpha */
-    {	
-	{
-	    sizeof(PIXELFORMATDESCRIPTOR),	1,
-	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|
-	    PFD_GENERIC_FORMAT,
-	    PFD_TYPE_RGBA,
-	    24,	
-	    8, 0,
-	    8, 8,
-	    8, 16,
-	    0, 0,
-	    0, 0, 0, 0,	0,
-	    16,	8,
-	    0, 0, 0,
-	    0, 0, 0 
-	},
-        GL_FALSE
-    },
-};
-
-int npfd = sizeof(pfd) / sizeof(pfd[0]);
-
-
-/*
- * Contexts
- */
-
-typedef struct {
-    WMesaContext ctx;
-} MesaWglCtx;
-
-#define MESAWGL_CTX_MAX_COUNT 20
-
-static MesaWglCtx wgl_ctx[MESAWGL_CTX_MAX_COUNT];
-
-static unsigned ctx_count = 0;
-static int ctx_current = -1;
-static unsigned curPFD = 0;
-
-static HDC CurrentHDC = 0;
-
-
-WINGDIAPI HGLRC GLAPIENTRY wglCreateContext(HDC hdc)
-{
-    int i = 0;
-    if (!ctx_count) {
-	for(i=0;i<MESAWGL_CTX_MAX_COUNT;i++) {
-	    wgl_ctx[i].ctx = NULL;
-	}
-    }
-    for( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {
-        if ( wgl_ctx[i].ctx == NULL ) {
-            wgl_ctx[i].ctx = 
-		WMesaCreateContext(hdc, NULL, (GLboolean)GL_TRUE,
-				   (GLboolean) (pfd[curPFD-1].doubleBuffered ?
-                                   GL_TRUE : GL_FALSE), 
-				   (GLboolean)(pfd[curPFD-1].pfd.cAlphaBits ? 
-				   GL_TRUE : GL_FALSE) );
-            if (wgl_ctx[i].ctx == NULL)
-                break;
-            ctx_count++;
-            return ((HGLRC)wgl_ctx[i].ctx);
-        }
-    }
-    SetLastError(0);
-    return(NULL);
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglDeleteContext(HGLRC hglrc)
-{
-    int i;
-    for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {
-    	if ( wgl_ctx[i].ctx == (WMesaContext) hglrc ){
-            WMesaMakeCurrent((WMesaContext) hglrc, NULL);
-            WMesaDestroyContext(wgl_ctx[i].ctx);
-            wgl_ctx[i].ctx = NULL;
-            ctx_count--;
-            return(TRUE);
-    	}
-    }
-    SetLastError(0);
-    return(FALSE);
-}
-
-WINGDIAPI HGLRC GLAPIENTRY wglGetCurrentContext(VOID)
-{
-    if (ctx_current < 0)
-	return 0;
-    else
-	return (HGLRC) wgl_ctx[ctx_current].ctx;
-}
-
-WINGDIAPI HDC GLAPIENTRY wglGetCurrentDC(VOID)
-{
-    return CurrentHDC;
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglMakeCurrent(HDC hdc, HGLRC hglrc)
-{
-    int i;
-    
-    CurrentHDC = hdc;
-
-    if (!hdc || !hglrc) {
-	WMesaMakeCurrent(NULL, NULL);
-	ctx_current = -1;
-	return TRUE;
-    }
-    
-    for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {
-	if ( wgl_ctx[i].ctx == (WMesaContext) hglrc ) {
-	    WMesaMakeCurrent( (WMesaContext) hglrc, hdc );
-	    ctx_current = i;
-	    return TRUE;
-	}
-    }
-    return FALSE;
-}
-
-
-WINGDIAPI int GLAPIENTRY wglChoosePixelFormat(HDC hdc,
-					      CONST 
-					      PIXELFORMATDESCRIPTOR *ppfd)
-{
-    int		i,best = -1,bestdelta = 0x7FFFFFFF,delta;
-    (void) hdc;
-    
-    if(ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR) || ppfd->nVersion != 1)
-	{
-	    SetLastError(0);
-	    return(0);
-	}
-    for(i = 0; i < npfd;i++)
-	{
-	    delta = 0;
-	    if(
-		(ppfd->dwFlags & PFD_DRAW_TO_WINDOW) &&
-		!(pfd[i].pfd.dwFlags & PFD_DRAW_TO_WINDOW))
-		continue;
-	    if(
-		(ppfd->dwFlags & PFD_DRAW_TO_BITMAP) &&
-		!(pfd[i].pfd.dwFlags & PFD_DRAW_TO_BITMAP))
-		continue;
-	    if(
-		(ppfd->dwFlags & PFD_SUPPORT_GDI) &&
-		!(pfd[i].pfd.dwFlags & PFD_SUPPORT_GDI))
-		continue;
-	    if(
-		(ppfd->dwFlags & PFD_SUPPORT_OPENGL) &&
-		!(pfd[i].pfd.dwFlags & PFD_SUPPORT_OPENGL))
-		continue;
-	    if(
-		!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) &&
-		((ppfd->dwFlags & PFD_DOUBLEBUFFER) != 
-		 (pfd[i].pfd.dwFlags & PFD_DOUBLEBUFFER)))
-		continue;
-	    if(
-		!(ppfd->dwFlags & PFD_STEREO_DONTCARE) &&
-		((ppfd->dwFlags & PFD_STEREO) != 
-		 (pfd[i].pfd.dwFlags & PFD_STEREO)))
-		continue;
-	    if(ppfd->iPixelType != pfd[i].pfd.iPixelType)
-		delta++;
-	    if(ppfd->cAlphaBits != pfd[i].pfd.cAlphaBits)
-		delta++;
-	    if(delta < bestdelta)
-		{
-		    best = i + 1;
-		    bestdelta = delta;
-		    if(bestdelta == 0)
-			break;
-		}
-	}
-    if(best == -1)
-	{
-	    SetLastError(0);
-	    return(0);
-	}
-    return(best);
-}
-
-WINGDIAPI int GLAPIENTRY wglDescribePixelFormat(HDC hdc,
-					        int iPixelFormat,
-					        UINT nBytes,
-					        LPPIXELFORMATDESCRIPTOR ppfd)
-{
-    (void) hdc;
-    
-    if(ppfd == NULL)
-	return(npfd);
-    if(iPixelFormat < 1 || iPixelFormat > npfd || 
-       nBytes != sizeof(PIXELFORMATDESCRIPTOR))
-	{
-	    SetLastError(0);
-	    return(0);
-	}
-    *ppfd = pfd[iPixelFormat - 1].pfd;
-    return(npfd);
-}
-
-WINGDIAPI PROC GLAPIENTRY wglGetProcAddress(LPCSTR lpszProc)
-{
-    PROC p = (PROC) _glapi_get_proc_address((const char *) lpszProc);
-    if (p)
-	return p;
-    
-    SetLastError(0);
-    return(NULL);
-}
-
-WINGDIAPI int GLAPIENTRY wglGetPixelFormat(HDC hdc)
-{
-    (void) hdc;
-    if(curPFD == 0) {
-	SetLastError(0);
-	return(0);
-    }
-    return(curPFD);
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglSetPixelFormat(HDC hdc,int iPixelFormat,
-					const PIXELFORMATDESCRIPTOR *ppfd)
-{
-    (void) hdc;
-    
-    if(iPixelFormat < 1 || iPixelFormat > npfd || 
-       ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR)) {
-	SetLastError(0);
-	return(FALSE);
-    }
-    curPFD = iPixelFormat;
-    return(TRUE);
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglSwapBuffers(HDC hdc)
-{
-    WMesaSwapBuffers(hdc);
-    return TRUE;
-}
-
-static FIXED FixedFromDouble(double d)
-{
-   long l = (long) (d * 65536L);
-   return *(FIXED *) (void *) &l;
-}
-
-
-/*
-** This is cribbed from FX/fxwgl.c, and seems to implement support
-** for bitmap fonts where the wglUseFontBitmapsA() code implements
-** support for outline fonts.  In combination they hopefully give
-** fairly generic support for fonts.
-*/
-static BOOL wglUseFontBitmaps_FX(HDC fontDevice, DWORD firstChar,
-                                 DWORD numChars, DWORD listBase)
-{
-#define VERIFY(a) a
-    
-    TEXTMETRIC metric;
-    BITMAPINFO *dibInfo;
-    HDC bitDevice;
-    COLORREF tempColor;
-    int i;
-    
-    VERIFY(GetTextMetrics(fontDevice, &metric));
-    
-    dibInfo = (BITMAPINFO *) calloc(sizeof(BITMAPINFO) + sizeof(RGBQUAD), 1);
-    dibInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-    dibInfo->bmiHeader.biPlanes = 1;
-    dibInfo->bmiHeader.biBitCount = 1;
-    dibInfo->bmiHeader.biCompression = BI_RGB;
-    
-    bitDevice = CreateCompatibleDC(fontDevice);
-    
-    /* Swap fore and back colors so the bitmap has the right polarity */
-    tempColor = GetBkColor(bitDevice);
-    SetBkColor(bitDevice, GetTextColor(bitDevice));
-    SetTextColor(bitDevice, tempColor);
-    
-    /* Place chars based on base line */
-    VERIFY(SetTextAlign(bitDevice, TA_BASELINE) != GDI_ERROR ? 1 : 0);
-    
-    for(i = 0; i < (int)numChars; i++) {
-	SIZE size;
-	char curChar;
-	int charWidth,charHeight,bmapWidth,bmapHeight,numBytes,res;
-	HBITMAP bitObject;
-	HGDIOBJ origBmap;
-	unsigned char *bmap;
-	
-	curChar = (char)(i + firstChar);
-	
-	/* Find how high/wide this character is */
-	VERIFY(GetTextExtentPoint32(bitDevice, (LPCWSTR)&curChar, 1, &size));
-	
-	/* Create the output bitmap */
-	charWidth = size.cx;
-	charHeight = size.cy;
-	/* Round up to the next multiple of 32 bits */
-	bmapWidth = ((charWidth + 31) / 32) * 32;   
-	bmapHeight = charHeight;
-	bitObject = CreateCompatibleBitmap(bitDevice,
-					   bmapWidth,
-					   bmapHeight);
-	/* VERIFY(bitObject); */
-	
-	/* Assign the output bitmap to the device */
-	origBmap = SelectObject(bitDevice, bitObject);
-	(void) VERIFY(origBmap);
-	
-	VERIFY( PatBlt( bitDevice, 0, 0, bmapWidth, bmapHeight,BLACKNESS ) );
-	
-	/* Use our source font on the device */
-	VERIFY(SelectObject(bitDevice, GetCurrentObject(fontDevice,OBJ_FONT)));
-	
-	/* Draw the character */
-	VERIFY(TextOut(bitDevice, 0, metric.tmAscent, (LPCWSTR)&curChar, 1));
-	
-	/* Unselect our bmap object */
-	VERIFY(SelectObject(bitDevice, origBmap));
-	
-	/* Convert the display dependant representation to a 1 bit deep DIB */
-	numBytes = (bmapWidth * bmapHeight) / 8;
-	bmap = (unsigned char *)malloc(numBytes);
-	dibInfo->bmiHeader.biWidth = bmapWidth;
-	dibInfo->bmiHeader.biHeight = bmapHeight;
-	res = GetDIBits(bitDevice, bitObject, 0, bmapHeight, bmap,
-			dibInfo,
-			DIB_RGB_COLORS);
-	/* VERIFY(res); */
-	
-	/* Create the GL object */
-	glNewList(i + listBase, GL_COMPILE);
-	glBitmap(bmapWidth, bmapHeight, 0.0, (GLfloat)metric.tmDescent,
-		 (GLfloat)charWidth, 0.0,
-		 bmap);
-	glEndList();
-	/* CheckGL(); */
-	
-	/* Destroy the bmap object */
-	DeleteObject(bitObject);
-	
-	/* Deallocate the bitmap data */
-	free(bmap);
-    }
-    
-    /* Destroy the DC */
-    VERIFY(DeleteDC(bitDevice));
-    
-    free(dibInfo);
-    
-    return TRUE;
-#undef VERIFY
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglUseFontBitmapsA(HDC hdc, DWORD first,
-					     DWORD count, DWORD listBase)
-{
-    int i;
-    GLuint font_list;
-    DWORD size;
-    GLYPHMETRICS gm;
-    HANDLE hBits;
-    LPSTR lpBits;
-    MAT2 mat;
-    int  success = TRUE;
-    
-    if (count == 0)
-	return FALSE;
-    
-    font_list = listBase;
-    
-    mat.eM11 = FixedFromDouble(1);
-    mat.eM12 = FixedFromDouble(0);
-    mat.eM21 = FixedFromDouble(0);
-    mat.eM22 = FixedFromDouble(-1);
-    
-    memset(&gm,0,sizeof(gm));
-    
-    /*
-    ** If we can't get the glyph outline, it may be because this is a fixed
-    ** font.  Try processing it that way.
-    */
-    if( GetGlyphOutline(hdc, first, GGO_BITMAP, &gm, 0, NULL, &mat)
-	== GDI_ERROR ) {
-	return wglUseFontBitmaps_FX( hdc, first, count, listBase );
-    }
-    
-    /*
-    ** Otherwise process all desired characters.
-    */
-    for (i = 0; i < (int)count; i++) {
-	DWORD err;
-	
-	glNewList( font_list+i, GL_COMPILE );
-	
-	/* allocate space for the bitmap/outline */
-	size = GetGlyphOutline(hdc, first + i, GGO_BITMAP, 
-			       &gm, 0, NULL, &mat);
-	if (size == GDI_ERROR) {
-	    glEndList( );
-	    err = GetLastError();
-	    success = FALSE;
-	    continue;
-	}
-	
-	hBits  = GlobalAlloc(GHND, size+1);
-	lpBits = GlobalLock(hBits);
-	
-	err = 
-	    GetGlyphOutline(hdc,         /* handle to device context */
-			    first + i,   /* character to query */
-			    GGO_BITMAP,  /* format of data to return */
-			    &gm,         /* ptr to structure for metrics*/
-			    size,        /* size of buffer for data */
-			    lpBits,      /* pointer to buffer for data */
-			    &mat         /* pointer to transformation */
-			    /* matrix structure */
-		);
-	
-	if (err == GDI_ERROR) {
-	    GlobalUnlock(hBits);
-	    GlobalFree(hBits);
-	    
-	    glEndList( );
-	    err = GetLastError();
-	    success = FALSE;
-	    continue;
-	}
-	
-	glBitmap(gm.gmBlackBoxX,gm.gmBlackBoxY,
-		 (GLfloat)-gm.gmptGlyphOrigin.x,
-		 (GLfloat)gm.gmptGlyphOrigin.y,
-		 (GLfloat)gm.gmCellIncX,
-		 (GLfloat)gm.gmCellIncY,
-		 (const GLubyte * )lpBits);
-	
-	GlobalUnlock(hBits);
-	GlobalFree(hBits);
-	
-	glEndList( );
-    }
-    
-    return success;
-}
-
-
-
-/* NOT IMPLEMENTED YET */
-WINGDIAPI BOOL GLAPIENTRY wglCopyContext(HGLRC hglrcSrc,
-					 HGLRC hglrcDst,
-					 UINT mask)
-{
-    (void) hglrcSrc; (void) hglrcDst; (void) mask;
-    return(FALSE);
-}
-
-WINGDIAPI HGLRC GLAPIENTRY wglCreateLayerContext(HDC hdc,
-						 int iLayerPlane)
-{
-    (void) hdc; (void) iLayerPlane;
-    SetLastError(0);
-    return(NULL);
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglShareLists(HGLRC hglrc1,
-					HGLRC hglrc2)
-{
-    (void) hglrc1; (void) hglrc2;
-    return(TRUE);
-}
-
-
-WINGDIAPI BOOL GLAPIENTRY wglUseFontBitmapsW(HDC hdc,
-					     DWORD first,
-					     DWORD count,
-					     DWORD listBase)
-{
-    (void) hdc; (void) first; (void) count; (void) listBase;
-    return FALSE;
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglUseFontOutlinesA(HDC hdc,
-					      DWORD first,
-					      DWORD count,
-					      DWORD listBase,
-					      FLOAT deviation,
-					      FLOAT extrusion,
-					      int format,
-					      LPGLYPHMETRICSFLOAT lpgmf)
-{
-    (void) hdc; (void) first; (void) count;
-    (void) listBase; (void) deviation; (void) extrusion; (void) format;
-    (void) lpgmf;
-    SetLastError(0);
-    return(FALSE);
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglUseFontOutlinesW(HDC hdc,
-					      DWORD first,
-					      DWORD count,
-					      DWORD listBase,
-					      FLOAT deviation,
-					      FLOAT extrusion,
-					      int format,
-					      LPGLYPHMETRICSFLOAT lpgmf)
-{
-    (void) hdc; (void) first; (void) count;
-    (void) listBase; (void) deviation; (void) extrusion; (void) format;
-    (void) lpgmf;
-    SetLastError(0);
-    return(FALSE);
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglDescribeLayerPlane(HDC hdc,
-						int iPixelFormat,
-						int iLayerPlane,
-						UINT nBytes,
-						LPLAYERPLANEDESCRIPTOR plpd)
-{
-    (void) hdc; (void) iPixelFormat; (void) iLayerPlane; 
-    (void) nBytes; (void) plpd;
-    SetLastError(0);
-    return(FALSE);
-}
-
-WINGDIAPI int GLAPIENTRY wglSetLayerPaletteEntries(HDC hdc,
-						   int iLayerPlane,
-						   int iStart,
-						   int cEntries,
-						   CONST COLORREF *pcr)
-{
-    (void) hdc; (void) iLayerPlane; (void) iStart; 
-    (void) cEntries; (void) pcr;
-    SetLastError(0);
-    return(0);
-}
-
-WINGDIAPI int GLAPIENTRY wglGetLayerPaletteEntries(HDC hdc,
-						   int iLayerPlane,
-						   int iStart,
-						   int cEntries,
-						   COLORREF *pcr)
-{
-    (void) hdc; (void) iLayerPlane; (void) iStart; (void) cEntries; (void) pcr;
-    SetLastError(0);
-    return(0);
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglRealizeLayerPalette(HDC hdc,
-						 int iLayerPlane,
-						 BOOL bRealize)
-{
-    (void) hdc; (void) iLayerPlane; (void) bRealize;
-    SetLastError(0);
-    return(FALSE);
-}
-
-WINGDIAPI BOOL GLAPIENTRY wglSwapLayerBuffers(HDC hdc,
-					      UINT fuPlanes)
-{
-    (void) hdc; (void) fuPlanes;
-    SetLastError(0);
-    return(FALSE);
-}
-
-WINGDIAPI const char * GLAPIENTRY wglGetExtensionsStringARB(HDC hdc)
-{
-    return "WGL_ARB_extensions_string";
-}
diff --git a/src/gallium/winsys/gdi/wmesa.c b/src/gallium/winsys/gdi/wmesa.c
deleted file mode 100644
index ed3dd2b927..0000000000
--- a/src/gallium/winsys/gdi/wmesa.c
+++ /dev/null
@@ -1,823 +0,0 @@
-/*
- * Windows (Win32/Win64) device driver for Mesa
- *
- */
-
-#include "mtypes.h"
-#include <GL/wmesa.h>
-#include "wmesadef.h"
-
-#undef Elements
-
-#include "pipe/p_winsys.h"
-#include "pipe/p_format.h"
-#include "pipe/p_context.h"
-#include "pipe/p_inlines.h"
-#include "util/u_memory.h"
-#include "softpipe/sp_winsys.h"
-#include "glapi/glapi.h"
-#include "colors.h"
-
-extern GLvisual *
-_mesa_create_visual( GLboolean rgbFlag,
-                     GLboolean dbFlag,
-                     GLboolean stereoFlag,
-                     GLint redBits,
-                     GLint greenBits,
-                     GLint blueBits,
-                     GLint alphaBits,
-                     GLint indexBits,
-                     GLint depthBits,
-                     GLint stencilBits,
-                     GLint accumRedBits,
-                     GLint accumGreenBits,
-                     GLint accumBlueBits,
-                     GLint accumAlphaBits,
-                     GLint numSamples );
-
-/* linked list of our Framebuffers (windows) */
-WMesaFramebuffer FirstFramebuffer = NULL;
-
-struct wmesa_pipe_winsys
-{
-   struct pipe_winsys base;
-};
-
-/**
- * Choose the pixel format for the given visual.
- * This will tell the gallium driver how to pack pixel data into
- * drawing surfaces.
- */
-static GLuint
-choose_pixel_format(GLvisual *v)
-{
-#if 1
-   return PIPE_FORMAT_A8R8G8B8_UNORM;
-#else
-   if (   GET_REDMASK(v)   == 0x0000ff
-       && GET_GREENMASK(v) == 0x00ff00
-       && GET_BLUEMASK(v)  == 0xff0000
-       && v->BitsPerPixel == 32) {
-      if (CHECK_BYTE_ORDER(v)) {
-         /* no byteswapping needed */
-         return 0 /* PIXEL_FORMAT_U_A8_B8_G8_R8 */;
-      }
-      else {
-         return PIPE_FORMAT_R8G8B8A8_UNORM;
-      }
-   }
-   else if (   GET_REDMASK(v)   == 0xff0000
-            && GET_GREENMASK(v) == 0x00ff00
-            && GET_BLUEMASK(v)  == 0x0000ff
-            && v->BitsPerPixel == 32) {
-      if (CHECK_BYTE_ORDER(v)) {
-         /* no byteswapping needed */
-         return PIPE_FORMAT_A8R8G8B8_UNORM;
-      }
-      else {
-         return PIPE_FORMAT_B8G8R8A8_UNORM;
-      }
-   }
-   else if (   GET_REDMASK(v)   == 0xf800
-            && GET_GREENMASK(v) == 0x07e0
-            && GET_BLUEMASK(v)  == 0x001f
-            && CHECK_BYTE_ORDER(v)
-            && v->BitsPerPixel == 16) {
-      /* 5-6-5 RGB */
-      return PIPE_FORMAT_R5G6B5_UNORM;
-   }
-
-printf("BITS %d\n",v->BitsPerPixel);
-   assert(0);
-   return 0;
-#endif
-}
-
-/*
- * Determine the pixel format based on the pixel size.
- */
-static void wmSetPixelFormat(WMesaFramebuffer pwfb, HDC hDC)
-{
-    /* Only 16 and 32 bit targets are supported now */
-    assert(pwfb->cColorBits == 0 ||
-	   pwfb->cColorBits == 16 || 
-	   pwfb->cColorBits == 32);
-
-    switch(pwfb->cColorBits){
-    case 8:
-	pwfb->pixelformat = PF_INDEX8;
-	break;
-    case 16:
-	pwfb->pixelformat = PF_5R6G5B;
-	break;
-    case 32:
-	pwfb->pixelformat = PF_8R8G8B;
-	break;
-    default:
-	pwfb->pixelformat = PF_BADFORMAT;
-    }
-}
-
-/**
- * Create a new WMesaFramebuffer object which will correspond to the
- * given HDC (Window handle).
- */
-WMesaFramebuffer
-wmesa_new_framebuffer(HDC hdc, GLvisual *visual, GLuint width, GLuint height)
-{
-    WMesaFramebuffer pwfb
-        = (WMesaFramebuffer) malloc(sizeof(struct wmesa_framebuffer));
-    if (pwfb) {
-   	enum pipe_format colorFormat, depthFormat, stencilFormat;
-
-   	/* determine PIPE_FORMATs for buffers */
-   	colorFormat = choose_pixel_format(visual);
-
-   	if (visual->depthBits == 0)
-      		depthFormat = PIPE_FORMAT_NONE;
-	else if (visual->depthBits <= 16)
-      		depthFormat = PIPE_FORMAT_Z16_UNORM;
-	else if (visual->depthBits <= 24)
-      		depthFormat = PIPE_FORMAT_S8Z24_UNORM;
-	else
-      		depthFormat = PIPE_FORMAT_Z32_UNORM;
-
-	if (visual->stencilBits == 8) {
-      		if (depthFormat == PIPE_FORMAT_S8Z24_UNORM)
-			stencilFormat = depthFormat;
-		else
-			stencilFormat = PIPE_FORMAT_S8_UNORM;
-   	}
-   	else {
-      		stencilFormat = PIPE_FORMAT_NONE;
-   	}
-
-   	pwfb->stfb = st_create_framebuffer(visual,
-                                   colorFormat, depthFormat, stencilFormat,
-                                   width, height,
-                                   (void *) pwfb);
-
-        pwfb->cColorBits = GetDeviceCaps(hdc, BITSPIXEL);
-
-        pwfb->hDC = hdc;
-        /* insert at head of list */
-	pwfb->next = FirstFramebuffer;
-        FirstFramebuffer = pwfb;
-    }
-    return pwfb;
-}
-
-/**
- * Given an hdc, free the corresponding WMesaFramebuffer
- */
-void
-wmesa_free_framebuffer(HDC hdc)
-{
-    WMesaFramebuffer pwfb, prev;
-    for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {
-        if (pwfb->hDC == hdc)
-            break;
-	prev = pwfb;
-    }
-    if (pwfb) {
-	if (pwfb == FirstFramebuffer)
-	    FirstFramebuffer = pwfb->next;
-	else
-	    prev->next = pwfb->next;
-	free(pwfb);
-    }
-}
-
-/**
- * Given an hdc, return the corresponding WMesaFramebuffer
- */
-WMesaFramebuffer
-wmesa_lookup_framebuffer(HDC hdc)
-{
-    WMesaFramebuffer pwfb;
-    for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {
-        if (pwfb->hDC == hdc)
-            return pwfb;
-    }
-    return NULL;
-}
-
-
-/**
- * Given a GLframebuffer, return the corresponding WMesaFramebuffer.
- */
-static WMesaFramebuffer wmesa_framebuffer(GLframebuffer *fb)
-{
-    return (WMesaFramebuffer) fb;
-}
-
-
-/**
- * Given a GLcontext, return the corresponding WMesaContext.
- */
-static WMesaContext wmesa_context(const GLcontext *ctx)
-{
-    return (WMesaContext) ctx;
-}
-
-/**
- * Find the width and height of the window named by hdc.
- */
-static void
-get_window_size(HDC hdc, GLuint *width, GLuint *height)
-{
-    if (WindowFromDC(hdc)) {
-        RECT rect;
-        GetClientRect(WindowFromDC(hdc), &rect);
-        *width = rect.right - rect.left;
-        *height = rect.bottom - rect.top;
-    }
-    else { /* Memory context */
-        /* From contributed code - use the size of the desktop
-         * for the size of a memory context (?) */
-        *width = GetDeviceCaps(hdc, HORZRES);
-        *height = GetDeviceCaps(hdc, VERTRES);
-    }
-}
-
-/**
- * Low-level OS/window system memory buffer
- */
-struct wm_buffer
-{
-   struct pipe_buffer base;
-   boolean userBuffer;  /** Is this a user-space buffer? */
-   void *data;
-   void *mapped;
-};
-
-struct wmesa_surface
-{
-   struct pipe_surface surface;
-
-   int no_swap;
-};
-
-
-/** Cast wrapper */
-static INLINE struct wmesa_surface *
-wmesa_surface(struct pipe_surface *ps)
-{
-//   assert(0);
-   return (struct wmesa_surface *) ps;
-}
-
-/**
- * Turn the softpipe opaque buffer pointer into a dri_bufmgr opaque
- * buffer pointer...
- */
-static INLINE struct wm_buffer *
-wm_buffer( struct pipe_buffer *buf )
-{
-   return (struct wm_buffer *)buf;
-}
-
-
-
-/* Most callbacks map direcly onto dri_bufmgr operations:
- */
-static void *
-wm_buffer_map(struct pipe_winsys *pws, struct pipe_buffer *buf,
-              unsigned flags)
-{
-   struct wm_buffer *wm_buf = wm_buffer(buf);
-   wm_buf->mapped = wm_buf->data;
-   return wm_buf->mapped;
-}
-
-static void
-wm_buffer_unmap(struct pipe_winsys *pws, struct pipe_buffer *buf)
-{
-   struct wm_buffer *wm_buf = wm_buffer(buf);
-   wm_buf->mapped = NULL;
-}
-
-static void
-wm_buffer_destroy(struct pipe_winsys *pws,
-                  struct pipe_buffer *buf)
-{
-   struct wm_buffer *oldBuf = wm_buffer(buf);
-
-   if (oldBuf->data) {
-      {
-         if (!oldBuf->userBuffer) {
-            align_free(oldBuf->data);
-         }
-      }
-
-      oldBuf->data = NULL;
-   }
-
-   free(oldBuf);
-}
-
-
-static void
-wm_flush_frontbuffer(struct pipe_winsys *pws,
-                     struct pipe_surface *surf,
-                     void *context_private)
-{
-    WMesaContext pwc = context_private;
-    WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(pwc->hDC);
-   struct wm_buffer *wm_buf;
-    BITMAPINFO bmi, *pbmi;
-
-    wm_buf = wm_buffer(surf->buffer);
-
-    pbmi = &bmi;
-    memset(pbmi, 0, sizeof(BITMAPINFO));
-    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-    pbmi->bmiHeader.biWidth = pwfb->stfb->Base.Width;
-    pbmi->bmiHeader.biHeight= -((long)pwfb->stfb->Base.Height);
-    pbmi->bmiHeader.biPlanes = 1;
-    pbmi->bmiHeader.biBitCount = pwfb->cColorBits;
-    pbmi->bmiHeader.biCompression = BI_RGB;
-    pbmi->bmiHeader.biSizeImage = 0;
-    pbmi->bmiHeader.biXPelsPerMeter = 0;
-    pbmi->bmiHeader.biYPelsPerMeter = 0;
-    pbmi->bmiHeader.biClrUsed = 0;
-    pbmi->bmiHeader.biClrImportant = 0;
-
-    StretchDIBits(pwfb->hDC, 0, 0, pwfb->stfb->Base.Width, pwfb->stfb->Base.Height, 0, 0, pwfb->stfb->Base.Width, pwfb->stfb->Base.Height, wm_buf->data, pbmi, 0, SRCCOPY);
-}
-
-
-
-static const char *
-wm_get_name(struct pipe_winsys *pws)
-{
-   return "gdi";
-}
-
-static struct pipe_buffer *
-wm_buffer_create(struct pipe_winsys *pws, 
-                 unsigned alignment, 
-                 unsigned usage,
-                 unsigned size)
-{
-   struct wm_buffer *buffer = CALLOC_STRUCT(wm_buffer);
-
-   buffer->base.refcount = 1;
-   buffer->base.alignment = alignment;
-   buffer->base.usage = usage;
-   buffer->base.size = size;
-
-   if (buffer->data == NULL) {
-      /* align to 16-byte multiple for Cell */
-      buffer->data = align_malloc(size, max(alignment, 16));
-   }
-
-   return &buffer->base;
-}
-
-
-/**
- * Create buffer which wraps user-space data.
- */
-static struct pipe_buffer *
-wm_user_buffer_create(struct pipe_winsys *pws, void *ptr, unsigned bytes)
-{
-   struct wm_buffer *buffer = CALLOC_STRUCT(wm_buffer);
-   buffer->base.refcount = 1;
-   buffer->base.size = bytes;
-   buffer->userBuffer = TRUE;
-   buffer->data = ptr;
-
-   return &buffer->base;
-}
-
-
-
-/**
- * Round n up to next multiple.
- */
-static INLINE unsigned
-round_up(unsigned n, unsigned multiple)
-{
-   return (n + multiple - 1) & ~(multiple - 1);
-}
-
-static int
-wm_surface_alloc_storage(struct pipe_winsys *winsys,
-                         struct pipe_surface *surf,
-                         unsigned width, unsigned height,
-                         enum pipe_format format, 
-                         unsigned flags,
-                         unsigned tex_usage)
-{
-   const unsigned alignment = 64;
-
-   surf->width = width;
-   surf->height = height;
-   surf->format = format;
-   pf_get_block(format, &surf->block);
-   surf->nblocksx = pf_get_nblocksx(&surf->block, width);
-   surf->nblocksy = pf_get_nblocksy(&surf->block, height);
-   surf->stride = round_up(surf->nblocksx * surf->block.size, alignment);
-
-   assert(!surf->buffer);
-   surf->buffer = winsys->buffer_create(winsys, alignment,
-                                        PIPE_BUFFER_USAGE_PIXEL,
-                                        surf->nblocksy * surf->stride);
-   if(!surf->buffer)
-      return -1;
-   
-   return 0;
-}
-
-
-/**
- * Called via winsys->surface_alloc() to create new surfaces.
- */
-static struct pipe_surface *
-wm_surface_alloc(struct pipe_winsys *ws)
-{
-   struct wmesa_surface *wms = CALLOC_STRUCT(wmesa_surface);
-   static boolean no_swap = 0;
-   static boolean firsttime = 1;
-
-   if (firsttime) {
-      no_swap = getenv("SP_NO_RAST") != NULL;
-      firsttime = 0;
-   }
-
-   assert(ws);
-
-   wms->surface.refcount = 1;
-   wms->surface.winsys = ws;
-
-   wms->no_swap = no_swap;
-   
-   return &wms->surface;
-}
-
-static void
-wm_surface_release(struct pipe_winsys *winsys, struct pipe_surface **s)
-{
-   struct pipe_surface *surf = *s;
-   surf->refcount--;
-   if (surf->refcount == 0) {
-      if (surf->buffer)
-	winsys_buffer_reference(winsys, &surf->buffer, NULL);
-      free(surf);
-   }
-   *s = NULL;
-}
-
-
-/*
- * Fence functions - basically nothing to do, as we don't create any actual
- * fence objects.
- */
-
-static void
-wm_fence_reference(struct pipe_winsys *sws, struct pipe_fence_handle **ptr,
-                   struct pipe_fence_handle *fence)
-{
-}
-
-
-static int
-wm_fence_signalled(struct pipe_winsys *sws, struct pipe_fence_handle *fence,
-                   unsigned flag)
-{
-   return 0;
-}
-
-
-static int
-wm_fence_finish(struct pipe_winsys *sws, struct pipe_fence_handle *fence,
-                unsigned flag)
-{
-   return 0;
-}
-
-
-
-struct pipe_winsys *
-wmesa_get_pipe_winsys(GLvisual *visual)
-{
-   static struct wmesa_pipe_winsys *ws = NULL;
-
-   if (!ws) {
-      ws = CALLOC_STRUCT(wmesa_pipe_winsys);
-
-      /* Fill in this struct with callbacks that pipe will need to
-       * communicate with the window system, buffer manager, etc. 
-       */
-      ws->base.buffer_create = wm_buffer_create;
-      ws->base.user_buffer_create = wm_user_buffer_create;
-      ws->base.buffer_map = wm_buffer_map;
-      ws->base.buffer_unmap = wm_buffer_unmap;
-      ws->base.buffer_destroy = wm_buffer_destroy;
-
-      ws->base.surface_alloc = wm_surface_alloc;
-      ws->base.surface_alloc_storage = wm_surface_alloc_storage;
-      ws->base.surface_release = wm_surface_release;
-
-      ws->base.fence_reference = wm_fence_reference;
-      ws->base.fence_signalled = wm_fence_signalled;
-      ws->base.fence_finish = wm_fence_finish;
-
-      ws->base.flush_frontbuffer = wm_flush_frontbuffer;
-      ws->base.get_name = wm_get_name;
-   }
-
-   return &ws->base;
-}
-
-
-
-/**********************************************************************/
-/*****                   WMESA Functions                          *****/
-/**********************************************************************/
-
-WMesaContext WMesaCreateContext(HDC hDC, 
-				HPALETTE* Pal,
-				GLboolean rgb_flag,
-				GLboolean db_flag,
-				GLboolean alpha_flag)
-{
-   WMesaContext c;
-   struct pipe_winsys *pws;
-   struct pipe_context *pipe;
-   struct pipe_screen *screen;
-   GLint red_bits, green_bits, blue_bits, alpha_bits;
-   GLvisual *visual;
-
-   (void) Pal;
-    
-   /* Indexed mode not supported */
-   if (!rgb_flag)
-	return NULL;
-
-   /* Allocate wmesa context */
-   c = CALLOC_STRUCT(wmesa_context);
-   if (!c)
-	return NULL;
-
-   c->hDC = hDC;
-
-    /* Get data for visual */
-    /* Dealing with this is actually a bit of overkill because Mesa will end
-     * up treating all color component size requests less than 8 by using 
-     * a single byte per channel.  In addition, the interface to the span
-     * routines passes colors as an entire byte per channel anyway, so there
-     * is nothing to be saved by telling the visual to be 16 bits if the device
-     * is 16 bits.  That is, Mesa is going to compute colors down to 8 bits per
-     * channel anyway.
-     * But we go through the motions here anyway.
-     */
-    c->cColorBits = GetDeviceCaps(c->hDC, BITSPIXEL);
-
-    switch (c->cColorBits) {
-    case 16:
-	red_bits = green_bits = blue_bits = 5;
-	alpha_bits = 0;
-	break;
-    default:
-	red_bits = green_bits = blue_bits = 8;
-	alpha_bits = 8;
-	break;
-    }
-    /* Create visual based on flags */
-    visual = _mesa_create_visual(rgb_flag,
-                                 db_flag,    /* db_flag */
-                                 GL_FALSE,   /* stereo */
-                                 red_bits, green_bits, blue_bits, /* color RGB */
-                                 alpha_flag ? alpha_bits : 0, /* color A */
-                                 0,          /* index bits */
-                                 DEFAULT_SOFTWARE_DEPTH_BITS, /* depth_bits */
-                                 8,          /* stencil_bits */
-                                 16,16,16,   /* accum RGB */
-                                 alpha_flag ? 16 : 0, /* accum A */
-                                 1);         /* num samples */
-    
-    if (!visual) {
-	_mesa_free(c);
-	return NULL;
-    }
-
-    pws = wmesa_get_pipe_winsys(visual);
-
-    screen = softpipe_create_screen(pws);
-
-    if (!screen) {
-        _mesa_free(c);
-	return NULL;
-   }
-
-   pipe = softpipe_create(screen, pws, NULL);
-
-   if (!pipe) {
-      /* FIXME - free screen */
-      _mesa_free(c);
-      return NULL;
-   }
-
-   pipe->priv = c;
-
-   c->st = st_create_context(pipe, visual, NULL);
-
-   c->st->ctx->DriverCtx = c;
-
-   return c;
-}
-
-
-void WMesaDestroyContext( WMesaContext pwc )
-{
-    GLcontext *ctx = pwc->st->ctx;
-    WMesaFramebuffer pwfb;
-    GET_CURRENT_CONTEXT(cur_ctx);
-
-    if (cur_ctx == ctx) {
-        /* unbind current if deleting current context */
-        WMesaMakeCurrent(NULL, NULL);
-    }
-
-    /* clean up frame buffer resources */
-    pwfb = wmesa_lookup_framebuffer(pwc->hDC);
-    if (pwfb) {
-	wmesa_free_framebuffer(pwc->hDC);
-    }
-
-    /* Release for device, not memory contexts */
-    if (WindowFromDC(pwc->hDC) != NULL)
-    {
-      ReleaseDC(WindowFromDC(pwc->hDC), pwc->hDC);
-    }
-    
-    st_destroy_context(pwc->st);
-    _mesa_free(pwc);
-}
-
-
-void WMesaMakeCurrent(WMesaContext c, HDC hdc)
-{
-    GLuint width = 0, height = 0;
-    WMesaFramebuffer pwfb;
-
-    {
-        /* return if already current */
-        GET_CURRENT_CONTEXT(ctx);
-        WMesaContext pwc = wmesa_context(ctx);
-        if (pwc && c == pwc && pwc->hDC == hdc)
-            return;
-    }
-
-    pwfb = wmesa_lookup_framebuffer(hdc);
-
-    if (hdc) {
-        get_window_size(hdc, &width, &height);
-    }
-
-    /* Lazy creation of framebuffers */
-    if (c && !pwfb && (hdc != 0)) {
-        GLvisual *visual = &c->st->ctx->Visual;
-
-        pwfb = wmesa_new_framebuffer(hdc, visual, width, height);
-    }
-
-    if (c && pwfb) {
-      	st_make_current(c->st, pwfb->stfb, pwfb->stfb);
-
-	st_resize_framebuffer(pwfb->stfb, width, height);
-   }
-   else {
-      /* Detach */
-      st_make_current( NULL, NULL, NULL );
-   }
-}
-
-
-void WMesaSwapBuffers( HDC hdc )
-{
-   struct pipe_surface *surf;
-   struct wm_buffer *wm_buf;
-    WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(hdc);
-    BITMAPINFO bmi, *pbmi;
-
-    if (!pwfb) {
-        _mesa_problem(NULL, "wmesa: swapbuffers on unknown hdc");
-        return;
-    }
-
-
-    /* If we're swapping the buffer associated with the current context
-     * we have to flush any pending rendering commands first.
-     */
-    st_notify_swapbuffers(pwfb->stfb);
-
-    surf = st_get_framebuffer_surface(pwfb->stfb, ST_SURFACE_BACK_LEFT);
-    wm_buf = wm_buffer(surf->buffer);
-
-    pbmi = &bmi;
-    memset(pbmi, 0, sizeof(BITMAPINFO));
-    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-    pbmi->bmiHeader.biWidth = pwfb->stfb->Base.Width;
-    pbmi->bmiHeader.biHeight= -((long)pwfb->stfb->Base.Height);
-    pbmi->bmiHeader.biPlanes = 1;
-    pbmi->bmiHeader.biBitCount = pwfb->cColorBits;
-    pbmi->bmiHeader.biCompression = BI_RGB;
-    pbmi->bmiHeader.biSizeImage = 0;
-    pbmi->bmiHeader.biXPelsPerMeter = 0;
-    pbmi->bmiHeader.biYPelsPerMeter = 0;
-    pbmi->bmiHeader.biClrUsed = 0;
-    pbmi->bmiHeader.biClrImportant = 0;
-
-    StretchDIBits(pwfb->hDC, 0, 0, pwfb->stfb->Base.Width, pwfb->stfb->Base.Height, 0, 0, pwfb->stfb->Base.Width, pwfb->stfb->Base.Height, wm_buf->data, pbmi, 0, SRCCOPY);
-
-    {
-        GLuint width = 0, height = 0;
-
-        get_window_size(pwfb->hDC, &width, &height);
-
-	st_resize_framebuffer(pwfb->stfb, width, height);
-    }
-}
-
-/* This is hopefully a temporary hack to define some needed dispatch
- * table entries.  Hopefully, I'll find a better solution.  The
- * dispatch table generation scripts ought to be making these dummy
- * stubs as well. */
-#if !defined(__MINGW32__) || !defined(GL_NO_STDCALL)
-void gl_dispatch_stub_543(void){}
-void gl_dispatch_stub_544(void){}
-void gl_dispatch_stub_545(void){}
-void gl_dispatch_stub_546(void){}
-void gl_dispatch_stub_547(void){}
-void gl_dispatch_stub_548(void){}
-void gl_dispatch_stub_549(void){}
-void gl_dispatch_stub_550(void){}
-void gl_dispatch_stub_551(void){}
-void gl_dispatch_stub_552(void){}
-void gl_dispatch_stub_553(void){}
-void gl_dispatch_stub_554(void){}
-void gl_dispatch_stub_555(void){}
-void gl_dispatch_stub_556(void){}
-void gl_dispatch_stub_557(void){}
-void gl_dispatch_stub_558(void){}
-void gl_dispatch_stub_559(void){}
-void gl_dispatch_stub_560(void){}
-void gl_dispatch_stub_561(void){}
-void gl_dispatch_stub_565(void){}
-void gl_dispatch_stub_566(void){}
-void gl_dispatch_stub_577(void){}
-void gl_dispatch_stub_578(void){}
-void gl_dispatch_stub_603(void){}
-void gl_dispatch_stub_645(void){}
-void gl_dispatch_stub_646(void){}
-void gl_dispatch_stub_647(void){}
-void gl_dispatch_stub_648(void){}
-void gl_dispatch_stub_649(void){}
-void gl_dispatch_stub_650(void){}
-void gl_dispatch_stub_651(void){}
-void gl_dispatch_stub_652(void){}
-void gl_dispatch_stub_653(void){}
-void gl_dispatch_stub_733(void){}
-void gl_dispatch_stub_734(void){}
-void gl_dispatch_stub_735(void){}
-void gl_dispatch_stub_736(void){}
-void gl_dispatch_stub_737(void){}
-void gl_dispatch_stub_738(void){}
-void gl_dispatch_stub_744(void){}
-void gl_dispatch_stub_745(void){}
-void gl_dispatch_stub_746(void){}
-void gl_dispatch_stub_760(void){}
-void gl_dispatch_stub_761(void){}
-void gl_dispatch_stub_763(void){}
-void gl_dispatch_stub_765(void){}
-void gl_dispatch_stub_766(void){}
-void gl_dispatch_stub_767(void){}
-void gl_dispatch_stub_768(void){}
-
-void gl_dispatch_stub_562(void){}
-void gl_dispatch_stub_563(void){}
-void gl_dispatch_stub_564(void){}
-void gl_dispatch_stub_567(void){}
-void gl_dispatch_stub_568(void){}
-void gl_dispatch_stub_569(void){}
-void gl_dispatch_stub_580(void){}
-void gl_dispatch_stub_581(void){}
-void gl_dispatch_stub_606(void){}
-void gl_dispatch_stub_654(void){}
-void gl_dispatch_stub_655(void){}
-void gl_dispatch_stub_656(void){}
-void gl_dispatch_stub_739(void){}
-void gl_dispatch_stub_740(void){}
-void gl_dispatch_stub_741(void){}
-void gl_dispatch_stub_748(void){}
-void gl_dispatch_stub_749(void){}
-void gl_dispatch_stub_769(void){}
-void gl_dispatch_stub_770(void){}
-void gl_dispatch_stub_771(void){}
-void gl_dispatch_stub_772(void){}
-void gl_dispatch_stub_773(void){}
-
-#endif
diff --git a/src/gallium/winsys/gdi/wmesadef.h b/src/gallium/winsys/gdi/wmesadef.h
deleted file mode 100644
index fb8ce30a08..0000000000
--- a/src/gallium/winsys/gdi/wmesadef.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef WMESADEF_H
-#define WMESADEF_H
-#ifdef __MINGW32__
-#include <windows.h>
-#endif
-#if 0
-#include "context.h"
-#endif
-#include "state_tracker/st_context.h"
-#include "state_tracker/st_public.h"
-
-
-/**
- * The Windows Mesa rendering context, derived from GLcontext.
- */
-struct wmesa_context {
-    struct st_context 	*st;
-    HDC                 hDC;
-    BYTE		cColorBits;
-};
-
-/**
- * Windows framebuffer, derived from gl_framebuffer
- */
-struct wmesa_framebuffer
-{
-    struct st_framebuffer *stfb;
-    HDC                 hDC;
-    int			pixelformat;
-    BYTE		cColorBits;
-    HDC                 dib_hDC;
-    HBITMAP             hbmDIB;
-    HBITMAP             hOldBitmap;
-    PBYTE               pbPixels;
-    struct wmesa_framebuffer *next;
-};
-
-typedef struct wmesa_framebuffer *WMesaFramebuffer;
-
-#endif /* WMESADEF_H */