moved windoze specific code outside drivers/glide/

3 files changed, 2143 insertions, 0 deletions

diff --git a/src/mesa/drivers/windows/fx/fx.rc b/src/mesa/drivers/windows/fx/fx.rc
new file mode 100644
index 0000000000..f920b8768d
--- /dev/null
+++ b/src/mesa/drivers/windows/fx/fx.rc
@@ -0,0 +1,39 @@
+#include <windows.h>
+
+#define PRODNAME                "Mesa 6.x"
+#define CONTACTSTR              "http://www.mesa3d.org"
+#define HWSTR                   "3dfx Voodoo Graphics, Voodoo Rush, Voodoo^2, Voodoo Banshee, Velocity 100/200, Voodoo3, Voodoo4, Voodoo5"
+#define COPYRIGHTSTR            "Copyright \251 Brian E. Paul"
+
+#define VERSIONSTR              "6.3.0.1"
+#define MANVERSION              6
+#define MANREVISION             3
+#define BUILD_NUMBER            1
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION MANVERSION, MANREVISION, 0, BUILD_NUMBER
+ PRODUCTVERSION MANVERSION, MANREVISION, 0, BUILD_NUMBER
+ FILEFLAGSMASK 0x0030003FL
+
+ FILEOS VOS_DOS_WINDOWS32
+ FILETYPE VFT_DRV
+ FILESUBTYPE VFT2_DRV_INSTALLABLE
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904E4"
+        BEGIN
+            VALUE "FileDescription", PRODNAME
+            VALUE "FileVersion", VERSIONSTR
+            VALUE "LegalCopyright", COPYRIGHTSTR
+            VALUE "ProductName", PRODNAME
+            VALUE "Graphics Subsystem", HWSTR
+            VALUE "Contact", CONTACTSTR
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        /* the following line should be extended for localized versions */
+        VALUE "Translation", 0x409, 1252
+    END
+END
diff --git a/src/mesa/drivers/windows/fx/fxopengl.def b/src/mesa/drivers/windows/fx/fxopengl.def
new file mode 100644
index 0000000000..fecbb253cf
--- /dev/null
+++ b/src/mesa/drivers/windows/fx/fxopengl.def
@@ -0,0 +1,938 @@
+LIBRARY OpenGL32
+DESCRIPTION "Mesa 5.1"
+EXPORTS
+ glAccum
+ glActiveStencilFaceEXT
+ glActiveTexture
+ glActiveTextureARB
+ glAlphaFunc
+ glAreProgramsResidentNV
+ glAreTexturesResident
+ glAreTexturesResidentEXT
+ glArrayElement
+ glArrayElementEXT
+ glBegin
+ glBeginQueryARB
+ glBindBufferARB
+ glBindProgramARB
+ glBindProgramNV
+ glBindTexture
+ glBindTextureEXT
+ glBitmap
+;glBlendColor
+;glBlendColorEXT
+ glBlendEquation
+ glBlendEquationEXT
+ glBlendFunc
+ glBlendFuncSeparate
+ glBlendFuncSeparateEXT
+ glBlendFuncSeparateINGR
+ glBufferDataARB
+ glBufferSubDataARB
+ glCallList
+ glCallLists
+ glClear
+ glClearAccum
+ glClearColor
+ glClearDepth
+ glClearIndex
+ glClearStencil
+ glClientActiveTexture
+ glClientActiveTextureARB
+ glClipPlane
+ glColorMask
+ glColorMaterial
+ glColorPointer
+ glColorPointerEXT
+ glColorSubTable
+ glColorSubTableEXT
+ glColorTable
+ glColorTableEXT
+ glColorTableParameterfv
+ glColorTableParameterfvSGI
+ glColorTableParameteriv
+ glColorTableParameterivSGI
+ glColorTableSGI
+ 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
+ glCombinerInputNV
+ glCombinerOutputNV
+ glCombinerParameterfNV
+ glCombinerParameterfvNV
+ glCombinerParameteriNV
+ glCombinerParameterivNV
+ glCompressedTexImage1D
+ glCompressedTexImage1DARB
+ glCompressedTexImage2D
+ glCompressedTexImage2DARB
+ glCompressedTexImage3D
+ glCompressedTexImage3DARB
+ glCompressedTexSubImage1D
+ glCompressedTexSubImage1DARB
+ glCompressedTexSubImage2D
+ glCompressedTexSubImage2DARB
+ glCompressedTexSubImage3D
+ glCompressedTexSubImage3DARB
+ glConvolutionFilter1D
+ glConvolutionFilter1DEXT
+ glConvolutionFilter2D
+ glConvolutionFilter2DEXT
+ glConvolutionParameterf
+ glConvolutionParameterfEXT
+ glConvolutionParameterfv
+ glConvolutionParameterfvEXT
+ glConvolutionParameteri
+ glConvolutionParameteriEXT
+ glConvolutionParameteriv
+ glConvolutionParameterivEXT
+ glCopyColorSubTable
+ glCopyColorSubTableEXT
+ glCopyColorTable
+ glCopyColorTableSGI
+ glCopyConvolutionFilter1D
+ glCopyConvolutionFilter1DEXT
+ glCopyConvolutionFilter2D
+ glCopyConvolutionFilter2DEXT
+ glCopyPixels
+ glCopyTexImage1D
+ glCopyTexImage1DEXT
+ glCopyTexImage2D
+ glCopyTexImage2DEXT
+ glCopyTexSubImage1D
+ glCopyTexSubImage1DEXT
+ glCopyTexSubImage2D
+ glCopyTexSubImage2DEXT
+ glCopyTexSubImage3D
+ glCopyTexSubImage3DEXT
+ glCullFace
+ glCullParameterdvEXT
+ glCullParameterfvEXT
+ glDeleteBuffersARB
+ glDeleteFencesNV
+ glDeleteLists
+ glDeleteProgramsARB
+ glDeleteProgramsNV
+ glDeleteQueriesARB
+ glDeleteTextures
+ glDeleteTexturesEXT
+ glDepthBoundsEXT
+ glDepthFunc
+ glDepthMask
+ glDepthRange
+ glDetailTexFuncSGIS
+ glDisable
+ glDisableClientState
+ glDisableVertexAttribArrayARB
+ glDrawArrays
+ glDrawArraysEXT
+ glDrawBuffer
+ glDrawElements
+ glDrawPixels
+ glDrawRangeElements
+ glDrawRangeElementsEXT
+ glEdgeFlag
+ glEdgeFlagPointer
+ glEdgeFlagPointerEXT
+ glEdgeFlagv
+ glEnable
+ glEnableClientState
+ glEnableVertexAttribArrayARB
+ glEnd
+ glEndList
+ glEndQueryARB
+ glEvalCoord1d
+ glEvalCoord1dv
+ glEvalCoord1f
+ glEvalCoord1fv
+ glEvalCoord2d
+ glEvalCoord2dv
+ glEvalCoord2f
+ glEvalCoord2fv
+ glEvalMesh1
+ glEvalMesh2
+ glEvalPoint1
+ glEvalPoint2
+ glExecuteProgramNV
+ glFeedbackBuffer
+ glFinalCombinerInputNV
+ glFinish
+ glFinishFenceNV
+ glFlush
+ glFlushRasterSGIX
+ glFlushVertexArrayRangeNV
+ glFogCoordd
+ glFogCoorddEXT
+ glFogCoorddv
+ glFogCoorddvEXT
+ glFogCoordf
+ glFogCoordfEXT
+ glFogCoordfv
+ glFogCoordfvEXT
+ glFogCoordPointer
+ glFogCoordPointerEXT
+ glFogf
+ glFogfv
+ glFogi
+ glFogiv
+ glFragmentColorMaterialSGIX
+ glFragmentLightfSGIX
+ glFragmentLightfvSGIX
+ glFragmentLightiSGIX
+ glFragmentLightivSGIX
+ glFragmentLightModelfSGIX
+ glFragmentLightModelfvSGIX
+ glFragmentLightModeliSGIX
+ glFragmentLightModelivSGIX
+ glFragmentMaterialfSGIX
+ glFragmentMaterialfvSGIX
+ glFragmentMaterialiSGIX
+ glFragmentMaterialivSGIX
+ glFrameZoomSGIX
+ glFrontFace
+ glFrustum
+ glGenBuffersARB
+ glGenFencesNV
+ glGenLists
+ glGenProgramsARB
+ glGenProgramsNV
+ glGenQueriesARB
+ glGenTextures
+ glGenTexturesEXT
+ glGetBooleanv
+ glGetBufferParameterivARB
+ glGetBufferPointervARB
+ glGetBufferSubDataARB
+ glGetClipPlane
+ glGetColorTable
+ glGetColorTableEXT
+ glGetColorTableParameterfv
+ glGetColorTableParameterfvEXT
+ glGetColorTableParameterfvSGI
+ glGetColorTableParameteriv
+ glGetColorTableParameterivEXT
+ glGetColorTableParameterivSGI
+ glGetColorTableSGI
+ glGetCombinerInputParameterfvNV
+ glGetCombinerInputParameterivNV
+ glGetCombinerOutputParameterfvNV
+ glGetCombinerOutputParameterivNV
+ glGetCompressedTexImage
+ glGetCompressedTexImageARB
+ glGetConvolutionFilter
+ glGetConvolutionFilterEXT
+ glGetConvolutionParameterfv
+ glGetConvolutionParameterfvEXT
+ glGetConvolutionParameteriv
+ glGetConvolutionParameterivEXT
+ glGetDetailTexFuncSGIS
+ glGetDoublev
+ glGetError
+ glGetFenceivNV
+ glGetFinalCombinerInputParameterfvNV
+ glGetFinalCombinerInputParameterivNV
+ glGetFloatv
+ glGetFragmentLightfvSGIX
+ glGetFragmentLightivSGIX
+ glGetFragmentMaterialfvSGIX
+ glGetFragmentMaterialivSGIX
+ glGetHistogram
+ glGetHistogramEXT
+ glGetHistogramParameterfv
+ glGetHistogramParameterfvEXT
+ glGetHistogramParameteriv
+ glGetHistogramParameterivEXT
+ glGetInstrumentsSGIX
+ glGetIntegerv
+ glGetLightfv
+ glGetLightiv
+ glGetListParameterfvSGIX
+ glGetListParameterivSGIX
+ glGetMapdv
+ glGetMapfv
+ glGetMapiv
+ glGetMaterialfv
+ glGetMaterialiv
+ glGetMinmax
+ glGetMinmaxEXT
+ glGetMinmaxParameterfv
+ glGetMinmaxParameterfvEXT
+ glGetMinmaxParameteriv
+ glGetMinmaxParameterivEXT
+ glGetPixelMapfv
+ glGetPixelMapuiv
+ glGetPixelMapusv
+ glGetPixelTexGenParameterfvSGIS
+ glGetPixelTexGenParameterivSGIS
+ glGetPointerv
+ glGetPointervEXT
+ glGetPolygonStipple
+ glGetProgramEnvParameterdvARB
+ glGetProgramEnvParameterfvARB
+ glGetProgramivARB
+ glGetProgramivNV
+ glGetProgramLocalParameterdvARB
+ glGetProgramLocalParameterfvARB
+ glGetProgramNamedParameterdvNV
+ glGetProgramNamedParameterfvNV
+ glGetProgramParameterdvNV
+ glGetProgramParameterfvNV
+ glGetProgramStringARB
+ glGetProgramStringNV
+ glGetQueryivARB
+ glGetQueryObjectivARB
+ glGetQueryObjectuivARB
+ glGetSeparableFilter
+ glGetSeparableFilterEXT
+ glGetSharpenTexFuncSGIS
+ glGetString
+ glGetTexEnvfv
+ glGetTexEnviv
+ glGetTexFilterFuncSGIS
+ glGetTexGendv
+ glGetTexGenfv
+ glGetTexGeniv
+ glGetTexImage
+ glGetTexLevelParameterfv
+ glGetTexLevelParameteriv
+ glGetTexParameterfv
+ glGetTexParameteriv
+ glGetTrackMatrixivNV
+ glGetVertexAttribdvARB
+ glGetVertexAttribdvNV
+ glGetVertexAttribfvARB
+ glGetVertexAttribfvNV
+ glGetVertexAttribivARB
+ glGetVertexAttribivNV
+ glGetVertexAttribPointervARB
+ glGetVertexAttribPointervNV
+ glHint
+ glHintPGI
+ glHistogram
+ glHistogramEXT
+ glIndexd
+ glIndexdv
+ glIndexf
+ glIndexFuncEXT
+ glIndexfv
+ glIndexi
+ glIndexiv
+ glIndexMask
+ glIndexMaterialEXT
+ glIndexPointer
+ glIndexPointerEXT
+ glIndexs
+ glIndexsv
+ glIndexub
+ glIndexubv
+ glInitNames
+ glInstrumentsBufferSGIX
+ glInterleavedArrays
+ glIsBufferARB
+ glIsEnabled
+ glIsFenceNV
+ glIsList
+ glIsProgramARB
+ glIsProgramNV
+ glIsQueryARB
+ glIsTexture
+ glIsTextureEXT
+ glLightEnviSGIX
+ glLightf
+ glLightfv
+ glLighti
+ glLightiv
+ glLightModelf
+ glLightModelfv
+ glLightModeli
+ glLightModeliv
+ glLineStipple
+ glLineWidth
+ glListBase
+ glListParameterfSGIX
+ glListParameterfvSGIX
+ glListParameteriSGIX
+ glListParameterivSGIX
+ glLoadIdentity
+ glLoadMatrixd
+ glLoadMatrixf
+ glLoadName
+ glLoadProgramNV
+ glLoadTransposeMatrixd
+ glLoadTransposeMatrixdARB
+ glLoadTransposeMatrixf
+ glLoadTransposeMatrixfARB
+ glLockArraysEXT
+ glLogicOp
+ glMapBufferARB
+ glMapGrid1d
+ glMapGrid1f
+ glMapGrid2d
+ glMapGrid2f
+ glMap1d
+ glMap1f
+ glMap2d
+ glMap2f
+ glMaterialf
+ glMaterialfv
+ glMateriali
+ glMaterialiv
+ glMatrixMode
+ glMinmax
+ glMinmaxEXT
+ glMultiDrawArrays
+ glMultiDrawArraysEXT
+ glMultiDrawElements
+ glMultiDrawElementsEXT
+ glMultiModeDrawArraysIBM
+ glMultiModeDrawElementsIBM
+ glMultiTexCoord1d
+ glMultiTexCoord1dARB
+ glMultiTexCoord1dv
+ glMultiTexCoord1dvARB
+ glMultiTexCoord1f
+ glMultiTexCoord1fARB
+ glMultiTexCoord1fv
+ glMultiTexCoord1fvARB
+ glMultiTexCoord1i
+ glMultiTexCoord1iARB
+ glMultiTexCoord1iv
+ glMultiTexCoord1ivARB
+ glMultiTexCoord1s
+ glMultiTexCoord1sARB
+ glMultiTexCoord1sv
+ glMultiTexCoord1svARB
+ glMultiTexCoord2d
+ glMultiTexCoord2dARB
+ glMultiTexCoord2dv
+ glMultiTexCoord2dvARB
+ glMultiTexCoord2f
+ glMultiTexCoord2fARB
+ glMultiTexCoord2fv
+ glMultiTexCoord2fvARB
+ glMultiTexCoord2i
+ glMultiTexCoord2iARB
+ glMultiTexCoord2iv
+ glMultiTexCoord2ivARB
+ glMultiTexCoord2s
+ glMultiTexCoord2sARB
+ glMultiTexCoord2sv
+ glMultiTexCoord2svARB
+ glMultiTexCoord3d
+ glMultiTexCoord3dARB
+ glMultiTexCoord3dv
+ glMultiTexCoord3dvARB
+ glMultiTexCoord3f
+ glMultiTexCoord3fARB
+ glMultiTexCoord3fv
+ glMultiTexCoord3fvARB
+ glMultiTexCoord3i
+ glMultiTexCoord3iARB
+ glMultiTexCoord3iv
+ glMultiTexCoord3ivARB
+ glMultiTexCoord3s
+ glMultiTexCoord3sARB
+ glMultiTexCoord3sv
+ glMultiTexCoord3svARB
+ glMultiTexCoord4d
+ glMultiTexCoord4dARB
+ glMultiTexCoord4dv
+ glMultiTexCoord4dvARB
+ glMultiTexCoord4f
+ glMultiTexCoord4fARB
+ glMultiTexCoord4fv
+ glMultiTexCoord4fvARB
+ glMultiTexCoord4i
+ glMultiTexCoord4iARB
+ glMultiTexCoord4iv
+ glMultiTexCoord4ivARB
+ glMultiTexCoord4s
+ glMultiTexCoord4sARB
+ glMultiTexCoord4sv
+ glMultiTexCoord4svARB
+ glMultMatrixd
+ glMultMatrixf
+ glMultTransposeMatrixd
+ glMultTransposeMatrixdARB
+ glMultTransposeMatrixf
+ glMultTransposeMatrixfARB
+ glNewList
+ glNormalPointer
+ glNormalPointerEXT
+ glNormal3b
+ glNormal3bv
+ glNormal3d
+ glNormal3dv
+ glNormal3f
+ glNormal3fv
+ glNormal3i
+ glNormal3iv
+ glNormal3s
+ glNormal3sv
+ glOrtho
+ glPassThrough
+ glPixelMapfv
+ glPixelMapuiv
+ glPixelMapusv
+ glPixelStoref
+ glPixelStorei
+ glPixelTexGenParameterfSGIS
+ glPixelTexGenParameterfvSGIS
+ glPixelTexGenParameteriSGIS
+ glPixelTexGenParameterivSGIS
+ glPixelTexGenSGIX
+ glPixelTransferf
+ glPixelTransferi
+ glPixelZoom
+ glPointParameterf
+ glPointParameterfARB
+ glPointParameterfEXT
+ glPointParameterfSGIS
+ glPointParameterfv
+ glPointParameterfvARB
+ glPointParameterfvEXT
+ glPointParameterfvSGIS
+ glPointParameteri
+ glPointParameteriNV
+ glPointParameteriv
+ glPointParameterivNV
+ glPointSize
+ glPollInstrumentsSGIX
+ glPolygonMode
+ glPolygonOffset
+ glPolygonOffsetEXT
+ glPolygonStipple
+ glPopAttrib
+ glPopClientAttrib
+ glPopMatrix
+ glPopName
+ glPrioritizeTextures
+ glPrioritizeTexturesEXT
+ glProgramEnvParameter4dARB
+ glProgramEnvParameter4dvARB
+ glProgramEnvParameter4fARB
+ glProgramEnvParameter4fvARB
+ glProgramLocalParameter4dARB
+ glProgramLocalParameter4dvARB
+ glProgramLocalParameter4fARB
+ glProgramLocalParameter4fvARB
+ glProgramNamedParameter4dNV
+ glProgramNamedParameter4dvNV
+ glProgramNamedParameter4fNV
+ glProgramNamedParameter4fvNV
+ glProgramParameters4dvNV
+ glProgramParameters4fvNV
+ glProgramParameter4dNV
+ glProgramParameter4dvNV
+ glProgramParameter4fNV
+ glProgramParameter4fvNV
+ glProgramStringARB
+ glPushAttrib
+ glPushClientAttrib
+ glPushMatrix
+ glPushName
+ glRasterPos2d
+ glRasterPos2dv
+ glRasterPos2f
+ glRasterPos2fv
+ glRasterPos2i
+ glRasterPos2iv
+ glRasterPos2s
+ glRasterPos2sv
+ glRasterPos3d
+ glRasterPos3dv
+ glRasterPos3f
+ glRasterPos3fv
+ glRasterPos3i
+ glRasterPos3iv
+ glRasterPos3s
+ glRasterPos3sv
+ glRasterPos4d
+ glRasterPos4dv
+ glRasterPos4f
+ glRasterPos4fv
+ glRasterPos4i
+ glRasterPos4iv
+ glRasterPos4s
+ glRasterPos4sv
+ glReadBuffer
+ glReadInstrumentsSGIX
+ glReadPixels
+ glRectd
+ glRectdv
+ glRectf
+ glRectfv
+ glRecti
+ glRectiv
+ glRects
+ glRectsv
+ glReferencePlaneSGIX
+ glRenderMode
+ glRequestResidentProgramsNV
+ glResetHistogram
+ glResetHistogramEXT
+ glResetMinmax
+ glResetMinmaxEXT
+ glResizeBuffersMESA
+ glRotated
+ glRotatef
+ glSampleCoverage
+ glSampleCoverageARB
+ glSampleMaskEXT
+ glSampleMaskSGIS
+ glSamplePatternEXT
+ glSamplePatternSGIS
+ glScaled
+ glScalef
+ glScissor
+ glSecondaryColorPointer
+ glSecondaryColorPointerEXT
+ glSecondaryColor3b
+ glSecondaryColor3bEXT
+ glSecondaryColor3bv
+ glSecondaryColor3bvEXT
+ glSecondaryColor3d
+ glSecondaryColor3dEXT
+ glSecondaryColor3dv
+ glSecondaryColor3dvEXT
+ glSecondaryColor3f
+ glSecondaryColor3fEXT
+ glSecondaryColor3fv
+ glSecondaryColor3fvEXT
+ glSecondaryColor3i
+ glSecondaryColor3iEXT
+ glSecondaryColor3iv
+ glSecondaryColor3ivEXT
+ glSecondaryColor3s
+ glSecondaryColor3sEXT
+ glSecondaryColor3sv
+ glSecondaryColor3svEXT
+ glSecondaryColor3ub
+ glSecondaryColor3ubEXT
+ glSecondaryColor3ubv
+ glSecondaryColor3ubvEXT
+ glSecondaryColor3ui
+ glSecondaryColor3uiEXT
+ glSecondaryColor3uiv
+ glSecondaryColor3uivEXT
+ glSecondaryColor3us
+ glSecondaryColor3usEXT
+ glSecondaryColor3usv
+ glSecondaryColor3usvEXT
+ glSelectBuffer
+ glSeparableFilter2D
+ glSeparableFilter2DEXT
+ glSetFenceNV
+ glShadeModel
+ glSharpenTexFuncSGIS
+ glSpriteParameterfSGIX
+ glSpriteParameterfvSGIX
+ glSpriteParameteriSGIX
+ glSpriteParameterivSGIX
+ glStartInstrumentsSGIX
+ glStencilFunc
+ glStencilMask
+ glStencilOp
+ glStopInstrumentsSGIX
+ glTagSampleBufferSGIX
+ glTbufferMask3DFX
+ glTestFenceNV
+ glTexCoordPointer
+ glTexCoordPointerEXT
+ 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
+ glTexEnvf
+ glTexEnvfv
+ glTexEnvi
+ glTexEnviv
+ glTexFilterFuncSGIS
+ glTexGend
+ glTexGendv
+ glTexGenf
+ glTexGenfv
+ glTexGeni
+ glTexGeniv
+ glTexImage1D
+ glTexImage2D
+ glTexImage3D
+ glTexImage3DEXT
+ glTexImage4DSGIS
+ glTexParameterf
+ glTexParameterfv
+ glTexParameteri
+ glTexParameteriv
+ glTexSubImage1D
+ glTexSubImage1DEXT
+ glTexSubImage2D
+ glTexSubImage2DEXT
+ glTexSubImage3D
+ glTexSubImage3DEXT
+ glTexSubImage4DSGIS
+ glTrackMatrixNV
+ glTranslated
+ glTranslatef
+ glUnlockArraysEXT
+ glUnmapBufferARB
+ glVertexArrayRangeNV
+ glVertexAttribPointerARB
+ glVertexAttribPointerNV
+ glVertexAttribs1dvNV
+ glVertexAttribs1fvNV
+ glVertexAttribs1svNV
+ glVertexAttribs2dvNV
+ glVertexAttribs2fvNV
+ glVertexAttribs2svNV
+ glVertexAttribs3dvNV
+ glVertexAttribs3fvNV
+ glVertexAttribs3svNV
+ glVertexAttribs4dvNV
+ glVertexAttribs4fvNV
+ glVertexAttribs4svNV
+ glVertexAttribs4ubvNV
+ glVertexAttrib1dARB
+ glVertexAttrib1dNV
+ glVertexAttrib1dvARB
+ glVertexAttrib1dvNV
+ glVertexAttrib1fARB
+ glVertexAttrib1fNV
+ glVertexAttrib1fvARB
+ glVertexAttrib1fvNV
+ glVertexAttrib1sARB
+ glVertexAttrib1sNV
+ glVertexAttrib1svARB
+ glVertexAttrib1svNV
+ glVertexAttrib2dARB
+ glVertexAttrib2dNV
+ glVertexAttrib2dvARB
+ glVertexAttrib2dvNV
+ glVertexAttrib2fARB
+ glVertexAttrib2fNV
+ glVertexAttrib2fvARB
+ glVertexAttrib2fvNV
+ glVertexAttrib2sARB
+ glVertexAttrib2sNV
+ glVertexAttrib2svARB
+ glVertexAttrib2svNV
+ glVertexAttrib3dARB
+ glVertexAttrib3dNV
+ glVertexAttrib3dvARB
+ glVertexAttrib3dvNV
+ glVertexAttrib3fARB
+ glVertexAttrib3fNV
+ glVertexAttrib3fvARB
+ glVertexAttrib3fvNV
+ glVertexAttrib3sARB
+ glVertexAttrib3sNV
+ glVertexAttrib3svARB
+ glVertexAttrib3svNV
+ glVertexAttrib4bvARB
+ glVertexAttrib4dARB
+ glVertexAttrib4dNV
+ glVertexAttrib4dvARB
+ glVertexAttrib4dvNV
+ glVertexAttrib4fARB
+ glVertexAttrib4fNV
+ glVertexAttrib4fvARB
+ glVertexAttrib4fvNV
+ glVertexAttrib4ivARB
+ glVertexAttrib4NbvARB
+ glVertexAttrib4NivARB
+ glVertexAttrib4NsvARB
+ glVertexAttrib4NubARB
+ glVertexAttrib4NubvARB
+ glVertexAttrib4NuivARB
+ glVertexAttrib4NusvARB
+ glVertexAttrib4sARB
+ glVertexAttrib4sNV
+ glVertexAttrib4svARB
+ glVertexAttrib4svNV
+ glVertexAttrib4ubNV
+ glVertexAttrib4ubvARB
+ glVertexAttrib4ubvNV
+ glVertexAttrib4uivARB
+ glVertexAttrib4usvARB
+ glVertexPointer
+ glVertexPointerEXT
+ glVertexWeightfEXT
+ glVertexWeightfvEXT
+ glVertexWeightPointerEXT
+ glVertex2d
+ glVertex2dv
+ glVertex2f
+ glVertex2fv
+ glVertex2i
+ glVertex2iv
+ glVertex2s
+ glVertex2sv
+ glVertex3d
+ glVertex3dv
+ glVertex3f
+ glVertex3fv
+ glVertex3i
+ glVertex3iv
+ glVertex3s
+ glVertex3sv
+ glVertex4d
+ glVertex4dv
+ glVertex4f
+ glVertex4fv
+ glVertex4i
+ glVertex4iv
+ glVertex4s
+ glVertex4sv
+ glViewport
+ glWindowPos2d
+ glWindowPos2dARB
+ glWindowPos2dMESA
+ glWindowPos2dv
+ glWindowPos2dvARB
+ glWindowPos2dvMESA
+ glWindowPos2f
+ glWindowPos2fARB
+ glWindowPos2fMESA
+ glWindowPos2fv
+ glWindowPos2fvARB
+ glWindowPos2fvMESA
+ glWindowPos2i
+ glWindowPos2iARB
+ glWindowPos2iMESA
+ glWindowPos2iv
+ glWindowPos2ivARB
+ glWindowPos2ivMESA
+ glWindowPos2s
+ glWindowPos2sARB
+ glWindowPos2sMESA
+ glWindowPos2sv
+ glWindowPos2svARB
+ glWindowPos2svMESA
+ glWindowPos3d
+ glWindowPos3dARB
+ glWindowPos3dMESA
+ glWindowPos3dv
+ glWindowPos3dvARB
+ glWindowPos3dvMESA
+ glWindowPos3f
+ glWindowPos3fARB
+ glWindowPos3fMESA
+ glWindowPos3fv
+ glWindowPos3fvARB
+ glWindowPos3fvMESA
+ glWindowPos3i
+ glWindowPos3iARB
+ glWindowPos3iMESA
+ glWindowPos3iv
+ glWindowPos3ivARB
+ glWindowPos3ivMESA
+ glWindowPos3s
+ glWindowPos3sARB
+ glWindowPos3sMESA
+ glWindowPos3sv
+ glWindowPos3svARB
+ glWindowPos3svMESA
+ glWindowPos4dMESA
+ glWindowPos4dvMESA
+ glWindowPos4fMESA
+ glWindowPos4fvMESA
+ glWindowPos4iMESA
+ glWindowPos4ivMESA
+ glWindowPos4sMESA
+ glWindowPos4svMESA
+ fxCloseHardware
+;fxGetScreenGeometry
+ fxMesaCreateBestContext
+ fxMesaCreateContext
+ fxMesaDestroyContext
+ fxMesaGetCurrentContext
+ fxMesaMakeCurrent
+ fxMesaSelectCurrentBoard
+;fxMesaSetNearFar
+ fxMesaSwapBuffers
+ fxMesaUpdateScreenSize
+ wglChoosePixelFormat
+ wglCopyContext
+ wglCreateContext
+ wglCreateLayerContext
+ wglDeleteContext
+ wglDescribeLayerPlane
+ wglDescribePixelFormat
+ wglGetCurrentContext
+ wglGetCurrentDC
+ wglGetDefaultProcAddress
+ wglGetLayerPaletteEntries
+ wglGetPixelFormat
+ wglGetProcAddress
+ wglMakeCurrent
+ wglRealizeLayerPalette
+ wglSetLayerPaletteEntries
+ wglSetPixelFormat
+ wglShareLists
+ wglSwapBuffers
+ wglSwapLayerBuffers
+ wglUseFontBitmapsA
+ wglUseFontBitmapsW
+ wglUseFontOutlinesA
+ wglUseFontOutlinesW
+ ChoosePixelFormat
+ DescribePixelFormat
+ GetPixelFormat
+ SetPixelFormat
+ SwapBuffers
diff --git a/src/mesa/drivers/windows/fx/fxwgl.c b/src/mesa/drivers/windows/fx/fxwgl.c
new file mode 100644
index 0000000000..d9eb342138
--- /dev/null
+++ b/src/mesa/drivers/windows/fx/fxwgl.c
@@ -0,0 +1,1166 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* Authors:
+ *    David Bucciarelli
+ *    Brian Paul
+ *    Keith Whitwell
+ *    Hiroshi Morii
+ *    Daniel Borca
+ */
+
+/* fxwgl.c - Microsoft wgl functions emulation for
+ *           3Dfx VooDoo/Mesa interface
+ */
+
+
+#ifdef _WIN32
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <windows.h>
+#define GL_GLEXT_PROTOTYPES
+#include "GL/gl.h"
+#include "GL/glext.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#include "GL/fxmesa.h"
+#include "glheader.h"
+#include "glapi.h"
+#include "imports.h"
+#include "fxdrv.h"
+
+#define MAX_MESA_ATTRS  20
+
+#if (_MSC_VER >= 1200)
+#pragma warning( push )
+#pragma warning( disable : 4273 )
+#endif
+
+struct __extensions__
+{
+   PROC proc;
+   char *name;
+};
+
+struct __pixelformat__
+{
+   PIXELFORMATDESCRIPTOR pfd;
+   GLint mesaAttr[MAX_MESA_ATTRS];
+};
+
+WINGDIAPI void GLAPIENTRY gl3DfxSetPaletteEXT(GLuint *);
+static GLushort gammaTable[3*256];
+
+struct __pixelformat__ pix[] = {
+   /* 16bit RGB565 single buffer with depth */
+   {
+    {sizeof(PIXELFORMATDESCRIPTOR), 1,
+     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL,
+     PFD_TYPE_RGBA,
+     16,
+     5, 0, 6, 5, 5, 11, 0, 0,
+     0, 0, 0, 0, 0,
+     16,
+     0,
+     0,
+     PFD_MAIN_PLANE,
+     0, 0, 0, 0}
+    ,
+    {FXMESA_COLORDEPTH, 16,
+     FXMESA_ALPHA_SIZE, 0,
+     FXMESA_DEPTH_SIZE, 16,
+     FXMESA_STENCIL_SIZE, 0,
+     FXMESA_ACCUM_SIZE, 0,
+     FXMESA_NONE}
+   }
+   ,
+   /* 16bit RGB565 double buffer with depth */
+   {
+    {sizeof(PIXELFORMATDESCRIPTOR), 1,
+     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
+     PFD_DOUBLEBUFFER | PFD_SWAP_COPY,
+     PFD_TYPE_RGBA,
+     16,
+     5, 0, 6, 5, 5, 11, 0, 0,
+     0, 0, 0, 0, 0,
+     16,
+     0,
+     0,
+     PFD_MAIN_PLANE,
+     0, 0, 0, 0}
+    ,
+    {FXMESA_COLORDEPTH, 16,
+     FXMESA_DOUBLEBUFFER,
+     FXMESA_ALPHA_SIZE, 0,
+     FXMESA_DEPTH_SIZE, 16,
+     FXMESA_STENCIL_SIZE, 0,
+     FXMESA_ACCUM_SIZE, 0,
+     FXMESA_NONE}
+   }
+   ,
+   /* 16bit ARGB1555 single buffer with depth */
+   {
+    {sizeof(PIXELFORMATDESCRIPTOR), 1,
+     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL,
+     PFD_TYPE_RGBA,
+     16,
+     5, 0, 5, 5, 5, 10, 1, 15,
+     0, 0, 0, 0, 0,
+     16,
+     0,
+     0,
+     PFD_MAIN_PLANE,
+     0, 0, 0, 0}
+    ,
+    {FXMESA_COLORDEPTH, 15,
+     FXMESA_ALPHA_SIZE, 1,
+     FXMESA_DEPTH_SIZE, 16,
+     FXMESA_STENCIL_SIZE, 0,
+     FXMESA_ACCUM_SIZE, 0,
+     FXMESA_NONE}
+   }
+   ,
+   /* 16bit ARGB1555 double buffer with depth */
+   {
+    {sizeof(PIXELFORMATDESCRIPTOR), 1,
+     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
+     PFD_DOUBLEBUFFER | PFD_SWAP_COPY,
+     PFD_TYPE_RGBA,
+     16,
+     5, 0, 5, 5, 5, 10, 1, 15,
+     0, 0, 0, 0, 0,
+     16,
+     0,
+     0,
+     PFD_MAIN_PLANE,
+     0, 0, 0, 0}
+    ,
+    {FXMESA_COLORDEPTH, 15,
+     FXMESA_DOUBLEBUFFER,
+     FXMESA_ALPHA_SIZE, 1,
+     FXMESA_DEPTH_SIZE, 16,
+     FXMESA_STENCIL_SIZE, 0,
+     FXMESA_ACCUM_SIZE, 0,
+     FXMESA_NONE}
+   }
+   ,
+   /* 32bit ARGB8888 single buffer with depth */
+   {
+    {sizeof(PIXELFORMATDESCRIPTOR), 1,
+     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL,
+     PFD_TYPE_RGBA,
+     32,
+     8, 0, 8, 8, 8, 16, 8, 24,
+     0, 0, 0, 0, 0,
+     24,
+     8,
+     0,
+     PFD_MAIN_PLANE,
+     0, 0, 0, 0}
+    ,
+    {FXMESA_COLORDEPTH, 32,
+     FXMESA_ALPHA_SIZE, 8,
+     FXMESA_DEPTH_SIZE, 24,
+     FXMESA_STENCIL_SIZE, 8,
+     FXMESA_ACCUM_SIZE, 0,
+     FXMESA_NONE}
+   }
+   ,
+   /* 32bit ARGB8888 double buffer with depth */
+   {
+    {sizeof(PIXELFORMATDESCRIPTOR), 1,
+     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
+     PFD_DOUBLEBUFFER | PFD_SWAP_COPY,
+     PFD_TYPE_RGBA,
+     32,
+     8, 0, 8, 8, 8, 16, 8, 24,
+     0, 0, 0, 0, 0,
+     24,
+     8,
+     0,
+     PFD_MAIN_PLANE,
+     0, 0, 0, 0}
+    ,
+    {FXMESA_COLORDEPTH, 32,
+     FXMESA_DOUBLEBUFFER,
+     FXMESA_ALPHA_SIZE, 8,
+     FXMESA_DEPTH_SIZE, 24,
+     FXMESA_STENCIL_SIZE, 8,
+     FXMESA_ACCUM_SIZE, 0,
+     FXMESA_NONE}
+   }
+};
+
+static fxMesaContext ctx = NULL;
+static WNDPROC hWNDOldProc;
+static int curPFD = 0;
+static HDC hDC;
+static HWND hWND;
+
+static GLboolean haveDualHead;
+
+/* For the in-window-rendering hack */
+
+#ifndef GR_CONTROL_RESIZE
+/* Apparently GR_CONTROL_RESIZE can be ignored. OK? */
+#define GR_CONTROL_RESIZE -1
+#endif
+
+static GLboolean gdiWindowHack;
+static void *dibSurfacePtr;
+static BITMAPINFO *dibBMI;
+static HBITMAP dibHBM;
+static HWND dibWnd;
+
+static int env_check (const char *var, int val)
+{
+ const char *env = getenv(var);
+ return (env && (env[0] == val));
+}
+
+static LRESULT APIENTRY 
+__wglMonitor(HWND hwnd, UINT message, UINT wParam, LONG lParam)
+ {
+   long ret;			/* Now gives the resized window at the end to hWNDOldProc */
+
+   if (ctx && hwnd == hWND) {
+     switch (message) {
+       case WM_PAINT:
+       case WM_MOVE:
+	   break;
+       case WM_DISPLAYCHANGE:
+       case WM_SIZE:
+#if 0
+       if (wParam != SIZE_MINIMIZED) {
+         static int moving = 0;
+         if (!moving) {
+           if (!FX_grSstControl(GR_CONTROL_RESIZE)) {
+             moving = 1;
+             SetWindowPos(hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE | SWP_NOZORDER);
+             moving = 0;
+             if (!FX_grSstControl(GR_CONTROL_RESIZE)) {
+               /*MessageBox(0,_T("Error changing windowsize"),_T("fxMESA"),MB_OK); */
+               PostMessage(hWND, WM_CLOSE, 0, 0);
+		     }
+		   }
+	       /* Do the clipping in the glide library */
+	       grClipWindow(0, 0, FX_grSstScreenWidth(), FX_grSstScreenHeight());
+           /* And let the new size set in the context */
+           fxMesaUpdateScreenSize(ctx);
+	     }
+	   }
+#endif
+       break;
+       case WM_ACTIVATE:
+       break;
+       case WM_SHOWWINDOW:
+	   break;
+       case WM_SYSKEYDOWN:
+       case WM_SYSCHAR:
+	   break;
+     }
+   }
+
+   /* Finaly call the hWNDOldProc, which handles the resize witch the
+      now changed window sizes */
+   ret = CallWindowProc(hWNDOldProc, hwnd, message, wParam, lParam);
+
+   return (ret);
+}
+
+static void wgl_error (long error)
+{
+#define WGL_INVALID_PIXELFORMAT ERROR_INVALID_PIXEL_FORMAT
+ SetLastError(0xC0000000 /* error severity */
+             |0x00070000 /* error facility (who we are) */
+             |error);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask)
+{
+   return (FALSE);
+}
+
+GLAPI HGLRC GLAPIENTRY
+wglCreateContext(HDC hdc)
+{
+   HWND hWnd;
+   WNDPROC oldProc;
+   int error;
+
+   if (ctx) {
+      SetLastError(0);
+      return (NULL);
+   }
+
+   if (!(hWnd = WindowFromDC(hdc))) {
+      SetLastError(0);
+      return (NULL);
+   }
+
+   if (curPFD == 0) {
+      wgl_error(WGL_INVALID_PIXELFORMAT);
+      return (NULL);
+   }
+
+   if ((oldProc = (WNDPROC) GetWindowLong(hWnd, GWL_WNDPROC)) != __wglMonitor) {
+      hWNDOldProc = oldProc;
+      SetWindowLong(hWnd, GWL_WNDPROC, (LONG) __wglMonitor);
+   }
+
+   /* always log when debugging, or if user demands */
+   if (TDFX_DEBUG || env_check("MESA_FX_INFO", 'r')) {
+      freopen("MESA.LOG", "w", stderr);
+   }
+
+   {
+     RECT cliRect;
+     ShowWindow(hWnd, SW_SHOWNORMAL);
+     SetForegroundWindow(hWnd);
+     Sleep(100); /* a hack for win95 */
+     if (env_check("MESA_GLX_FX", 'w') && !(GetWindowLong (hWnd, GWL_STYLE) & WS_POPUP)) {
+	/* XXX todo - windowed modes */
+        error = !(ctx = fxMesaCreateContext((GLuint) hWnd, GR_RESOLUTION_NONE, GR_REFRESH_NONE, pix[curPFD - 1].mesaAttr));
+     } else {
+        GetClientRect(hWnd, &cliRect);
+        error = !(ctx = fxMesaCreateBestContext((GLuint) hWnd, cliRect.right, cliRect.bottom, pix[curPFD - 1].mesaAttr));
+     }
+   }
+
+   /*if (getenv("SST_DUALHEAD"))
+      haveDualHead =
+	 ((atoi(getenv("SST_DUALHEAD")) == 1) ? GL_TRUE : GL_FALSE);
+   else
+      haveDualHead = GL_FALSE;*/
+
+   if (error) {
+      SetLastError(0);
+      return (NULL);
+   }
+
+   hDC = hdc;
+   hWND = hWnd;
+
+   /* Required by the OpenGL Optimizer 1.1 (is it a Optimizer bug ?) */
+   wglMakeCurrent(hdc, (HGLRC) 1);
+
+   return ((HGLRC) 1);
+}
+
+GLAPI HGLRC GLAPIENTRY
+wglCreateLayerContext(HDC hdc, int iLayerPlane)
+{
+   SetLastError(0);
+   return (NULL);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglDeleteContext(HGLRC hglrc)
+{
+   if (ctx && hglrc == (HGLRC) 1) {
+
+      fxMesaDestroyContext(ctx);
+
+      SetWindowLong(WindowFromDC(hDC), GWL_WNDPROC, (LONG) hWNDOldProc);
+
+      ctx = NULL;
+      hDC = 0;
+      return (TRUE);
+   }
+
+   SetLastError(0);
+
+   return (FALSE);
+}
+
+GLAPI HGLRC GLAPIENTRY
+wglGetCurrentContext(VOID)
+{
+   if (ctx)
+      return ((HGLRC) 1);
+
+   SetLastError(0);
+   return (NULL);
+}
+
+GLAPI HDC GLAPIENTRY
+wglGetCurrentDC(VOID)
+{
+   if (ctx)
+      return (hDC);
+
+   SetLastError(0);
+   return (NULL);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglSwapIntervalEXT (int interval)
+{
+ if (ctx == NULL) {
+    return FALSE;
+ }
+ if (interval < 0) {
+    interval = 0;
+ } else if (interval > 3) {
+    interval = 3;
+ }
+ ctx->swapInterval = interval;
+ return TRUE;
+}
+
+GLAPI int GLAPIENTRY
+wglGetSwapIntervalEXT (void)
+{
+ return (ctx == NULL) ? -1 : ctx->swapInterval;
+}
+
+GLAPI BOOL GLAPIENTRY
+wglGetDeviceGammaRamp3DFX (HDC hdc, LPVOID arrays)
+{
+ /* gammaTable should be per-context */
+ memcpy(arrays, gammaTable, 3*256*sizeof(GLushort));
+ return TRUE;
+}
+
+GLAPI BOOL GLAPIENTRY
+wglSetDeviceGammaRamp3DFX (HDC hdc, LPVOID arrays)
+{
+ GLint i, tableSize, inc, index;
+ GLushort *red, *green, *blue;
+ FxU32 gammaTableR[256], gammaTableG[256], gammaTableB[256];
+
+ /* gammaTable should be per-context */
+ memcpy(gammaTable, arrays, 3*256*sizeof(GLushort));
+
+ tableSize = FX_grGetInteger(GR_GAMMA_TABLE_ENTRIES);
+ inc = 256 / tableSize;
+ red = (GLushort *)arrays;
+ green = (GLushort *)arrays + 256;
+ blue = (GLushort *)arrays + 512;
+ for (i = 0, index = 0; i < tableSize; i++, index += inc) {
+     gammaTableR[i] = red[index] >> 8;
+     gammaTableG[i] = green[index] >> 8;
+     gammaTableB[i] = blue[index] >> 8;
+ }
+
+ grLoadGammaTable(tableSize, gammaTableR, gammaTableG, gammaTableB);
+
+ return TRUE;
+}
+
+typedef void *HPBUFFERARB;
+
+/* WGL_ARB_pixel_format */
+GLAPI BOOL GLAPIENTRY
+wglGetPixelFormatAttribivARB (HDC hdc,
+			      int iPixelFormat,
+			      int iLayerPlane,
+			      UINT nAttributes,
+			      const int *piAttributes,
+			      int *piValues)
+{
+  SetLastError(0);
+  return(FALSE);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglGetPixelFormatAttribfvARB (HDC hdc,
+			      int iPixelFormat,
+			      int iLayerPlane,
+			      UINT nAttributes,
+			      const int *piAttributes,
+			      FLOAT *pfValues)
+{
+  SetLastError(0);
+  return(FALSE);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglChoosePixelFormatARB (HDC hdc,
+			 const int *piAttribIList,
+			 const FLOAT *pfAttribFList,
+			 UINT nMaxFormats,
+			 int *piFormats,
+			 UINT *nNumFormats)
+{
+  SetLastError(0);
+  return(FALSE);
+}
+
+/* WGL_ARB_render_texture */
+GLAPI BOOL GLAPIENTRY
+wglBindTexImageARB (HPBUFFERARB hPbuffer, int iBuffer)
+{
+  SetLastError(0);
+  return(FALSE);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglReleaseTexImageARB (HPBUFFERARB hPbuffer, int iBuffer)
+{
+  SetLastError(0);
+  return(FALSE);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglSetPbufferAttribARB (HPBUFFERARB hPbuffer,
+			const int *piAttribList)
+{
+  SetLastError(0);
+  return(FALSE);
+}
+
+/* WGL_ARB_pbuffer */
+GLAPI HPBUFFERARB GLAPIENTRY
+wglCreatePbufferARB (HDC hDC,
+		     int iPixelFormat,
+		     int iWidth,
+		     int iHeight,
+		     const int *piAttribList)
+{
+  SetLastError(0);
+  return NULL;
+}
+
+GLAPI HDC GLAPIENTRY
+wglGetPbufferDCARB (HPBUFFERARB hPbuffer)
+{
+  SetLastError(0);
+  return NULL;
+}
+
+GLAPI int GLAPIENTRY
+wglReleasePbufferDCARB (HPBUFFERARB hPbuffer, HDC hDC)
+{
+  SetLastError(0);
+  return -1;
+}
+
+GLAPI BOOL GLAPIENTRY
+wglDestroyPbufferARB (HPBUFFERARB hPbuffer)
+{
+  SetLastError(0);
+  return(FALSE);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglQueryPbufferARB (HPBUFFERARB hPbuffer,
+		    int iAttribute,
+		    int *piValue)
+{
+  SetLastError(0);
+  return(FALSE);
+}
+
+GLAPI const char * GLAPIENTRY
+wglGetExtensionsStringEXT (void)
+{
+ return "WGL_3DFX_gamma_control "
+        "WGL_EXT_swap_control "
+        "WGL_EXT_extensions_string WGL_ARB_extensions_string"
+        /*WGL_ARB_pixel_format WGL_ARB_render_texture WGL_ARB_pbuffer*/;
+}
+
+GLAPI const char * GLAPIENTRY
+wglGetExtensionsStringARB (HDC hdc)
+{
+ return wglGetExtensionsStringEXT();
+}
+
+static struct {
+       const char *name;
+       PROC func;
+} wgl_ext[] = {
+       {"wglGetExtensionsStringARB",    wglGetExtensionsStringARB},
+       {"wglGetExtensionsStringEXT",    wglGetExtensionsStringEXT},
+       {"wglSwapIntervalEXT",           wglSwapIntervalEXT},
+       {"wglGetSwapIntervalEXT",        wglGetSwapIntervalEXT},
+       {"wglGetDeviceGammaRamp3DFX",    wglGetDeviceGammaRamp3DFX},
+       {"wglSetDeviceGammaRamp3DFX",    wglSetDeviceGammaRamp3DFX},
+       /* WGL_ARB_pixel_format */
+       {"wglGetPixelFormatAttribivARB", wglGetPixelFormatAttribivARB},
+       {"wglGetPixelFormatAttribfvARB", wglGetPixelFormatAttribfvARB},
+       {"wglChoosePixelFormatARB",      wglChoosePixelFormatARB},
+       /* WGL_ARB_render_texture */
+       {"wglBindTexImageARB",           wglBindTexImageARB},
+       {"wglReleaseTexImageARB",        wglReleaseTexImageARB},
+       {"wglSetPbufferAttribARB",       wglSetPbufferAttribARB},
+       /* WGL_ARB_pbuffer */
+       {"wglCreatePbufferARB",          wglCreatePbufferARB},
+       {"wglGetPbufferDCARB",           wglGetPbufferDCARB},
+       {"wglReleasePbufferDCARB",       wglReleasePbufferDCARB},
+       {"wglDestroyPbufferARB",         wglDestroyPbufferARB},
+       {"wglQueryPbufferARB",           wglQueryPbufferARB},
+       {NULL, NULL}
+};
+
+GLAPI PROC GLAPIENTRY
+wglGetProcAddress(LPCSTR lpszProc)
+{ 
+   int i;
+   PROC p = (PROC) _glapi_get_proc_address((const char *) lpszProc);
+
+   /* we can't BlendColor. work around buggy applications */
+   if (p && strcmp(lpszProc, "glBlendColor") && strcmp(lpszProc, "glBlendColorEXT"))
+      return p;
+
+   for (i = 0; wgl_ext[i].name; i++) {
+       if (!strcmp(lpszProc, wgl_ext[i].name)) {
+          return wgl_ext[i].func;
+       }
+   }
+
+   SetLastError(0);
+   return (NULL);
+}
+
+GLAPI PROC GLAPIENTRY
+wglGetDefaultProcAddress(LPCSTR lpszProc)
+{ 
+   SetLastError(0);
+   return (NULL);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglMakeCurrent(HDC hdc, HGLRC hglrc)
+{
+   if ((hdc == NULL) && (hglrc == NULL))
+      return (TRUE);
+
+   if (!ctx || hglrc != (HGLRC) 1 || WindowFromDC(hdc) != hWND) {
+      SetLastError(0);
+      return (FALSE);
+   }
+
+   hDC = hdc;
+
+   fxMesaMakeCurrent(ctx);
+
+   return (TRUE);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglShareLists(HGLRC hglrc1, HGLRC hglrc2)
+{
+   if (!ctx || hglrc1 != (HGLRC) 1 || hglrc1 != hglrc2) {
+      SetLastError(0);
+      return (FALSE);
+   }
+
+   return (TRUE);
+}
+
+static BOOL
+wglUseFontBitmaps_FX(HDC fontDevice, DWORD firstChar, DWORD numChars,
+		     DWORD listBase)
+{
+   TEXTMETRIC metric;
+   BITMAPINFO *dibInfo;
+   HDC bitDevice;
+   COLORREF tempColor;
+   int i;
+
+   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 */
+   SetTextAlign(bitDevice, TA_BASELINE);
+
+   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); /* [koolsmoky] explicit cast */
+
+      /* Find how high/wide this character is */
+      GetTextExtentPoint32(bitDevice, &curChar, 1, &size);
+ 
+      /* Create the output bitmap */
+      charWidth = size.cx;
+      charHeight = size.cy;
+      bmapWidth = ((charWidth + 31) / 32) * 32;	/* Round up to the next multiple of 32 bits */
+      bmapHeight = charHeight;
+      bitObject = CreateCompatibleBitmap(bitDevice, bmapWidth, bmapHeight);
+      /*VERIFY(bitObject);*/
+
+      /* Assign the output bitmap to the device */
+      origBmap = SelectObject(bitDevice, bitObject);
+
+      PatBlt(bitDevice, 0, 0, bmapWidth, bmapHeight, BLACKNESS);
+
+      /* Use our source font on the device */
+      SelectObject(bitDevice, GetCurrentObject(fontDevice, OBJ_FONT));
+
+      /* Draw the character */
+      TextOut(bitDevice, 0, metric.tmAscent, &curChar, 1);
+
+      /* Unselect our bmap object */
+      SelectObject(bitDevice, origBmap);
+
+      /* Convert the display dependant representation to a 1 bit deep DIB */
+      numBytes = (bmapWidth * bmapHeight) / 8;
+      bmap = MALLOC(numBytes);
+      dibInfo->bmiHeader.biWidth = bmapWidth;
+      dibInfo->bmiHeader.biHeight = bmapHeight;
+      res = GetDIBits(bitDevice, bitObject, 0, bmapHeight, bmap,
+		      dibInfo, DIB_RGB_COLORS);
+
+      /* Create the GL object */
+      glNewList(i + listBase, GL_COMPILE);
+      glBitmap(bmapWidth, bmapHeight, 0.0, metric.tmDescent,
+	       charWidth, 0.0, bmap);
+      glEndList();
+      /* CheckGL(); */
+
+      /* Destroy the bmap object */
+      DeleteObject(bitObject);
+
+      /* Deallocate the bitmap data */
+      FREE(bmap);
+   }
+
+   /* Destroy the DC */
+   DeleteDC(bitDevice);
+
+   FREE(dibInfo);
+
+   return TRUE;
+}
+
+GLAPI BOOL GLAPIENTRY
+wglUseFontBitmapsW(HDC hdc, DWORD first, DWORD count, DWORD listBase)
+{
+   return (FALSE);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglUseFontOutlinesA(HDC hdc, DWORD first, DWORD count,
+		    DWORD listBase, FLOAT deviation,
+		    FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)
+{
+   SetLastError(0);
+   return (FALSE);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglUseFontOutlinesW(HDC hdc, DWORD first, DWORD count,
+		    DWORD listBase, FLOAT deviation,
+		    FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)
+{
+   SetLastError(0);
+   return (FALSE);
+}
+
+
+GLAPI BOOL GLAPIENTRY
+wglSwapLayerBuffers(HDC hdc, UINT fuPlanes)
+{
+   if (ctx && WindowFromDC(hdc) == hWND) {
+      fxMesaSwapBuffers();
+
+      return (TRUE);
+   }
+
+   SetLastError(0);
+   return (FALSE);
+}
+
+static int pfd_tablen (void)
+{
+ /* we should take an envvar for `fxMesaSelectCurrentBoard' */
+ return (fxMesaSelectCurrentBoard(0) < GR_SSTTYPE_Voodoo4)
+        ? 2                               /* only 16bit entries */
+        : sizeof(pix) / sizeof(pix[0]);   /* full table */
+}
+
+GLAPI int GLAPIENTRY
+wglChoosePixelFormat(HDC hdc, const PIXELFORMATDESCRIPTOR * ppfd)
+{
+   int i, best = -1, qt_valid_pix;
+   PIXELFORMATDESCRIPTOR pfd = *ppfd;
+
+   qt_valid_pix = pfd_tablen();
+
+#if 1 || QUAKE2 || GORE
+  /* QUAKE2: 24+32 */
+  /* GORE  : 24+16 */
+  if ((pfd.cColorBits == 24) || (pfd.cColorBits == 32)) {
+     /* the first 2 entries are 16bit */
+     pfd.cColorBits = (qt_valid_pix > 2) ? 32 : 16;
+  }
+  if (pfd.cColorBits == 32) {
+     pfd.cDepthBits = 24;
+  } else if (pfd.cColorBits == 16) {
+     pfd.cDepthBits = 16;
+  }
+#endif
+
+   if (pfd.nSize != sizeof(PIXELFORMATDESCRIPTOR) || pfd.nVersion != 1) {
+      SetLastError(0);
+      return (0);
+   }
+
+   for (i = 0; i < qt_valid_pix; i++) {
+      if (pfd.cColorBits > 0 && pix[i].pfd.cColorBits != pfd.cColorBits) 
+		  continue;
+
+      if ((pfd.dwFlags & PFD_DRAW_TO_WINDOW)
+	  && !(pix[i].pfd.dwFlags & PFD_DRAW_TO_WINDOW)) continue;
+      if ((pfd.dwFlags & PFD_DRAW_TO_BITMAP)
+	  && !(pix[i].pfd.dwFlags & PFD_DRAW_TO_BITMAP)) continue;
+      if ((pfd.dwFlags & PFD_SUPPORT_GDI)
+	  && !(pix[i].pfd.dwFlags & PFD_SUPPORT_GDI)) continue;
+      if ((pfd.dwFlags & PFD_SUPPORT_OPENGL)
+	  && !(pix[i].pfd.dwFlags & PFD_SUPPORT_OPENGL)) continue;
+      if (!(pfd.dwFlags & PFD_DOUBLEBUFFER_DONTCARE)
+	  && ((pfd.dwFlags & PFD_DOUBLEBUFFER) !=
+	      (pix[i].pfd.dwFlags & PFD_DOUBLEBUFFER))) continue;
+#if 1 /* Doom3 fails here! */
+      if (!(pfd.dwFlags & PFD_STEREO_DONTCARE)
+	  && ((pfd.dwFlags & PFD_STEREO) !=
+	      (pix[i].pfd.dwFlags & PFD_STEREO))) continue;
+#endif
+
+      if (pfd.cDepthBits > 0 && pix[i].pfd.cDepthBits == 0)
+	 continue;		/* need depth buffer */
+
+      if (pfd.cAlphaBits > 0 && pix[i].pfd.cAlphaBits == 0)
+	 continue;		/* need alpha buffer */
+
+#if 0 /* regression bug? */
+      if (pfd.cStencilBits > 0 && pix[i].pfd.cStencilBits == 0)
+	 continue;		/* need stencil buffer */
+#endif
+
+      if (pfd.iPixelType == pix[i].pfd.iPixelType) {
+	 best = i + 1;
+	 break;
+      }
+   }
+
+   if (best == -1) {
+      FILE *err = fopen("MESA.LOG", "w");
+      if (err != NULL) {
+         fprintf(err, "wglChoosePixelFormat failed\n");
+         fprintf(err, "\tnSize           = %d\n", ppfd->nSize);
+         fprintf(err, "\tnVersion        = %d\n", ppfd->nVersion);
+         fprintf(err, "\tdwFlags         = %d\n", ppfd->dwFlags);
+         fprintf(err, "\tiPixelType      = %d\n", ppfd->iPixelType);
+         fprintf(err, "\tcColorBits      = %d\n", ppfd->cColorBits);
+         fprintf(err, "\tcRedBits        = %d\n", ppfd->cRedBits);
+         fprintf(err, "\tcRedShift       = %d\n", ppfd->cRedShift);
+         fprintf(err, "\tcGreenBits      = %d\n", ppfd->cGreenBits);
+         fprintf(err, "\tcGreenShift     = %d\n", ppfd->cGreenShift);
+         fprintf(err, "\tcBlueBits       = %d\n", ppfd->cBlueBits);
+         fprintf(err, "\tcBlueShift      = %d\n", ppfd->cBlueShift);
+         fprintf(err, "\tcAlphaBits      = %d\n", ppfd->cAlphaBits);
+         fprintf(err, "\tcAlphaShift     = %d\n", ppfd->cAlphaShift);
+         fprintf(err, "\tcAccumBits      = %d\n", ppfd->cAccumBits);
+         fprintf(err, "\tcAccumRedBits   = %d\n", ppfd->cAccumRedBits);
+         fprintf(err, "\tcAccumGreenBits = %d\n", ppfd->cAccumGreenBits);
+         fprintf(err, "\tcAccumBlueBits  = %d\n", ppfd->cAccumBlueBits);
+         fprintf(err, "\tcAccumAlphaBits = %d\n", ppfd->cAccumAlphaBits);
+         fprintf(err, "\tcDepthBits      = %d\n", ppfd->cDepthBits);
+         fprintf(err, "\tcStencilBits    = %d\n", ppfd->cStencilBits);
+         fprintf(err, "\tcAuxBuffers     = %d\n", ppfd->cAuxBuffers);
+         fprintf(err, "\tiLayerType      = %d\n", ppfd->iLayerType);
+         fprintf(err, "\tbReserved       = %d\n", ppfd->bReserved);
+         fprintf(err, "\tdwLayerMask     = %d\n", ppfd->dwLayerMask);
+         fprintf(err, "\tdwVisibleMask   = %d\n", ppfd->dwVisibleMask);
+         fprintf(err, "\tdwDamageMask    = %d\n", ppfd->dwDamageMask);
+         fclose(err);
+      }
+
+      SetLastError(0);
+      return (0);
+   }
+
+   return (best);
+}
+
+GLAPI int GLAPIENTRY
+ChoosePixelFormat(HDC hdc, const PIXELFORMATDESCRIPTOR * ppfd)
+{
+  
+   return wglChoosePixelFormat(hdc, ppfd);
+}
+
+GLAPI int GLAPIENTRY
+wglDescribePixelFormat(HDC hdc, int iPixelFormat, UINT nBytes,
+		       LPPIXELFORMATDESCRIPTOR ppfd)
+{
+   int qt_valid_pix;
+
+   qt_valid_pix = pfd_tablen();
+
+   if (iPixelFormat < 1 || iPixelFormat > qt_valid_pix ||
+       ((nBytes != sizeof(PIXELFORMATDESCRIPTOR)) && (nBytes != 0))) {
+      SetLastError(0);
+      return (qt_valid_pix);
+   }
+
+   if (nBytes != 0)
+      *ppfd = pix[iPixelFormat - 1].pfd;
+
+   return (qt_valid_pix);
+}
+
+GLAPI int GLAPIENTRY
+DescribePixelFormat(HDC hdc, int iPixelFormat, UINT nBytes,
+		    LPPIXELFORMATDESCRIPTOR ppfd)
+{
+   return wglDescribePixelFormat(hdc, iPixelFormat, nBytes, ppfd);
+}
+
+GLAPI int GLAPIENTRY
+wglGetPixelFormat(HDC hdc)
+{
+   if (curPFD == 0) {
+      SetLastError(0);
+      return (0);
+   }
+
+   return (curPFD);
+}
+
+GLAPI int GLAPIENTRY
+GetPixelFormat(HDC hdc)
+{
+   return wglGetPixelFormat(hdc);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglSetPixelFormat(HDC hdc, int iPixelFormat, const PIXELFORMATDESCRIPTOR * ppfd)
+{
+   int qt_valid_pix;
+
+   qt_valid_pix = pfd_tablen();
+
+   if (iPixelFormat < 1 || iPixelFormat > qt_valid_pix) {
+      if (ppfd == NULL) {
+         PIXELFORMATDESCRIPTOR my_pfd;
+         if (!wglDescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &my_pfd)) {
+            SetLastError(0);
+            return (FALSE);
+         }
+      } else if (ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR)) {
+         SetLastError(0);
+         return (FALSE);
+      }
+   }
+   curPFD = iPixelFormat;
+
+   return (TRUE);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglSwapBuffers(HDC hdc)
+{
+   if (!ctx) {
+      SetLastError(0);
+      return (FALSE);
+   }
+
+   fxMesaSwapBuffers();
+
+   return (TRUE);
+}
+
+GLAPI BOOL GLAPIENTRY
+SetPixelFormat(HDC hdc, int iPixelFormat, const PIXELFORMATDESCRIPTOR * ppfd)
+{
+   return wglSetPixelFormat(hdc, iPixelFormat, ppfd);
+}
+
+GLAPI BOOL GLAPIENTRY
+SwapBuffers(HDC hdc)
+{
+   return wglSwapBuffers(hdc);
+}
+
+static FIXED FixedFromDouble(double d)
+{
+  long l = (long) (d * 65536L);
+  return *(FIXED *)&l;
+}
+
+/*
+** This was yanked from windows/gdi/wgl.c
+*/
+GLAPI 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 (first<0)
+     return FALSE;
+  if (count<0)
+     return FALSE;
+  if (listBase<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 < 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,                /* pointer 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,
+             -gm.gmptGlyphOrigin.x,
+             gm.gmptGlyphOrigin.y,
+             gm.gmCellIncX,gm.gmCellIncY,
+             (const GLubyte * )lpBits);
+
+    GlobalUnlock(hBits);
+    GlobalFree(hBits);
+
+    glEndList( );
+  }
+
+  return success;
+}
+
+GLAPI BOOL GLAPIENTRY
+wglDescribeLayerPlane(HDC hdc, int iPixelFormat, int iLayerPlane,
+                      UINT nBytes, LPLAYERPLANEDESCRIPTOR ppfd)
+{
+  SetLastError(0);
+  return (FALSE);
+}
+
+GLAPI int GLAPIENTRY
+wglGetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart,
+                          int cEntries, COLORREF *pcr)
+{
+  SetLastError(0);
+  return (FALSE);
+}
+
+GLAPI BOOL GLAPIENTRY
+wglRealizeLayerPalette(HDC hdc,int iLayerPlane,BOOL bRealize)
+{
+  SetLastError(0);
+  return(FALSE);
+}
+
+GLAPI int GLAPIENTRY
+wglSetLayerPaletteEntries(HDC hdc,int iLayerPlane, int iStart,
+                          int cEntries, CONST COLORREF *pcr)
+{
+  SetLastError(0);
+  return(FALSE);
+}
+
+#if (_MSC_VER >= 1200)
+#pragma warning( pop )
+#endif
+
+#endif /* FX */