Add GLX code to Xgl

9 files changed, 1723 insertions, 167 deletions

diff --git a/hw/xgl/xgl.h b/hw/xgl/xgl.h
index 346d7b3b5..f7c6102df 100644
--- a/hw/xgl/xgl.h
+++ b/hw/xgl/xgl.h
@@ -351,6 +351,7 @@ typedef struct _xglPixmap {
     Bool	      allBits;
     unsigned long     pictureMask;
     xglGeometryPtr    pGeometry;
+    int		      lock;
 } xglPixmapRec, *xglPixmapPtr;
 
 extern int xglPixmapPrivateIndex;
@@ -1313,6 +1314,9 @@ xglUpdatePicture (PicturePtr pPicture);
 Bool
 xglPictureInit (ScreenPtr pScreen);
 
+void
+xglPictureClipExtents (PicturePtr pPicture,
+		       BoxPtr     extents);
 
 /* xglglyph.c */
 
@@ -1365,4 +1369,11 @@ xglAddTraps (PicturePtr pDst,
 
 #endif
 
+#ifdef GLXEXT
+
+Bool
+xglInitVisualConfigs (ScreenPtr pScreen);
+
+#endif
+
 #endif /* _XGL_H_ */
diff --git a/hw/xgl/xglglx.c b/hw/xgl/xglglx.c
new file mode 100644
index 000000000..a036362d6
--- /dev/null
+++ b/hw/xgl/xglglx.c
@@ -0,0 +1,1506 @@
+/*
+ * Copyright © 2005 Novell, Inc.
+ * 
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Novell, Inc. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Novell, Inc. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: David Reveman <davidr@novell.com>
+ */
+
+#include "xgl.h"
+
+#ifdef GLXEXT
+
+#include <GL/gl.h>
+
+#include "glxserver.h"
+#include "glxdrawable.h"
+#include "glxscreens.h"
+#include "micmap.h"
+
+extern void
+GlxSetVisualConfigs (int	       nconfigs,
+		     __GLXvisualConfig *configs,
+		     void	       **privates);
+
+extern void
+GlxWrapInitVisuals (miInitVisualsProcPtr *);
+
+extern int
+GlxInitVisuals (VisualPtr     *visualp,
+		DepthPtr      *depthp,
+		int	      *nvisualp,
+		int	      *ndepthp,
+		int	      *rootDepthp,
+		VisualID      *defaultVisp,
+		unsigned long sizes,
+		int	      bitsPerRGB,
+		int	      preferredVis);
+
+extern void
+__glXFlushContextCache (void);
+
+extern __GLXscreenInfo __glDDXScreenInfo;
+
+extern __glProcTable    __glMesaRenderTable;
+extern __glProcTableEXT __glMesaRenderTableEXT;
+
+typedef Bool	      (*GLXScreenProbeProc)    (int screen);
+typedef __GLinterface *(*GLXCreateContextProc) (__GLimports      *imports,
+						__GLcontextModes *modes,
+						__GLinterface    *shareGC);
+typedef void	      (*GLXCreateBufferProc)   (__GLXdrawablePrivate *glxPriv);
+typedef GLboolean     (*GLXSwapBuffersProc)    (__GLXdrawablePrivate *glxPriv);
+
+typedef struct _xglGLXScreenInfo {
+    GLXScreenProbeProc   screenProbe;
+    GLXCreateContextProc createContext;
+    GLXCreateBufferProc  createBuffer;
+} xglGLXScreenInfoRec, *xglGLXScreenInfoPtr;
+
+static xglGLXScreenInfoRec screenInfoPriv;
+
+typedef GLboolean (*GLResizeBuffersProc) (__GLdrawableBuffer   *buffer,
+					  GLint		       x,
+					  GLint		       y,
+					  GLuint	       width,
+					  GLuint	       height, 
+					  __GLdrawablePrivate  *glPriv,
+					  GLuint	       bufferMask);
+typedef void	  (*GLFreeBuffersProc)   (__GLdrawablePrivate  *glPriv);
+    
+typedef struct _xglGLBuffer {
+    GLXSwapBuffersProc  swapBuffers;
+    GLResizeBuffersProc resizeBuffers;
+    GLFreeBuffersProc   freeBuffers;
+    ScreenPtr		pScreen;
+    DrawablePtr		pDrawable;
+    PixmapPtr		pPixmap;
+    GCPtr		pGC;
+    void	        *private;
+} xglGLBufferRec, *xglGLBufferPtr;
+
+typedef int xglGLXVisualConfigRec, *xglGLXVisualConfigPtr;
+
+typedef struct _xglGLContext {
+    __GLinterface	     iface;
+    __GLinterface	     *mIface;
+    glitz_context_t	     *context;
+    __glProcTableEXT	     glRenderTableEXT;
+    PFNGLWINDOWPOS3FMESAPROC WindowPos3fMESA;
+    Bool		     needInit;
+    Bool		     target;
+    glitz_surface_t	     *draw;
+    int			     tx, ty;
+    xRectangle		     viewport;
+    xRectangle		     scissor;
+    char		     *versionString;
+} xglGLContextRec, *xglGLContextPtr;
+
+xglGLContextPtr cctx = NULL;
+
+static void
+xglViewport (GLint   x,
+	     GLint   y,
+	     GLsizei width,
+	     GLsizei height)
+{
+    cctx->viewport.x	  = x;
+    cctx->viewport.y	  = y;
+    cctx->viewport.width  = width;
+    cctx->viewport.height = height;
+
+    glitz_context_set_viewport (cctx->context,
+				cctx->tx + x, cctx->ty + y, width, height);
+}
+
+static void
+xglScissor (GLint   x,
+	    GLint   y,
+	    GLsizei width,
+	    GLsizei height)
+{
+    cctx->scissor.x	 = x;
+    cctx->scissor.y	 = y;
+    cctx->scissor.width  = width;
+    cctx->scissor.height = height;
+
+    glitz_context_set_scissor (cctx->context,
+			       cctx->tx + x, cctx->ty + y, width, height);
+}
+
+static void
+xglDrawBuffer (GLenum mode)
+{
+    ErrorF ("NYI xglDrawBuffer: 0x%x\n", mode);
+}
+
+static void
+xglDisable (GLenum cap)
+{
+    if (cap != GL_SCISSOR_TEST)
+	glDisable (cap);
+}
+
+static void
+xglReadBuffer (GLenum mode)
+{
+    ErrorF ("NYI xglReadBuffer: 0x%x\n", mode);
+}
+
+static void
+xglCopyPixels (GLint   x,
+	       GLint   y,
+	       GLsizei width,
+	       GLsizei height,
+	       GLenum  type)
+{
+    ErrorF ("NYI glCopyPixels: %d %d %d %d 0x%x\n",
+	    x, y, width, height, type);   
+}
+
+static const GLubyte *
+xglGetString (GLenum name)
+{
+    switch (name) {
+    case GL_VERSION:
+	if (!cctx->versionString)
+	{
+	    static const char *version = "1.2 (%s)";
+	    const char	      *nativeVersion = glGetString (GL_VERSION);
+
+	    cctx->versionString = xalloc (strlen (version) +
+					  strlen (nativeVersion));
+	    if (cctx->versionString)
+		sprintf (cctx->versionString, version, nativeVersion);
+	}
+	return cctx->versionString;
+    default:
+	return glGetString (name);
+    }
+}
+
+__glProcTable __glNativeRenderTable = {
+    glNewList,
+    glEndList,
+    glCallList,
+    glCallLists,
+    glDeleteLists,
+    glGenLists,
+    glListBase,
+    glBegin,
+    glBitmap,
+    glColor3bv,
+    glColor3dv,
+    glColor3fv,
+    glColor3iv,
+    glColor3sv,
+    glColor3ubv,
+    glColor3uiv,
+    glColor3usv,
+    glColor4bv,
+    glColor4dv,
+    glColor4fv,
+    glColor4iv,
+    glColor4sv,
+    glColor4ubv,
+    glColor4uiv,
+    glColor4usv,
+    glEdgeFlagv,
+    glEnd,
+    glIndexdv,
+    glIndexfv,
+    glIndexiv,
+    glIndexsv,
+    glNormal3bv,
+    glNormal3dv,
+    glNormal3fv,
+    glNormal3iv,
+    glNormal3sv,
+    glRasterPos2dv,
+    glRasterPos2fv,
+    glRasterPos2iv,
+    glRasterPos2sv,
+    glRasterPos3dv,
+    glRasterPos3fv,
+    glRasterPos3iv,
+    glRasterPos3sv,
+    glRasterPos4dv,
+    glRasterPos4fv,
+    glRasterPos4iv,
+    glRasterPos4sv,
+    glRectdv,
+    glRectfv,
+    glRectiv,
+    glRectsv,
+    glTexCoord1dv,
+    glTexCoord1fv,
+    glTexCoord1iv,
+    glTexCoord1sv,
+    glTexCoord2dv,
+    glTexCoord2fv,
+    glTexCoord2iv,
+    glTexCoord2sv,
+    glTexCoord3dv,
+    glTexCoord3fv,
+    glTexCoord3iv,
+    glTexCoord3sv,
+    glTexCoord4dv,
+    glTexCoord4fv,
+    glTexCoord4iv,
+    glTexCoord4sv,
+    glVertex2dv,
+    glVertex2fv,
+    glVertex2iv,
+    glVertex2sv,
+    glVertex3dv,
+    glVertex3fv,
+    glVertex3iv,
+    glVertex3sv,
+    glVertex4dv,
+    glVertex4fv,
+    glVertex4iv,
+    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,
+    xglScissor, /* 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,
+    xglDrawBuffer, /* glDrawBuffer */
+    glClear,
+    glClearAccum,
+    glClearIndex,
+    glClearColor,
+    glClearStencil,
+    glClearDepth,
+    glStencilMask,
+    glColorMask,
+    glDepthMask,
+    glIndexMask,
+    glAccum,
+    xglDisable, /* glDisable */
+    glEnable,
+    glFinish,
+    glFlush,
+    glPopAttrib,
+    glPushAttrib,
+    glMap1d,
+    glMap1f,
+    glMap2d,
+    glMap2f,
+    glMapGrid1d,
+    glMapGrid1f,
+    glMapGrid2d,
+    glMapGrid2f,
+    glEvalCoord1dv,
+    glEvalCoord1fv,
+    glEvalCoord2dv,
+    glEvalCoord2fv,
+    glEvalMesh1,
+    glEvalPoint1,
+    glEvalMesh2,
+    glEvalPoint2,
+    glAlphaFunc,
+    glBlendFunc,
+    glLogicOp,
+    glStencilFunc,
+    glStencilOp,
+    glDepthFunc,
+    glPixelZoom,
+    glPixelTransferf,
+    glPixelTransferi,
+    glPixelStoref,
+    glPixelStorei,
+    glPixelMapfv,
+    glPixelMapuiv,
+    glPixelMapusv,
+    xglReadBuffer, /* glReadBuffer */
+    xglCopyPixels, /* glCopyPixels */
+    glReadPixels,
+    glDrawPixels,
+    glGetBooleanv,
+    glGetClipPlane,
+    glGetDoublev,
+    glGetError,
+    glGetFloatv,
+    glGetIntegerv,
+    glGetLightfv,
+    glGetLightiv,
+    glGetMapdv,
+    glGetMapfv,
+    glGetMapiv,
+    glGetMaterialfv,
+    glGetMaterialiv,
+    glGetPixelMapfv,
+    glGetPixelMapuiv,
+    glGetPixelMapusv,
+    glGetPolygonStipple,
+    xglGetString, /* 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,
+    xglViewport, /* glViewport */
+    glArrayElement,
+    glBindTexture,
+    glColorPointer,
+    glDisableClientState,
+    glDrawArrays,
+    glDrawElements,
+    glEdgeFlagPointer,
+    glEnableClientState,
+    glIndexPointer,
+    glIndexubv,
+    glInterleavedArrays,
+    glNormalPointer,
+    glPolygonOffset,
+    glTexCoordPointer,
+    glVertexPointer,
+    glAreTexturesResident,
+    glCopyTexImage1D,
+    glCopyTexImage2D,
+    glCopyTexSubImage1D,
+    glCopyTexSubImage2D,
+    glDeleteTextures,
+    glGenTextures,
+    glGetPointerv,
+    glIsTexture,
+    glPrioritizeTextures,
+    glTexSubImage1D,
+    glTexSubImage2D,
+    glPopClientAttrib,
+    glPushClientAttrib,
+    glBlendColor,
+    glBlendEquation,
+    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
+};
+
+/* GL_ARB_multitexture */
+static void
+xglNoOpActiveTextureARB (GLenum texture) {}
+static void
+xglNoOpClientActiveTextureARB (GLenum texture) {}
+static void
+xglNoOpMultiTexCoord1dvARB (GLenum target, const GLdouble *v) {}
+static void
+xglNoOpMultiTexCoord1fvARB (GLenum target, const GLfloat *v) {}
+static void
+xglNoOpMultiTexCoord1ivARB (GLenum target, const GLint *v) {}
+static void
+xglNoOpMultiTexCoord1svARB (GLenum target, const GLshort *v) {}
+static void
+xglNoOpMultiTexCoord2dvARB (GLenum target, const GLdouble *v) {}
+static void
+xglNoOpMultiTexCoord2fvARB (GLenum target, const GLfloat *v) {}
+static void
+xglNoOpMultiTexCoord2ivARB (GLenum target, const GLint *v) {}
+static void
+xglNoOpMultiTexCoord2svARB (GLenum target, const GLshort *v) {}
+static void
+xglNoOpMultiTexCoord3dvARB (GLenum target, const GLdouble *v) {}
+static void
+xglNoOpMultiTexCoord3fvARB (GLenum target, const GLfloat *v) {}
+static void
+xglNoOpMultiTexCoord3ivARB (GLenum target, const GLint *v) {}
+static void
+xglNoOpMultiTexCoord3svARB (GLenum target, const GLshort *v) {}
+static void
+xglNoOpMultiTexCoord4dvARB (GLenum target, const GLdouble *v) {}
+static void
+xglNoOpMultiTexCoord4fvARB (GLenum target, const GLfloat *v) {}
+static void
+xglNoOpMultiTexCoord4ivARB (GLenum target, const GLint *v) {}
+static void
+xglNoOpMultiTexCoord4svARB (GLenum target, const GLshort *v) {}
+
+/* GL_ARB_multisample */
+static void
+xglNoOpSampleCoverageARB (GLclampf value, GLboolean invert) {}
+
+/* GL_EXT_texture_object */
+static GLboolean
+xglNoOpAreTexturesResidentEXT (GLsizei n,
+			       const GLuint *textures,
+			       GLboolean *residences)
+{
+    return GL_FALSE;
+}
+static void
+xglNoOpGenTexturesEXT (GLsizei n, GLuint *textures) {}
+static GLboolean
+xglNoOpIsTextureEXT (GLuint texture)
+{
+    return GL_FALSE;
+}
+
+/* GL_SGIS_multisample */
+static void
+xglNoOpSampleMaskSGIS (GLclampf value, GLboolean invert) {}
+static void
+xglNoOpSamplePatternSGIS (GLenum pattern) {}
+
+/* GL_EXT_point_parameters */
+static void
+xglNoOpPointParameterfEXT (GLenum pname, GLfloat param) {}
+static void
+xglNoOpPointParameterfvEXT (GLenum pname, const GLfloat *params) {}
+
+/* GL_MESA_window_pos */
+static void
+xglNoOpWindowPos3fMESA (GLfloat x, GLfloat y, GLfloat z) {}
+static void
+xglWindowPos3fMESA (GLfloat x, GLfloat y, GLfloat z)
+{
+    (*cctx->glRenderTableEXT.WindowPos3fMESA) (cctx->tx + x, cctx->ty + y, z);
+}
+
+/* GL_EXT_blend_func_separate */
+static void
+xglNoOpBlendFuncSeparateEXT (GLenum sfactorRGB, GLenum dfactorRGB,
+			     GLenum sfactorAlpha, GLenum dfactorAlpha) {}
+
+/* GL_EXT_fog_coord */ 
+static void
+xglNoOpFogCoordfvEXT (const GLfloat *coord) {}
+static void
+xglNoOpFogCoorddvEXT (const GLdouble *coord) {}
+static void
+xglNoOpFogCoordPointerEXT (GLenum type, GLsizei stride,
+			   const GLvoid *pointer) {}
+
+/* GL_EXT_secondary_color */
+static void
+xglNoOpSecondaryColor3bvEXT (const GLbyte *v) {}
+static void
+xglNoOpSecondaryColor3dvEXT (const GLdouble *v) {}
+static void
+xglNoOpSecondaryColor3fvEXT (const GLfloat *v) {}
+static void
+xglNoOpSecondaryColor3ivEXT (const GLint *v) {}
+static void
+xglNoOpSecondaryColor3svEXT (const GLshort *v) {}
+static void
+xglNoOpSecondaryColor3ubvEXT (const GLubyte *v) {}
+static void
+xglNoOpSecondaryColor3uivEXT (const GLuint *v) {}
+static void
+xglNoOpSecondaryColor3usvEXT (const GLushort *v) {}
+static void
+xglNoOpSecondaryColorPointerEXT (GLint size, GLenum type, GLsizei stride,
+				 const GLvoid *pointer) {}
+
+
+/* GL_NV_point_sprite */
+static void
+xglNoOpPointParameteriNV (GLenum pname, GLint params) {}
+static void
+xglNoOpPointParameterivNV (GLenum pname, const GLint *params) {}
+
+/* GL_EXT_stencil_two_side */
+static void
+xglNoOpActiveStencilFaceEXT (GLenum face) {}
+
+__glProcTableEXT __glNoOpRenderTableEXT = {
+    xglNoOpActiveTextureARB,
+    xglNoOpClientActiveTextureARB,
+    xglNoOpMultiTexCoord1dvARB,
+    xglNoOpMultiTexCoord1fvARB,
+    xglNoOpMultiTexCoord1ivARB,
+    xglNoOpMultiTexCoord1svARB,
+    xglNoOpMultiTexCoord2dvARB,
+    xglNoOpMultiTexCoord2fvARB,
+    xglNoOpMultiTexCoord2ivARB,
+    xglNoOpMultiTexCoord2svARB,
+    xglNoOpMultiTexCoord3dvARB,
+    xglNoOpMultiTexCoord3fvARB,
+    xglNoOpMultiTexCoord3ivARB,
+    xglNoOpMultiTexCoord3svARB,
+    xglNoOpMultiTexCoord4dvARB,
+    xglNoOpMultiTexCoord4fvARB,
+    xglNoOpMultiTexCoord4ivARB,
+    xglNoOpMultiTexCoord4svARB,
+    xglNoOpSampleCoverageARB,
+    xglNoOpAreTexturesResidentEXT,
+    xglNoOpGenTexturesEXT,
+    xglNoOpIsTextureEXT,
+    xglNoOpSampleMaskSGIS,
+    xglNoOpSamplePatternSGIS,
+    xglNoOpPointParameterfEXT,
+    xglNoOpPointParameterfvEXT,
+    xglNoOpWindowPos3fMESA,
+    xglNoOpBlendFuncSeparateEXT,
+    xglNoOpFogCoordfvEXT,
+    xglNoOpFogCoorddvEXT,
+    xglNoOpFogCoordPointerEXT,
+    xglNoOpSecondaryColor3bvEXT,
+    xglNoOpSecondaryColor3dvEXT,
+    xglNoOpSecondaryColor3fvEXT,
+    xglNoOpSecondaryColor3ivEXT,
+    xglNoOpSecondaryColor3svEXT,
+    xglNoOpSecondaryColor3ubvEXT,
+    xglNoOpSecondaryColor3uivEXT,
+    xglNoOpSecondaryColor3usvEXT,
+    xglNoOpSecondaryColorPointerEXT,
+    xglNoOpPointParameteriNV,
+    xglNoOpPointParameterivNV,
+    xglNoOpActiveStencilFaceEXT
+};
+
+static void
+xglInitExtensions (xglGLContextPtr pContext)
+{
+    const char *extensions;
+
+    pContext->glRenderTableEXT = __glNoOpRenderTableEXT;
+
+    extensions = glGetString (GL_EXTENSIONS);
+
+    if (strstr (extensions, "GL_ARB_multitexture"))
+    {
+	pContext->glRenderTableEXT.ActiveTextureARB =
+	    (PFNGLACTIVETEXTUREARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glActiveTextureARB");
+	pContext->glRenderTableEXT.ClientActiveTextureARB =
+	    (PFNGLCLIENTACTIVETEXTUREARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glClientActiveTextureARB");
+	pContext->glRenderTableEXT.MultiTexCoord1dvARB =
+	    (PFNGLMULTITEXCOORD1DVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord1dvARB");
+	pContext->glRenderTableEXT.MultiTexCoord1fvARB =
+	    (PFNGLMULTITEXCOORD1FVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord1fvARB");
+	pContext->glRenderTableEXT.MultiTexCoord1ivARB =
+	    (PFNGLMULTITEXCOORD1IVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord1ivARB");
+	pContext->glRenderTableEXT.MultiTexCoord1svARB =
+	    (PFNGLMULTITEXCOORD1SVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord1svARB");
+	pContext->glRenderTableEXT.MultiTexCoord2dvARB =
+	    (PFNGLMULTITEXCOORD2DVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord2dvARB");
+	pContext->glRenderTableEXT.MultiTexCoord2fvARB =
+	    (PFNGLMULTITEXCOORD2FVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord2fvARB");
+	pContext->glRenderTableEXT.MultiTexCoord2ivARB =
+	    (PFNGLMULTITEXCOORD2IVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord2ivARB");
+	pContext->glRenderTableEXT.MultiTexCoord2svARB =
+	    (PFNGLMULTITEXCOORD2SVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord2svARB");
+	pContext->glRenderTableEXT.MultiTexCoord3dvARB =
+	    (PFNGLMULTITEXCOORD3DVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord3dvARB");
+	pContext->glRenderTableEXT.MultiTexCoord3fvARB =
+	    (PFNGLMULTITEXCOORD3FVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord3fvARB");
+	pContext->glRenderTableEXT.MultiTexCoord3ivARB =
+	    (PFNGLMULTITEXCOORD3IVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord3ivARB");
+	pContext->glRenderTableEXT.MultiTexCoord3svARB =
+	    (PFNGLMULTITEXCOORD3SVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord3svARB");
+	pContext->glRenderTableEXT.MultiTexCoord4dvARB =
+	    (PFNGLMULTITEXCOORD4DVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord4dvARB");
+	pContext->glRenderTableEXT.MultiTexCoord4fvARB =
+	    (PFNGLMULTITEXCOORD4FVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord4fvARB");
+	pContext->glRenderTableEXT.MultiTexCoord4ivARB =
+	    (PFNGLMULTITEXCOORD4IVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord4ivARB");
+	pContext->glRenderTableEXT.MultiTexCoord4svARB =
+	    (PFNGLMULTITEXCOORD4SVARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glMultiTexCoord4svARB");
+    }
+
+    if (strstr (extensions, "GL_ARB_multisample"))
+    {
+	pContext->glRenderTableEXT.SampleCoverageARB =
+	    (PFNGLSAMPLECOVERAGEARBPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSampleCoverageARB");
+    }
+
+    if (strstr (extensions, "GL_EXT_texture_object"))
+    {
+	pContext->glRenderTableEXT.AreTexturesResidentEXT =
+	    (PFNGLARETEXTURESRESIDENTEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glAreTexturesResidentEXT");
+	pContext->glRenderTableEXT.GenTexturesEXT =
+	    (PFNGLGENTEXTURESEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glGenTexturesEXT");
+	pContext->glRenderTableEXT.IsTextureEXT =
+	    (PFNGLISTEXTUREEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glIsTextureEXT");
+    }
+
+    if (strstr (extensions, "GL_SGIS_multisample"))
+    {
+	pContext->glRenderTableEXT.SampleMaskSGIS =
+	    (PFNGLSAMPLEMASKSGISPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSampleMaskSGIS");
+	pContext->glRenderTableEXT.SamplePatternSGIS =
+	    (PFNGLSAMPLEPATTERNSGISPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSamplePatternSGIS");
+    }
+
+    if (strstr (extensions, "GL_EXT_point_parameters"))
+    {
+	pContext->glRenderTableEXT.PointParameterfEXT =
+	    (PFNGLPOINTPARAMETERFEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glPointParameterfEXT");
+	pContext->glRenderTableEXT.PointParameterfvEXT =
+	    (PFNGLPOINTPARAMETERFVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glPointParameterfvEXT");
+    }
+
+    if (strstr (extensions, "GL_MESA_window_pos"))
+    {
+	pContext->WindowPos3fMESA =
+	    (PFNGLWINDOWPOS3FMESAPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glWindowPos3fMESA");
+	pContext->glRenderTableEXT.WindowPos3fMESA = xglWindowPos3fMESA;
+    }
+
+    if (strstr (extensions, "GL_EXT_blend_func_separate"))
+    {
+	pContext->glRenderTableEXT.BlendFuncSeparateEXT =
+	    (PFNGLBLENDFUNCSEPARATEEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glBlendFuncSeparateEXT");
+    }
+
+    if (strstr (extensions, "GL_EXT_fog_coord"))
+    {
+	pContext->glRenderTableEXT.FogCoordfvEXT =
+	    (PFNGLFOGCOORDFVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glFogCoordfvEXT");
+	pContext->glRenderTableEXT.FogCoorddvEXT =
+	    (PFNGLFOGCOORDDVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glFogCoorddvEXT");
+	pContext->glRenderTableEXT.FogCoordPointerEXT =
+	    (PFNGLFOGCOORDPOINTEREXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glFogCoordPointerEXT");
+    }
+
+    if (strstr (extensions, "GL_EXT_secondary_color"))
+    {
+	pContext->glRenderTableEXT.SecondaryColor3bvEXT =
+	    (PFNGLSECONDARYCOLOR3BVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSecondaryColor3bvEXT");
+	pContext->glRenderTableEXT.SecondaryColor3dvEXT =
+	    (PFNGLSECONDARYCOLOR3DVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSecondaryColor3dvEXT");
+	pContext->glRenderTableEXT.SecondaryColor3fvEXT =
+	    (PFNGLSECONDARYCOLOR3FVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSecondaryColor3fvEXT");
+	pContext->glRenderTableEXT.SecondaryColor3ivEXT =
+	    (PFNGLSECONDARYCOLOR3IVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSecondaryColor3ivEXT");
+	pContext->glRenderTableEXT.SecondaryColor3svEXT =
+	    (PFNGLSECONDARYCOLOR3SVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSecondaryColor3svEXT");
+	pContext->glRenderTableEXT.SecondaryColor3ubvEXT =
+	    (PFNGLSECONDARYCOLOR3UBVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSecondaryColor3ubvEXT");
+	pContext->glRenderTableEXT.SecondaryColor3uivEXT =
+	    (PFNGLSECONDARYCOLOR3UIVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSecondaryColor3uivEXT");
+	pContext->glRenderTableEXT.SecondaryColor3usvEXT =
+	    (PFNGLSECONDARYCOLOR3USVEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSecondaryColor3usvEXT");
+	pContext->glRenderTableEXT.SecondaryColorPointerEXT =
+	    (PFNGLSECONDARYCOLORPOINTEREXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glSecondaryColorPointerEXT");
+    }
+
+    if (strstr (extensions, "GL_NV_point_sprite"))
+    {
+	pContext->glRenderTableEXT.PointParameteriNV =
+	    (PFNGLPOINTPARAMETERINVPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glPointParameteriNV");
+	pContext->glRenderTableEXT.PointParameterivNV =
+	    (PFNGLPOINTPARAMETERIVNVPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glPointParameterivNV");
+    }
+
+    if (strstr (extensions, "GL_EXT_stencil_two_side"))
+    {
+	pContext->glRenderTableEXT.ActiveStencilFaceEXT =
+	    (PFNGLACTIVESTENCILFACEEXTPROC)
+	    glitz_context_get_proc_address (pContext->context,
+					    "glActiveStencilFaceEXT");
+    }
+    
+    pContext->needInit = FALSE;
+}
+
+static GLboolean
+xglDestroyContext (__GLcontext *gc)
+{
+    xglGLContextPtr pContext = (xglGLContextPtr) gc;
+    __GLinterface   *iface = pContext->mIface;
+
+    glitz_context_destroy (pContext->context);
+    if (pContext->versionString)
+	xfree (pContext->versionString);
+    xfree (pContext);
+
+    return (*iface->exports.destroyContext) ((__GLcontext *) iface);
+}
+
+static GLboolean
+xglLoseCurrent (__GLcontext *gc)
+{
+    xglGLContextPtr pContext = (xglGLContextPtr) gc;
+    __GLinterface   *iface = pContext->mIface;
+
+    __glXFlushContextCache ();
+
+    return (*iface->exports.loseCurrent) ((__GLcontext *) iface);   
+}
+
+static GLboolean
+xglMakeCurrent (__GLcontext *gc)
+{
+    xglGLContextPtr	pContext = (xglGLContextPtr) gc;
+    __GLinterface	*iface = pContext->mIface;
+    __GLdrawablePrivate *drawPriv = iface->imports.getDrawablePrivate (gc);
+    __GLdrawablePrivate *readPriv = iface->imports.getReadablePrivate (gc);
+    xglGLBufferPtr	pDrawBufferPriv = drawPriv->private;
+    xglGLBufferPtr	pReadBufferPriv = readPriv->private;
+    ScreenPtr		pScreen = pDrawBufferPriv->pScreen;
+    DrawablePtr		pDrawable = pDrawBufferPriv->pDrawable;
+    PixmapPtr		pPixmap = pDrawBufferPriv->pPixmap;
+    GLboolean		status;
+
+    pContext->target = xglPrepareTarget (pDrawable);
+    if (pContext->target && pPixmap)
+    {
+	pContext->target = xglPrepareTarget (&pPixmap->drawable);
+	if (pContext->target)
+	{
+	    xglPixmapPtr pFront = XGL_GET_DRAWABLE_PIXMAP_PRIV (pDrawable);
+	    xglPixmapPtr pBack  = XGL_GET_PIXMAP_PRIV (pPixmap);
+	    
+	    pContext->scissor.x = pContext->scissor.y = 0;
+	    pContext->scissor.width = pDrawable->width;
+	    pContext->scissor.height = pDrawable->height;
+
+	    pContext->viewport.x = pContext->viewport.y = 0;
+	    pContext->viewport.width = pDrawable->width;
+	    pContext->viewport.height = pDrawable->height;
+
+	    pContext->draw = pBack->surface;
+	    pContext->tx = pContext->ty = 0;
+	    
+	    if (!pFront->lock) pFront->lock++;
+	    if (!pBack->lock) pBack->lock++;
+
+	    glitz_context_set_surface (pContext->context, pContext->draw);
+
+	    return GL_TRUE;
+	}
+    } else
+	pContext->target = xglPixmapTargetNo;
+
+    ErrorF ("[glx] software: %d %d\n", pDrawable->x, pDrawable->y);
+    if (pPixmap)
+    {
+	(*pScreen->DestroyPixmap) (pPixmap);
+	pDrawBufferPriv->pPixmap = NULL;
+    }
+    
+    drawPriv->private = pDrawBufferPriv->private;
+    readPriv->private = pReadBufferPriv->private;
+
+    status = (*iface->exports.makeCurrent) ((__GLcontext *) iface);
+
+    drawPriv->private = pDrawBufferPriv;
+    readPriv->private = pReadBufferPriv;
+
+    return status;
+}
+
+static GLboolean
+xglShareContext (__GLcontext *gc,
+		 __GLcontext *gcShare)
+{
+    xglGLContextPtr pContext = (xglGLContextPtr) gc;
+    xglGLContextPtr pContextShare = (xglGLContextPtr) gcShare;
+    __GLinterface   *iface = pContext->mIface;
+    __GLinterface   *ifaceShare = pContextShare->mIface;
+
+    /* NYI. all contexts are currently shared */
+    
+    return (*iface->exports.shareContext) ((__GLcontext *) iface,
+					   (__GLcontext *) ifaceShare);
+}
+
+static GLboolean
+xglCopyContext (__GLcontext	  *dst,
+		const __GLcontext *src,
+		GLuint		  mask)
+{
+    xglGLContextPtr pDst = (xglGLContextPtr) dst;
+    xglGLContextPtr pSrc = (xglGLContextPtr) src;
+    __GLinterface   *dstIface = pDst->mIface;
+    __GLinterface   *srcIface = pSrc->mIface;
+
+    glitz_context_copy (pSrc->context, pDst->context, mask);
+    
+    return (*dstIface->exports.copyContext) ((__GLcontext *) dstIface,
+					     (const __GLcontext *) srcIface,
+					     mask);
+}
+
+static GLboolean
+xglForceCurrent (__GLcontext *gc)
+{
+    xglGLContextPtr pContext = (xglGLContextPtr) gc;
+    __GLinterface   *iface = pContext->mIface;
+
+    if (pContext->target)
+    {
+	cctx = pContext;
+	
+	glitz_context_make_current (cctx->context);
+	
+	if (cctx->needInit)
+	    xglInitExtensions (cctx);
+	
+	__glRenderTable = &__glNativeRenderTable;
+	__glRenderTableEXT = &cctx->glRenderTableEXT;
+	
+	return GL_TRUE;
+    }
+
+    cctx = NULL;
+    __glRenderTable = &__glMesaRenderTable;
+    __glRenderTableEXT = &__glMesaRenderTableEXT;
+	
+    return (*iface->exports.forceCurrent) ((__GLcontext *) iface);
+}
+
+static GLboolean
+xglNotifyResize (__GLcontext *gc)
+{
+    xglGLContextPtr pContext = (xglGLContextPtr) gc;
+    __GLinterface   *iface = pContext->mIface;
+
+    return (*iface->exports.notifyResize) ((__GLcontext *) iface);
+}
+
+static void
+xglNotifyDestroy (__GLcontext *gc)
+{
+    xglGLContextPtr pContext = (xglGLContextPtr) gc;
+    __GLinterface   *iface = pContext->mIface;
+
+    return (*iface->exports.notifyDestroy) ((__GLcontext *) iface);
+}
+
+static void
+xglNotifySwapBuffers (__GLcontext *gc)
+{
+    xglGLContextPtr pContext = (xglGLContextPtr) gc;
+    __GLinterface   *iface = pContext->mIface;
+
+    return (*iface->exports.notifySwapBuffers) ((__GLcontext *) iface);
+}
+
+static struct __GLdispatchStateRec *
+xglDispatchExec (__GLcontext *gc)
+{
+    xglGLContextPtr pContext = (xglGLContextPtr) gc;
+    __GLinterface   *iface = pContext->mIface;
+
+    return (*iface->exports.dispatchExec) ((__GLcontext *) iface);
+}
+
+static void
+xglBeginDispatchOverride (__GLcontext *gc)
+{
+    xglGLContextPtr pContext = (xglGLContextPtr) gc;
+    __GLinterface   *iface = pContext->mIface;
+
+    return (*iface->exports.beginDispatchOverride) ((__GLcontext *) iface);
+}
+
+static void
+xglEndDispatchOverride (__GLcontext *gc)
+{
+    xglGLContextPtr pContext = (xglGLContextPtr) gc;
+    __GLinterface   *iface = pContext->mIface;
+
+    return (*iface->exports.endDispatchOverride) ((__GLcontext *) iface);
+}
+
+static void
+xglLoseCurrentContext (void *closure)
+{
+    cctx = NULL;
+    __glRenderTable = &__glMesaRenderTable;
+    __glRenderTableEXT = &__glMesaRenderTableEXT;
+
+    __glXFlushContextCache ();
+}
+
+static __GLinterface *
+xglCreateContext (__GLimports      *imports,
+		  __GLcontextModes *modes,
+		  __GLinterface    *shareGC)
+{
+    glitz_drawable_format_t *format;
+    xglGLContextPtr	    pShareContext = (xglGLContextPtr) shareGC;
+    xglGLContextPtr	    pContext;
+    __GLinterface	    *shareIface = NULL;
+    __GLinterface	    *iface;
+    __GLXcontext	    *glxCtx = (__GLXcontext *) imports->other;
+    
+    XGL_SCREEN_PRIV (glxCtx->pScreen);
+ 
+    if (shareGC)
+	shareIface = pShareContext->mIface;
+    
+    pContext = xalloc (sizeof (xglGLContextRec));
+    if (!pContext)
+	return NULL;
+
+    format = glitz_drawable_get_format (pScreenPriv->drawable);
+
+    pContext->context = glitz_context_create (pScreenPriv->drawable, format);
+
+    pContext->needInit	    = TRUE;
+    pContext->draw	    = NULL;
+    pContext->target	    = FALSE;
+    pContext->versionString = NULL;
+    
+    glitz_context_set_user_data (pContext->context, NULL, 
+				 xglLoseCurrentContext);
+				 
+    iface = (*screenInfoPriv.createContext) (imports, modes, shareIface);
+    if (!iface)
+    {
+	xfree (pContext);
+	return NULL;
+    }
+
+    pContext->mIface = iface;
+    pContext->iface.imports = *imports;
+    
+    pContext->iface.exports.destroyContext	  = xglDestroyContext;
+    pContext->iface.exports.loseCurrent		  = xglLoseCurrent;
+    pContext->iface.exports.makeCurrent		  = xglMakeCurrent;
+    pContext->iface.exports.shareContext	  = xglShareContext;
+    pContext->iface.exports.copyContext		  = xglCopyContext;
+    pContext->iface.exports.forceCurrent	  = xglForceCurrent;
+    pContext->iface.exports.notifyResize	  = xglNotifyResize;
+    pContext->iface.exports.notifyDestroy	  = xglNotifyDestroy;
+    pContext->iface.exports.notifySwapBuffers     = xglNotifySwapBuffers;
+    pContext->iface.exports.dispatchExec	  = xglDispatchExec;
+    pContext->iface.exports.beginDispatchOverride = xglBeginDispatchOverride;
+    pContext->iface.exports.endDispatchOverride   = xglEndDispatchOverride;
+    
+    return (__GLinterface *) pContext;
+}
+
+static GLboolean
+xglSwapBuffers (__GLXdrawablePrivate *glxPriv)
+{
+    __GLdrawablePrivate	*glPriv = &glxPriv->glPriv;
+    xglGLBufferPtr	pBufferPriv = glPriv->private;
+    DrawablePtr		pDrawable = pBufferPriv->pDrawable;
+    PixmapPtr		pPixmap = pBufferPriv->pPixmap;
+    GCPtr		pGC = pBufferPriv->pGC;
+    GLboolean		ret;
+
+    if (pPixmap)
+    {
+	if (!pGC)
+	{
+	    int status;
+	    XID value;
+
+	    value = FALSE;
+	    pGC = CreateGC (pDrawable, GCGraphicsExposures, &value, &status);
+	    ValidateGC (pDrawable, pGC);
+	    pBufferPriv->pGC = pGC;
+	}
+	
+	if (pGC)
+	{
+	    (*pGC->ops->CopyArea) ((DrawablePtr) pPixmap,
+				   pDrawable, pGC,
+				   0, 0,
+				   pPixmap->drawable.width,
+				   pPixmap->drawable.height,
+				   0, 0);
+	    
+	    return GL_TRUE;
+	}
+
+	return GL_FALSE;
+    }
+    
+    glPriv->private = pBufferPriv->private;
+    ret = (*pBufferPriv->swapBuffers) (glxPriv);
+    glPriv->private = pBufferPriv;
+    
+    return ret;
+}
+
+static GLboolean
+xglResizeBuffers (__GLdrawableBuffer  *buffer,
+		  GLint		      x,
+		  GLint		      y,
+		  GLuint	      width,
+		  GLuint	      height, 
+		  __GLdrawablePrivate *glPriv,
+		  GLuint	      bufferMask)
+{
+    xglGLBufferPtr pBufferPriv = glPriv->private;
+    DrawablePtr    pDrawable = pBufferPriv->pDrawable;
+    PixmapPtr	   pPixmap = pBufferPriv->pPixmap;
+    ScreenPtr      pScreen = pBufferPriv->pScreen;
+    Bool	   status;
+    
+    if (pPixmap)
+    {
+	if (pPixmap->drawable.width  != width ||
+	    pPixmap->drawable.height != height)
+	{   
+	    ErrorF ("[glx] resizeBuffer: %d %d %dx%d\n", x, y, width, height);
+
+	    (*pScreen->DestroyPixmap) (pPixmap);
+	    pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
+						pDrawable->depth);
+
+	    /* give good initial score */
+	    XGL_GET_PIXMAP_PRIV (pPixmap)->score = 4000;
+	    pBufferPriv->pPixmap = pPixmap;
+	}
+    }
+    
+    glPriv->private = pBufferPriv->private;
+    status = (*pBufferPriv->resizeBuffers) (buffer,
+					    x, y, width, height,
+					    glPriv,
+					    bufferMask);
+    glPriv->private = pBufferPriv;
+    
+    return status;
+}
+
+static void
+xglFreeBuffers (__GLdrawablePrivate *glPriv)
+{
+    xglGLBufferPtr pBufferPriv = glPriv->private;
+    ScreenPtr      pScreen = pBufferPriv->pScreen;
+    
+    glPriv->private = pBufferPriv->private;
+
+    (*pBufferPriv->freeBuffers) (glPriv);
+    
+    if (pBufferPriv->pPixmap)
+	(*pScreen->DestroyPixmap) (pBufferPriv->pPixmap);
+
+    if (pBufferPriv->pGC)
+	FreeGC (pBufferPriv->pGC, (GContext) 0);
+    
+    xfree (pBufferPriv);
+}
+
+static void
+xglCreateBuffer (__GLXdrawablePrivate *glxPriv)
+{
+    __GLdrawablePrivate	*glPriv = &glxPriv->glPriv;
+    DrawablePtr		pDrawable = glxPriv->pDraw;
+    ScreenPtr		pScreen = pDrawable->pScreen;
+    xglGLBufferPtr	pBufferPriv;
+
+    XGL_DRAWABLE_PIXMAP_PRIV (pDrawable);
+    
+    pBufferPriv = xalloc (sizeof (xglGLBufferRec));
+    if (!pBufferPriv)
+	FatalError ("No memory");
+
+    ErrorF ("[glx] createBuffer: %dx%d\n",
+	    pDrawable->width, pDrawable->height);
+    
+    pBufferPriv->pScreen = pScreen;
+    pBufferPriv->pDrawable = pDrawable;
+    pBufferPriv->pPixmap = NULL;
+    pBufferPriv->pGC = NULL;
+    
+    if (glxPriv->pGlxVisual->doubleBuffer)
+	pBufferPriv->pPixmap =
+	    (*pScreen->CreatePixmap) (pScreen,
+				      pDrawable->width,
+				      pDrawable->height,
+				      pDrawable->depth);
+
+    /* give good initial score */
+    pPixmapPriv->score = 4000;
+
+    (*screenInfoPriv.createBuffer) (glxPriv);
+
+    /* Wrap the front buffer's resize routine */
+    pBufferPriv->resizeBuffers = glPriv->frontBuffer.resize;
+    glPriv->frontBuffer.resize = xglResizeBuffers;
+
+    /* Wrap the swap buffers routine */
+    pBufferPriv->swapBuffers = glxPriv->swapBuffers;
+    glxPriv->swapBuffers = xglSwapBuffers;
+
+    /* Wrap private and freePrivate */
+    pBufferPriv->private = glPriv->private;
+    pBufferPriv->freeBuffers = glPriv->freePrivate;
+    glPriv->private = (void *) pBufferPriv;
+    glPriv->freePrivate = xglFreeBuffers;
+}
+
+static Bool
+xglScreenProbe (int screen)
+{
+    Bool status;
+
+    status = (*screenInfoPriv.screenProbe) (screen);
+
+    /* Wrap createBuffer */
+    if (__glDDXScreenInfo.createBuffer != xglCreateBuffer)
+    {
+	screenInfoPriv.createBuffer    = __glDDXScreenInfo.createBuffer;
+	__glDDXScreenInfo.createBuffer = xglCreateBuffer;
+    }
+    
+    /* Wrap createContext */
+    if (__glDDXScreenInfo.createContext != xglCreateContext)
+    {
+	screenInfoPriv.createContext    = __glDDXScreenInfo.createContext;
+	__glDDXScreenInfo.createContext = xglCreateContext;
+    }
+    
+    return status;
+}
+
+Bool
+xglInitVisualConfigs (ScreenPtr pScreen)
+{
+    miInitVisualsProcPtr    initVisualsProc = NULL;
+    VisualPtr		    visuals;
+    int			    nvisuals;
+    DepthPtr		    depths;
+    int			    ndepths;
+    int			    rootDepth;
+    VisualID		    defaultVis;
+    glitz_drawable_format_t *format;
+    xglPixelFormatPtr	    pPixel;
+    __GLXvisualConfig	    *pConfig;
+    xglGLXVisualConfigPtr   pConfigPriv, *ppConfigPriv;
+    XID			    *installedCmaps;
+    ColormapPtr		    installedCmap;
+    int			    numInstalledCmaps;
+    int			    numConfig = 1;
+    int			    depth, bpp, i;
+
+    XGL_SCREEN_PRIV (pScreen);
+    
+    depth  = pScreenPriv->pVisual->pPixel->depth;
+    bpp    = pScreenPriv->pVisual->pPixel->masks.bpp;
+    format = glitz_drawable_get_format (pScreenPriv->drawable);
+    pPixel = pScreenPriv->pixmapFormats[depth].pPixel;
+
+    pConfig = xcalloc (sizeof (__GLXvisualConfig), numConfig);
+    if (!pConfig)
+	return FALSE;
+
+    pConfigPriv = xcalloc (sizeof (xglGLXVisualConfigRec), numConfig);
+    if (!pConfigPriv)
+    {
+	xfree (pConfig);
+	return FALSE;
+    }
+
+    ppConfigPriv = xcalloc (sizeof (xglGLXVisualConfigPtr), numConfig);
+    if (!ppConfigPriv)
+    {
+	xfree (pConfigPriv);
+	xfree (pConfig);
+	return FALSE;
+    }
+
+    installedCmaps = xalloc (pScreen->maxInstalledCmaps * sizeof (XID));
+    if (!installedCmaps)
+    {
+	xfree (ppConfigPriv);
+	xfree (pConfigPriv);
+	xfree (pConfig);
+	return FALSE;
+    }
+    
+    for (i = 0; i < numConfig; i++)
+    {
+	ppConfigPriv[i] = &pConfigPriv[i];
+	
+	pConfig[i].vid   = (VisualID) (-1);
+	pConfig[i].class = -1;
+	pConfig[i].rgba  = TRUE;
+	
+	pConfig[i].redSize   = format->color.red_size;
+	pConfig[i].greenSize = format->color.green_size;
+	pConfig[i].blueSize  = format->color.blue_size;
+
+	pConfig[i].redMask   = pPixel->masks.red_mask;
+	pConfig[i].greenMask = pPixel->masks.green_mask;
+	pConfig[i].blueMask  = pPixel->masks.blue_mask;
+
+	if (format->color.alpha_size)
+	{
+	    pConfig[i].alphaSize = format->color.alpha_size;
+	    pConfig[i].alphaMask = pPixel->masks.alpha_mask;
+	}
+	else
+	{
+	    pConfig[i].alphaSize = 0;
+	    pConfig[i].alphaMask = 0;
+	}
+
+	pConfig[i].doubleBuffer = TRUE;
+	pConfig[i].depthSize = format->depth_size;
+	pConfig[i].stereo = FALSE;
+	
+	if (depth == 16)
+	    pConfig[i].bufferSize = 16;
+	else
+	    pConfig[i].bufferSize = 32;
+
+	pConfig[i].auxBuffers = 0;
+	pConfig[i].level      = 0;
+	
+	pConfig[i].visualRating = GLX_NONE;
+	
+	pConfig[i].transparentPixel = GLX_NONE;
+	pConfig[i].transparentRed   = 0;
+	pConfig[i].transparentGreen = 0;
+	pConfig[i].transparentBlue  = 0;
+	pConfig[i].transparentAlpha = 0;
+	pConfig[i].transparentIndex = 0;
+    }
+
+    GlxSetVisualConfigs (numConfig, pConfig, (void **) ppConfigPriv);
+
+    /* Wrap screenProbe */
+    if (__glDDXScreenInfo.screenProbe != xglScreenProbe)
+    {
+	screenInfoPriv.screenProbe    = __glDDXScreenInfo.screenProbe;
+	__glDDXScreenInfo.screenProbe = xglScreenProbe;
+    }
+
+    visuals    = pScreen->visuals;
+    nvisuals   = pScreen->numVisuals;
+    depths     = pScreen->allowedDepths;
+    ndepths    = pScreen->numDepths;
+    rootDepth  = pScreen->rootDepth;
+    defaultVis = pScreen->rootVisual;
+    
+    /* Find installed colormaps */
+    numInstalledCmaps = (*pScreen->ListInstalledColormaps) (pScreen, 
+							    installedCmaps);
+	
+    GlxWrapInitVisuals (&initVisualsProc);
+    GlxInitVisuals (&visuals, &depths, &nvisuals, &ndepths, &rootDepth,
+		    &defaultVis, ((unsigned long) 1 << (bpp - 1)), 8, -1);
+
+    /* Fix up any existing installed colormaps. */
+    for (i = 0; i < numInstalledCmaps; i++)
+    {
+	int j;
+	
+	installedCmap = LookupIDByType (installedCmaps[i], RT_COLORMAP);
+	if (!installedCmap)
+	    continue;
+	
+	j = installedCmap->pVisual - pScreen->visuals;
+	installedCmap->pVisual = &visuals[j];
+    }
+    
+    pScreen->visuals       = visuals;
+    pScreen->numVisuals    = nvisuals;
+    pScreen->allowedDepths = depths;
+    pScreen->numDepths     = ndepths;
+    pScreen->rootDepth     = rootDepth;
+    pScreen->rootVisual    = defaultVis;
+
+    xfree (installedCmaps);
+    xfree (pConfigPriv);
+    xfree (pConfig);
+
+    ErrorF ("[glx] initialized\n");
+    
+    return TRUE;
+}
+
+#endif /* GLXEXT */
diff --git a/hw/xgl/xglglyph.c b/hw/xgl/xglglyph.c
index f535efc24..b854a83f5 100644
--- a/hw/xgl/xglglyph.c
+++ b/hw/xgl/xglglyph.c
@@ -837,7 +837,8 @@ xglCachedGlyphs (CARD8	       op,
 }
 
 static Bool
-xglGlyphExtents (int	      nlist,
+xglGlyphExtents (PicturePtr   pDst,
+		 int	      nlist,
 		 GlyphListPtr list,
 		 GlyphPtr     *glyphs,
 		 BoxPtr	      extents)
@@ -941,6 +942,8 @@ xglGlyphExtents (int	      nlist,
 	}
     }
 
+    xglPictureClipExtents (pDst, extents);
+
     return overlap;
 }
 
@@ -981,20 +984,26 @@ xglGlyphs (CARD8	 op,
     BoxRec	  extents;
     xglGlyphOpRec glyphOp;
     int		  xDst = list->xOff, yDst = list->yOff;
+    int		  overlap;
+    int		  target;
+
+    XGL_DRAWABLE_PIXMAP_PRIV (pDst->pDrawable);
+
+    overlap = xglGlyphExtents (pDst, nlist, list, glyphs, &extents);
+    if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
+	return;
+    
+    target = xglPrepareTarget (pDst->pDrawable);
 
     if (op != PictOpAdd && maskFormat &&
-	(xglGlyphExtents (nlist, list, glyphs, &extents) || op != PictOpOver ||
+	(overlap || op != PictOpOver ||
 	 xglGlyphListFormatId (list, nlist) != maskFormat->id))
     {
-	PixmapPtr    pPixmap;
-	xglPixmapPtr pPixmapPriv;
-	CARD32	     componentAlpha;
-	GCPtr	     pGC;
-	xRectangle   rect;
-	int	     error;
-	
-	if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
-	    return;
+	PixmapPtr  pPixmap;
+	CARD32	   componentAlpha;
+	GCPtr	   pGC;
+	xRectangle rect;
+	int	   error;
 
 	rect.x = 0;
 	rect.y = 0;
@@ -1012,7 +1021,17 @@ xglGlyphs (CARD8	 op,
 			       maskFormat, CPComponentAlpha, &componentAlpha,
 			       serverClient, &error);
 	if (!pMask)
+	{
+	    (*pScreen->DestroyPixmap) (pPixmap);
 	    return;
+	}
+
+	/* make sure destination drawable is locked */
+	pPixmapPriv->lock++;
+
+	/* lock mask if we are not doing accelerated drawing to destination */
+	if (!target)
+	    XGL_GET_PIXMAP_PRIV (pPixmap)->lock = 1;
 
 	ValidatePicture (pMask);
 	pGC = GetScratchGC (pPixmap->drawable.depth, pScreen);
@@ -1020,14 +1039,9 @@ xglGlyphs (CARD8	 op,
 	(*pGC->ops->PolyFillRect) (&pPixmap->drawable, pGC, 1, &rect);
 	FreeScratchGC (pGC);
 
-	/* all will be damaged */
-	pPixmapPriv = XGL_GET_PIXMAP_PRIV (pPixmap);
-	pPixmapPriv->damageBox.x1 = 0;
-	pPixmapPriv->damageBox.y1 = 0;
-	pPixmapPriv->damageBox.x2 = pMask->pDrawable->width;
-	pPixmapPriv->damageBox.y2 = pMask->pDrawable->height;
-
 	(*pScreen->DestroyPixmap) (pPixmap);
+
+	target = xglPrepareTarget (pMask->pDrawable);
 	
 	glyphOp.xOff = -extents.x1;
 	glyphOp.yOff = -extents.y1;
@@ -1036,6 +1050,9 @@ xglGlyphs (CARD8	 op,
     }
     else
     {
+	/* make sure destination drawable is locked */
+	pPixmapPriv->lock++;
+
 	glyphOp.xOff = 0;
 	glyphOp.yOff = 0;
 	pSrcPicture = pSrc;
@@ -1043,11 +1060,7 @@ xglGlyphs (CARD8	 op,
     }
 
     glyphOp.ppGlyphs = glyphs;
-    
-    if (xglPrepareTarget (pDstPicture->pDrawable))
-	glyphOp.noCache = FALSE;
-    else
-	glyphOp.noCache = TRUE;
+    glyphOp.noCache  = !target;
 
     while (nlist--)
     {
@@ -1097,6 +1110,10 @@ xglGlyphs (CARD8	 op,
 	
 	FreePicture ((pointer) pMask, (XID) 0);
     }
+
+    /* release destination drawable lock */
+    pPixmapPriv->lock--;
+
 }
 
 #endif
diff --git a/hw/xgl/xgloffscreen.c b/hw/xgl/xgloffscreen.c
index b19c3ce21..c6f8a9165 100644
--- a/hw/xgl/xgloffscreen.c
+++ b/hw/xgl/xgloffscreen.c
@@ -90,6 +90,9 @@ xglOffscreenCompareScore (xglAreaPtr pArea,
     
     if (s1 > s2)
 	XGL_DECREMENT_PIXMAP_SCORE (pPixmapPriv, 10);
+
+    if (pPixmapPriv->lock)
+	return 1;
     
     return s1 - s2;
 }
diff --git a/hw/xgl/xglpict.c b/hw/xgl/xglpict.c
index dcb1f485f..ec79eda68 100644
--- a/hw/xgl/xglpict.c
+++ b/hw/xgl/xglpict.c
@@ -464,4 +464,41 @@ xglPictureInit (ScreenPtr pScreen)
     return TRUE;
 }
 
+void
+xglPictureClipExtents (PicturePtr pPicture,
+		       BoxPtr     extents)
+{
+    if (pPicture->clientClipType != CT_NONE)
+    {
+	BoxPtr clip = REGION_EXTENTS (pPicture->pDrawable->pScreen,
+				      (RegionPtr) pPicture->clientClip);
+
+	if (extents->x1 < pPicture->clipOrigin.x + clip->x1)
+	    extents->x1 = pPicture->clipOrigin.x + clip->x1;
+
+	if (extents->y1 < pPicture->clipOrigin.y + clip->y1)
+	    extents->y1 = pPicture->clipOrigin.y + clip->y1;
+
+	if (extents->x2 > pPicture->clipOrigin.x + clip->x2)
+	    extents->x2 = pPicture->clipOrigin.x + clip->x2;
+
+	if (extents->y2 > pPicture->clipOrigin.y + clip->y2)
+	    extents->y2 = pPicture->clipOrigin.y + clip->y2;
+    }
+    else
+    {
+	if (extents->x1 < 0)
+	    extents->x1 = 0;
+
+	if (extents->y1 < 0)
+	    extents->y1 = 0;
+
+	if (extents->x2 > pPicture->pDrawable->width)
+	    extents->x2 = pPicture->pDrawable->width;
+
+	if (extents->y2 > pPicture->pDrawable->height)
+	    extents->y2 = pPicture->pDrawable->height;
+    }
+}
+
 #endif
diff --git a/hw/xgl/xglpixmap.c b/hw/xgl/xglpixmap.c
index 7c3d29d7b..ee6454779 100644
--- a/hw/xgl/xglpixmap.c
+++ b/hw/xgl/xglpixmap.c
@@ -106,6 +106,7 @@ xglPixmapSurfaceInit (PixmapPtr	    pPixmap,
     pPixmapPriv->acceleratedTile = FALSE;
     pPixmapPriv->pictureMask = ~0;
     pPixmapPriv->target = xglPixmapTargetNo;
+    pPixmapPriv->lock = 0;
 
     if (pPixmapPriv->format)
     {
@@ -209,7 +210,7 @@ void
 xglFiniPixmap (PixmapPtr pPixmap)
 {
     XGL_PIXMAP_PRIV (pPixmap);
-        
+    
     if (pPixmapPriv->pArea)
 	xglWithdrawArea (pPixmapPriv->pArea);
 	
diff --git a/hw/xgl/xglscreen.c b/hw/xgl/xglscreen.c
index 0426c06f8..87da17c78 100644
--- a/hw/xgl/xglscreen.c
+++ b/hw/xgl/xglscreen.c
@@ -35,6 +35,9 @@ static ShmFuncs shmFuncs = { NULL, xglShmPutImage };
 #ifdef RENDER
 #include "glyphstr.h"
 #endif
+#ifdef COMPOSITE
+#include "compint.h"
+#endif
 
 int xglScreenGeneration = -1;
 int xglScreenPrivateIndex;
@@ -135,7 +138,7 @@ xglScreenInit (ScreenPtr        pScreen,
 	       xglScreenInfoPtr pScreenInfo)
 {
     xglScreenPtr pScreenPriv;
-    int		 depth;
+    int		 depth, bpp;
     
 #ifdef RENDER
     PictureScreenPtr pPictureScreen;
@@ -154,6 +157,7 @@ xglScreenInit (ScreenPtr        pScreen,
 	glitz_drawable_get_features (pScreenInfo->drawable);
 
     depth = pScreenPriv->pVisual->pPixel->depth;
+    bpp   = pScreenPriv->pVisual->pPixel->masks.bpp;
 
     if (!xglInitOffscreen (pScreen, pScreenInfo))
 	return FALSE;
@@ -190,8 +194,7 @@ xglScreenInit (ScreenPtr        pScreen,
     if (!fbSetupScreen (pScreen, NULL,
 			pScreenInfo->width, pScreenInfo->height,
 			monitorResolution, monitorResolution,
-			pScreenInfo->width,
-			pScreenPriv->pVisual->pPixel->masks.bpp))
+			pScreenInfo->width, bpp))
 	return FALSE;
 
     pScreen->SaveScreen = xglSaveScreen;
@@ -202,8 +205,7 @@ xglScreenInit (ScreenPtr        pScreen,
     if (!fbFinishScreenInit (pScreen, NULL,
 			     pScreenInfo->width, pScreenInfo->height,
 			     monitorResolution, monitorResolution,
-			     pScreenInfo->width,
-			     pScreenPriv->pVisual->pPixel->masks.bpp))
+			     pScreenInfo->width, bpp))
 	return FALSE;
 
 #ifdef MITSHM
@@ -267,6 +269,19 @@ xglScreenInit (ScreenPtr        pScreen,
     XGL_SCREEN_WRAP (BackingStoreFuncs.SaveAreas, xglSaveAreas);
     XGL_SCREEN_WRAP (BackingStoreFuncs.RestoreAreas, xglRestoreAreas);
 
+    if (!fbCreateDefColormap (pScreen))
+	return FALSE;
+
+#ifdef COMPOSITE
+    if (!compScreenInit (pScreen))
+	return FALSE;
+#endif
+
+#ifdef GLXEXT
+    if (!xglInitVisualConfigs (pScreen))
+	return FALSE;
+#endif
+    
     /* Damage is required */
     DamageSetup (pScreen);
 
@@ -288,13 +303,6 @@ xglFinishScreenInit (ScreenPtr pScreen)
 
     XGL_SCREEN_PRIV (pScreen);
 	
-    /* Do we want to use BackingStore?
-       miInitializeBackingStore (pScreen);
-    */
-
-    if (!fbCreateDefColormap (pScreen))
-	return FALSE;
-
     pScreenPriv->solid =
 	glitz_surface_create (pScreenPriv->drawable,
 			      pScreenPriv->pixmapFormats[32].format,
diff --git a/hw/xgl/xglsync.c b/hw/xgl/xglsync.c
index 52fb09d96..8856352f6 100644
--- a/hw/xgl/xglsync.c
+++ b/hw/xgl/xglsync.c
@@ -304,6 +304,9 @@ xglPrepareTarget (DrawablePtr pDrawable)
 	break;
     case xglPixmapTargetOut:
 	XGL_INCREMENT_PIXMAP_SCORE (pPixmapPriv, 10);
+
+	if (pPixmapPriv->lock)
+	    return FALSE;
 	
 	if (xglFindOffscreenArea (pDrawable->pScreen, pPixmap))
 	    return TRUE;
diff --git a/hw/xgl/xgltrap.c b/hw/xgl/xgltrap.c
index ad9e97b52..fa5af8260 100644
--- a/hw/xgl/xgltrap.c
+++ b/hw/xgl/xgltrap.c
@@ -40,64 +40,6 @@
 /* just a guess */
 #define SMOOTH_TRAPS_ESTIMATE_RECTS(nTrap) (30 * nTrap)
 
-static PicturePtr
-xglCreateMaskPicture (ScreenPtr     pScreen, 
-		      PicturePtr    pDst,
-		      PictFormatPtr pPictFormat,
-		      CARD16	    width,
-		      CARD16	    height,
-		      Bool	    accelerate)
-{
-    PixmapPtr	 pPixmap;
-    PicturePtr	 pPicture;
-    GCPtr	 pGC;
-    int		 error;
-    xRectangle	 rect;
-
-    if (width > 32767 || height > 32767)
-	return 0;
-
-    pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, 
-					pPictFormat->depth);
-    if (!pPixmap)
-	return 0;
-
-    if (!accelerate)
-    {
-	XGL_PIXMAP_PRIV (pPixmap);
-	
-	if (!xglAllocatePixmapBits (pPixmap, XGL_PIXMAP_USAGE_HINT_DEFAULT))
-	{
-	    (*pScreen->DestroyPixmap) (pPixmap);
-	    return 0;
-	}
-
-	pPixmapPriv->target = xglPixmapTargetNo;
-    }
-    
-    pGC = GetScratchGC (pPixmap->drawable.depth, pScreen);
-    if (!pGC)
-    {
-	(*pScreen->DestroyPixmap) (pPixmap);
-	return 0;
-    }
-
-    rect.x = 0;
-    rect.y = 0;
-    rect.width = width;
-    rect.height = height;
-    
-    ValidateGC (&pPixmap->drawable, pGC);
-    (*pGC->ops->PolyFillRect) (&pPixmap->drawable, pGC, 1, &rect);
-    FreeScratchGC (pGC);
-
-    pPicture = CreatePicture (0, &pPixmap->drawable, pPictFormat,
-			      0, 0, serverClient, &error);
-    (*pScreen->DestroyPixmap) (pPixmap);
-    
-    return pPicture;
-}
-
 #define LINE_FIXED_X(l, _y, v)			 \
     dx = (l)->p2.x - (l)->p1.x;			 \
     ex = (xFixed_32_32) ((_y) - (l)->p1.y) * dx; \
@@ -111,9 +53,10 @@ xglCreateMaskPicture (ScreenPtr     pScreen,
     (v) = (l)->p1.x + (xFixed) ((ex + (dy - 1)) / dy)
 
 static Bool
-xglTrapezoidBounds (int	       ntrap,
-		    xTrapezoid *traps,
-		    BoxPtr     box)
+xglTrapezoidExtents (PicturePtr pDst,
+		     int        ntrap,
+		     xTrapezoid *traps,
+		     BoxPtr     extents)
 {
     Bool	 x_overlap, overlap = FALSE;
     xFixed	 dx, dy, top, bottom;
@@ -121,24 +64,24 @@ xglTrapezoidBounds (int	       ntrap,
 
     if (!ntrap)
     {
-	box->x1 = MAXSHORT;
-	box->x2 = MINSHORT;
-	box->y1 = MAXSHORT;
-	box->y2 = MINSHORT;
+	extents->x1 = MAXSHORT;
+	extents->x2 = MINSHORT;
+	extents->y1 = MAXSHORT;
+	extents->y2 = MINSHORT;
 
 	return FALSE;
     }
 
-    box->y1 = xFixedToInt (traps->top);
-    box->y2 = xFixedToInt (xFixedCeil (traps->bottom));
+    extents->y1 = xFixedToInt (traps->top);
+    extents->y2 = xFixedToInt (xFixedCeil (traps->bottom));
     
     LINE_FIXED_X (&traps->left, traps->top, top);
     LINE_FIXED_X (&traps->left, traps->bottom, bottom);
-    box->x1 = xFixedToInt (MIN (top, bottom));
+    extents->x1 = xFixedToInt (MIN (top, bottom));
     
     LINE_FIXED_X_CEIL (&traps->right, traps->top, top);
     LINE_FIXED_X_CEIL (&traps->right, traps->bottom, bottom);
-    box->x2 = xFixedToInt (xFixedCeil (MAX (top, bottom)));
+    extents->x2 = xFixedToInt (xFixedCeil (MAX (top, bottom)));
     
     ntrap--;
     traps++;
@@ -162,35 +105,37 @@ xglTrapezoidBounds (int	       ntrap,
 	x2 = xFixedToInt (xFixedCeil (MAX (top, bottom)));
 	
 	x_overlap = FALSE;
-	if (x1 >= box->x2)
-	    box->x2 = x2;
-	else if (x2 <= box->x1)
-	    box->x1 = x1;
+	if (x1 >= extents->x2)
+	    extents->x2 = x2;
+	else if (x2 <= extents->x1)
+	    extents->x1 = x1;
 	else
 	{
 	    x_overlap = TRUE;
-	    if (x1 < box->x1)
-		box->x1 = x1;
-	    if (x2 > box->x2)
-		box->x2 = x2;
+	    if (x1 < extents->x1)
+		extents->x1 = x1;
+	    if (x2 > extents->x2)
+		extents->x2 = x2;
 	}
 	
-	if (y1 >= box->y2)
-	    box->y2 = y2;
-	else if (y2 <= box->y1)
-	    box->y1 = y1;	    
+	if (y1 >= extents->y2)
+	    extents->y2 = y2;
+	else if (y2 <= extents->y1)
+	    extents->y1 = y1;	    
 	else
 	{
-	    if (y1 < box->y1)
-		box->y1 = y1;
-	    if (y2 > box->y2)
-		box->y2 = y2;
+	    if (y1 < extents->y1)
+		extents->y1 = y1;
+	    if (y2 > extents->y2)
+		extents->y2 = y2;
 	    
 	    if (x_overlap)
 		overlap = TRUE;
 	}
     }
 
+    xglPictureClipExtents (pDst, extents);
+
     return overlap;
 }
 
@@ -211,24 +156,30 @@ xglTrapezoids (CARD8	     op,
     unsigned int    polyEdge = pDst->polyEdge;
     INT16	    xDst, yDst;
     INT16	    xOff, yOff;
-    BoxRec	    bounds;
+    BoxRec	    extents;
     Bool	    overlap;
+    Bool	    target;
     
     XGL_SCREEN_PRIV (pScreen);
+    XGL_DRAWABLE_PIXMAP_PRIV (pDst->pDrawable);
 
     xDst = traps[0].left.p1.x >> 16;
     yDst = traps[0].left.p1.y >> 16;
     
-    overlap = xglTrapezoidBounds (nTrap, traps, &bounds);
-    if (bounds.y1 >= bounds.y2 || bounds.x1 >= bounds.x2)
+    overlap = xglTrapezoidExtents (pDst, nTrap, traps, &extents);
+    if (extents.y1 >= extents.y2 || extents.x1 >= extents.x2)
 	return;
 
+    target = xglPrepareTarget (pDst->pDrawable);
+
     if (nTrap > 1 && op != PictOpAdd && maskFormat &&
 	(overlap || op != PictOpOver))
     {
-	xglPixmapPtr pPixmapPriv;
-	int	     width, height;
-	Bool	     accelerate;
+	PixmapPtr  pPixmap;
+	GCPtr	   pGC;
+	xRectangle rect;
+	int	   error;
+	int	   area;
 	
 	if (!pScreenPriv->pSolidAlpha)
 	{
@@ -237,39 +188,53 @@ xglTrapezoids (CARD8	     op,
 		return;
 	}
 
-	accelerate = TRUE;
-	width  = bounds.x2 - bounds.x1;
-	height = bounds.y2 - bounds.y1;
-	if (maskFormat->depth > 1)
-	{
-	    /* Avoid acceleration if the estimated amount of vertex data
-	       is likely to exceed the size of the mask. */
-	    if ((SMOOTH_TRAPS_ESTIMATE_RECTS (nTrap) * 4) > (width * height))
-		accelerate = FALSE;
-	} else
-	    accelerate = FALSE;
+	rect.x = 0;
+	rect.y = 0;
+	rect.width = extents.x2 - extents.x1;
+	rect.height = extents.y2 - extents.y1;
 
-	pMask = xglCreateMaskPicture (pScreen, pDst, maskFormat,
-				      width, height, accelerate);
+	pPixmap = (*pScreen->CreatePixmap) (pScreen,
+					    rect.width, rect.height, 
+					    maskFormat->depth);
+	if (!pPixmap)
+	    return;
+    
+	pMask = CreatePicture (0, &pPixmap->drawable, maskFormat,
+			       0, 0, serverClient, &error);
 	if (!pMask)
+	{
+	    (*pScreen->DestroyPixmap) (pPixmap);
 	    return;
+	}
+	
+	/* make sure destination drawable is locked */
+	pPixmapPriv->lock++;
 
+	/* lock mask if we are not doing accelerated drawing to destination */
+	area = rect.width * rect.height;
+	if (!target || (SMOOTH_TRAPS_ESTIMATE_RECTS (nTrap) * 4) > area)
+	    XGL_GET_PIXMAP_PRIV (pPixmap)->lock = 1;
+	
 	ValidatePicture (pMask);
+	pGC = GetScratchGC (pPixmap->drawable.depth, pScreen);
+	ValidateGC (&pPixmap->drawable, pGC);
+	(*pGC->ops->PolyFillRect) (&pPixmap->drawable, pGC, 1, &rect);
+	FreeScratchGC (pGC);
 
-	/* all will be damaged */
-	pPixmapPriv = XGL_GET_DRAWABLE_PIXMAP_PRIV (pMask->pDrawable);
-	pPixmapPriv->damageBox.x1 = 0;
-	pPixmapPriv->damageBox.y1 = 0;
-	pPixmapPriv->damageBox.x2 = pMask->pDrawable->width;
-	pPixmapPriv->damageBox.y2 = pMask->pDrawable->height;
+	(*pScreen->DestroyPixmap) (pPixmap);
 
-	xOff = -bounds.x1;
-	yOff = -bounds.y1;
+	target = xglPrepareTarget (pMask->pDrawable);
+	
+	xOff = -extents.x1;
+	yOff = -extents.y1;
 	pSrcPicture = pScreenPriv->pSolidAlpha;
 	pDstPicture = pMask;
     }
     else
     {
+	/* make sure destination drawable is locked */
+	pPixmapPriv->lock++;
+
 	if (maskFormat)
 	{
 	    if (maskFormat->depth == 1)
@@ -284,7 +249,7 @@ xglTrapezoids (CARD8	     op,
 	pDstPicture = pDst;
     }
 
-    if (xglPrepareTarget (pDstPicture->pDrawable))
+    if (target)
     {
 	if (maskFormat || polyEdge == PolyEdgeSmooth)
 	{
@@ -309,7 +274,8 @@ xglTrapezoids (CARD8	     op,
 		{
 		    if (pMask)
 			FreePicture (pMask, 0);
-		    
+
+		    pPixmapPriv->lock--;
 		    return;
 		}
 		
@@ -337,7 +303,8 @@ xglTrapezoids (CARD8	     op,
 	    {
 		if (pMask)
 		    FreePicture (pMask, 0);
-		
+
+		pPixmapPriv->lock--;
 		return;
 	    }
 	    
@@ -354,13 +321,13 @@ xglTrapezoids (CARD8	     op,
 		 pSrcPicture,
 		 NULL,
 		 pDstPicture,
-		 bounds.x1 + xOff + xSrc - xDst,
-		 bounds.y1 + yOff + ySrc - yDst,
+		 extents.x1 + xOff + xSrc - xDst,
+		 extents.y1 + yOff + ySrc - yDst,
 		 0, 0,
-		 pDstPicture->pDrawable->x + bounds.x1 + xOff,
-		 pDstPicture->pDrawable->y + bounds.y1 + yOff,
-		 bounds.x2 - bounds.x1,
-		 bounds.y2 - bounds.y1,
+		 pDstPicture->pDrawable->x + extents.x1 + xOff,
+		 pDstPicture->pDrawable->y + extents.y1 + yOff,
+		 extents.x2 - extents.x1,
+		 extents.y2 - extents.y1,
 		 pGeometry,
 		 mask))
     {
@@ -370,7 +337,7 @@ xglTrapezoids (CARD8	     op,
 	{
 	    RegionRec region;
 
-	    REGION_INIT (pScreen, &region, &bounds, 1);
+	    REGION_INIT (pScreen, &region, &extents, 1);
 	    REGION_TRANSLATE (pScreen, &region,
 			      pDst->pDrawable->x, pDst->pDrawable->y);
 	    
@@ -385,10 +352,10 @@ xglTrapezoids (CARD8	     op,
     {
 	XGL_DRAWABLE_PIXMAP_PRIV (pDstPicture->pDrawable);
 
-	pPixmapPriv->damageBox.x1 = bounds.x1 + xOff;
-	pPixmapPriv->damageBox.y1 = bounds.y1 + yOff;
-	pPixmapPriv->damageBox.x2 = bounds.x2 + xOff;
-	pPixmapPriv->damageBox.y2 = bounds.y2 + yOff;
+	pPixmapPriv->damageBox.x1 = extents.x1 + xOff;
+	pPixmapPriv->damageBox.y1 = extents.y1 + yOff;
+	pPixmapPriv->damageBox.x2 = extents.x2 + xOff;
+	pPixmapPriv->damageBox.y2 = extents.y2 + yOff;
 
 	xglSyncDamageBoxBits (pDstPicture->pDrawable);
 
@@ -411,15 +378,18 @@ xglTrapezoids (CARD8	     op,
 	xglLeaveOffscreenArea ((PixmapPtr) pMask->pDrawable);
 	
 	CompositePicture (op, pSrc, pMask, pDst,
-			  bounds.x1 + xSrc - xDst,
-			  bounds.y1 + ySrc - yDst,
+			  extents.x1 + xSrc - xDst,
+			  extents.y1 + ySrc - yDst,
 			  0, 0,
-			  bounds.x1, bounds.y1,
-			  bounds.x2 - bounds.x1,
-			  bounds.y2 - bounds.y1);
+			  extents.x1, extents.y1,
+			  extents.x2 - extents.x1,
+			  extents.y2 - extents.y1);
 	
 	FreePicture (pMask, 0);
     }
+
+    /* release destination drawable lock */
+    pPixmapPriv->lock--;
 }
 
 void