xserver: Branch 'glucose-2'

Alan Hourihane alanh at kemper.freedesktop.org
Wed Aug 20 02:42:52 PDT 2008 

 xgl/xglcopy.c     |    4 ++--
 xgl/xglgc.c       |   12 ++++++++++++
 xgl/xglgeometry.c |   34 +++++++++++++++++++++++++++++++++-
 xgl/xglget.c      |    4 ++--
 xgl/xglglyph.c    |   41 +++++++++++++++++++++++++++++++++++++++--
 xgl/xglsolid.c    |    8 +++++---
 xgl/xglsync.c     |   28 +++++++++++++++-------------
 xgl/xgltile.c     |   43 ++++++++++++++++++++++++++++++++++++-------
 xgl/xgltrap.c     |    8 ++++++++
 xgl/xglwindow.c   |    2 ++
 10 files changed, 154 insertions(+), 30 deletions(-)

New commits:
commit 1d538d9cd3c25c258c09197b1e28dd8b2c99660a
Author: Alan Hourihane <alanh at localhost.(none)>
Date:   Wed Aug 20 10:42:41 2008 +0100

    Update XGL path Enter/Leave path

diff --git a/xgl/xglcopy.c b/xgl/xglcopy.c
index a640163..6ec8d97 100644
--- a/xgl/xglcopy.c
+++ b/xgl/xglcopy.c
@@ -60,11 +60,11 @@ xglCopy (DrawablePtr pSrc,
     XGL_GET_DRAWABLE (pSrc, src, srcXoff, srcYoff);
     XGL_GET_DRAWABLE (pDst, dst, dstXoff, dstYoff);
 
+    xglLeaveServer(pDst->pScreen);
     glitz_surface_set_clip_region (dst,
 				   dstXoff, dstYoff,
 				   (glitz_box_t *) pBox, nBox);
 
-    xglLeaveServer();
     glitz_copy_area (src,
 		     dst,
 		     srcXoff + dx,
@@ -73,9 +73,9 @@ xglCopy (DrawablePtr pSrc,
 		     pPixmap->drawable.height - dstYoff,
 		     dstXoff,
 		     dstYoff);
-    xglEnterServer();
 
     glitz_surface_set_clip_region (dst, 0, 0, NULL, 0);
+    xglEnterServer(pDst->pScreen);
 
     if (glitz_surface_get_status (dst))
 	return FALSE;
diff --git a/xgl/xglgc.c b/xgl/xglgc.c
index deb3982..b9e464f 100644
--- a/xgl/xglgc.c
+++ b/xgl/xglgc.c
@@ -28,6 +28,8 @@
 #include "gcstruct.h"
 #include "migc.h"
 
+DevPrivateKey xglGCPrivateKey = &xglGCPrivateKey;
+
 #define XGL_GC_OP_FALLBACK_PROLOGUE(pDrawable) \
     xglSyncDamageBoxBits (pDrawable);	       \
     XGL_GC_UNWRAP (funcs);		       \
@@ -494,11 +496,13 @@ xglDestroyGC (GCPtr pGC)
 {
     XGL_GC_PRIV (pGC);
 
+    xglLeaveServer(pGC->pScreen);
     if (pGCPriv->fg)
 	glitz_surface_destroy (pGCPriv->fg);
 
     if (pGCPriv->bg)
 	glitz_surface_destroy (pGCPriv->bg);
+    xglEnterServer(pGC->pScreen);
 
     XGL_GC_UNWRAP (funcs);
     XGL_GC_UNWRAP (ops);
@@ -549,6 +553,8 @@ xglValidateGC (GCPtr	     pGC,
 
 		pGCPriv->flags |= xglGCSoftwareDrawableFlag;
 
+		xglLeaveServer(pDrawable->pScreen);
+
 		if (pGCPriv->fg)
 		    glitz_surface_destroy (pGCPriv->fg);
 
@@ -565,6 +571,8 @@ xglValidateGC (GCPtr	     pGC,
 		if (pGCPriv->bg)
 		    glitz_surface_set_fill (pGCPriv->bg, GLITZ_FILL_REPEAT);
 
+		xglEnterServer(pDrawable->pScreen);
+
 		pGCPriv->id = format->id;
 
 		if (pGCPriv->fg && pGCPriv->bg)
@@ -628,6 +636,8 @@ xglValidateGC (GCPtr	     pGC,
 	    format.bytes_per_line = sizeof (CARD32);
 	    format.scanline_order = GLITZ_PIXEL_SCANLINE_ORDER_BOTTOM_UP;
 
+	    xglLeaveServer(pDrawable->pScreen);
+
 	    buffer = glitz_buffer_create_for_data (&pixel);
 
 	    if (changes & GCForeground)
@@ -643,6 +653,8 @@ xglValidateGC (GCPtr	     pGC,
 	    }
 
 	    glitz_buffer_destroy (buffer);
+
+	    xglEnterServer(pDrawable->pScreen);
 	}
     }
 }
diff --git a/xgl/xglgeometry.c b/xgl/xglgeometry.c
index 7ab1ba4..1ac0de7 100644
--- a/xgl/xglgeometry.c
+++ b/xgl/xglgeometry.c
@@ -55,6 +55,8 @@ xglGeometryResize (ScreenPtr	  pScreen,
     {
 	pGeometry->data = xrealloc (pGeometry->data, size);
 
+	xglLeaveServer(pScreen);
+
 	if (pGeometry->buffer)
 	    glitz_buffer_destroy (pGeometry->buffer);
 
@@ -66,19 +68,25 @@ xglGeometryResize (ScreenPtr	  pScreen,
 	    if (!pGeometry->buffer)
 	    {
 		pGeometry->broken = TRUE;
+		xglEnterServer(pScreen);
 		return;
 	    }
 	}
 	else if (size)
 	{
 	    pGeometry->broken = TRUE;
+	    xglEnterServer(pScreen);
 	    return;
 	}
+
+	xglEnterServer(pScreen);
     }
     else
     {
 	glitz_buffer_t *newBuffer;
 
+	xglLeaveServer(pScreen);
+	
 	if (size)
 	{
 	    newBuffer =
@@ -87,6 +95,7 @@ xglGeometryResize (ScreenPtr	  pScreen,
 	    if (!newBuffer)
 	    {
 		pGeometry->broken = TRUE;
+		xglEnterServer(pScreen);
 		return;
 	    }
 	} else
@@ -109,6 +118,9 @@ xglGeometryResize (ScreenPtr	  pScreen,
 
 	    glitz_buffer_destroy (pGeometry->buffer);
 	}
+
+	xglEnterServer(pScreen);
+
 	pGeometry->buffer = newBuffer;
     }
 
@@ -129,8 +141,10 @@ xglGeometryResize (ScreenPtr	  pScreen,
 	if ((pGeometry)->broken)					  \
 	    return;							  \
     }									  \
+    xglLeaveServer(pScreen);							  \
     (ptr) = glitz_buffer_map ((pGeometry)->buffer,			  \
 			      GLITZ_BUFFER_ACCESS_WRITE_ONLY);		  \
+    xglEnterServer(pScreen);							  \
     if (!(ptr))								  \
     {									  \
 	(pGeometry)->broken = TRUE;					  \
@@ -139,11 +153,14 @@ xglGeometryResize (ScreenPtr	  pScreen,
     (ptr) += (offset)
 
 #define UNMAP_GEOMETRY(pGeometry, offset, _size)			   \
+    xglLeaveServer(pScreen);							   \
     if (glitz_buffer_unmap ((pGeometry)->buffer))			   \
     {									   \
 	(pGeometry)->broken = TRUE;					   \
+        xglEnterServer(pScreen);						   \
 	return;								   \
     }									   \
+    xglEnterServer(pScreen);							   \
     if (((offset) + (_size)) > (pGeometry)->endOffset)			   \
     {									   \
 	(pGeometry)->endOffset = (offset) + (_size);			   \
@@ -458,7 +475,9 @@ xglGeometryForGlyph (ScreenPtr	    pScreen,
 	    glyphbase = pglyph;
     }
 
+    xglLeaveServer(pScreen);
     buffer = glitz_buffer_create_for_data (glyphbase);
+    xglEnterServer(pScreen);
     if (!buffer)
     {
 	pGeometry->broken = TRUE;
@@ -467,7 +486,9 @@ xglGeometryForGlyph (ScreenPtr	    pScreen,
 
     GEOMETRY_SET_BUFFER (pGeometry, buffer);
 
+    xglLeaveServer(pScreen);
     array = glitz_multi_array_create (nGlyph);
+    xglEnterServer(pScreen);
     if (!array)
     {
 	pGeometry->broken = TRUE;
@@ -489,18 +510,22 @@ xglGeometryForGlyph (ScreenPtr	    pScreen,
 	    gx = x + pci->metrics.leftSideBearing;
 	    gy = -pci->metrics.ascent;
 
+    	    xglLeaveServer(pScreen);
 	    glitz_multi_array_add (array,
 				   (pglyph - glyphbase) * 8,
 				   gWidth, gHeight,
 				   (gx - lastX) << 16, (gy - lastY) << 16);
+    	    xglEnterServer(pScreen);
 	    lastX = gx;
 	    lastY = gy;
 	}
 	x += pci->metrics.characterWidth;
     }
 
+    xglLeaveServer(pScreen);
     glitz_buffer_destroy (buffer);
     glitz_multi_array_destroy (array);
+    xglEnterServer(pScreen);
 }
 
 #define FIXED_LINE_X_TO_FLOAT(line, v)		  \
@@ -640,7 +665,9 @@ xglGetScratchGeometryWithSize (ScreenPtr pScreen,
     {
 	if (pGeometry->array)
 	{
+    	    xglLeaveServer(pScreen);
 	    glitz_multi_array_destroy (pGeometry->array);
+    	    xglEnterServer(pScreen);
 	    pGeometry->array = NULL;
 	}
 	pGeometry->endOffset = 0;
@@ -703,12 +730,15 @@ xglGetScratchVertexGeometry (ScreenPtr pScreen,
 }
 
 Bool
-xglSetGeometry (xglGeometryPtr	pGeometry,
+xglSetGeometry (ScreenPtr pScreen,
+		xglGeometryPtr	pGeometry,
 		glitz_surface_t *surface)
 {
     if (pGeometry->broken)
 	return FALSE;
 
+    xglLeaveServer(pScreen);
+
     glitz_set_geometry (surface, pGeometry->type, &pGeometry->f,
 			pGeometry->buffer);
 
@@ -720,5 +750,7 @@ xglSetGeometry (xglGeometryPtr	pGeometry,
 			 pGeometry->first, pGeometry->width, pGeometry->count,
 			 pGeometry->xOff, pGeometry->yOff);
 
+    xglEnterServer(pScreen);
+
     return TRUE;
 }
diff --git a/xgl/xglget.c b/xgl/xglget.c
index 893ab2c..1b90c1d 100644
--- a/xgl/xglget.c
+++ b/xgl/xglget.c
@@ -48,10 +48,10 @@ xglGetImage (DrawablePtr   pDrawable,
 	if (!xglSyncSurface (&pScreenPriv->pScreenPixmap->drawable))
 	    FatalError (XGL_SW_FAILURE_STRING);
 
-	xglLeaveServer();
+	xglLeaveServer(pScreen);
 	glitz_surface_flush (pScreenPriv->surface);
 	glitz_drawable_finish (pScreenPriv->drawable);
-	xglEnterServer();
+	xglEnterServer(pScreen);
     }
 
     XGL_GET_DRAWABLE (pDrawable, surface, xOff, yOff);
diff --git a/xgl/xglglyph.c b/xgl/xglglyph.c
index c1a484a..abcc7e3 100644
--- a/xgl/xglglyph.c
+++ b/xgl/xglglyph.c
@@ -63,6 +63,8 @@
     WRITE_VEC2 (ptr, _vx1, _vy2);		    \
     WRITE_VEC2 (ptr, (box).x1, (box).y1)
 
+DevPrivateKey xglGlyphPrivateKey = &xglGlyphPrivateKey;
+
 typedef union _xglGlyphList {
     glitz_short_t *s;
     glitz_float_t *f;
@@ -245,6 +247,8 @@ xglInitGlyphCache (xglGlyphCachePtr pCache,
 			      (pointer) pCache))
 	    return FALSE;
 
+	xglLeaveServer(pScreen);
+
 	if (pScreenPriv->geometryDataType == GEOMETRY_DATA_TYPE_SHORT)
 	{
 	    attr.unnormalized = 1;
@@ -276,6 +280,8 @@ xglInitGlyphCache (xglGlyphCachePtr pCache,
 	if (NEEDS_COMPONENT (format->format))
 	    glitz_surface_set_component_alpha (mask, 1);
 
+	xglEnterServer(pScreen);
+
 	pTexture->pMask = xglCreateDevicePicture (mask);
 	if (!pTexture->pMask)
 	    return FALSE;
@@ -416,9 +422,16 @@ xglCacheGlyph (xglGlyphCachePtr pCache,
 	{
 	    glitz_buffer_t *buffer;
 
+	    xglLeaveServer(pScreen);
+
 	    buffer = glitz_buffer_create_for_data (pGlyph + 1);
-	    if (!buffer)
+	    if (!buffer) {
+	    	xglEnterServer(pScreen);
+
 		return NULL;
+	    }
+
+	    xglEnterServer(pScreen);
 
 	    /* Find available area */
 	    if (!xglFindArea (pCache->rootArea.pArea,
@@ -445,6 +458,8 @@ xglCacheGlyph (xglGlyphCachePtr pCache,
 
 		surface = pTexture->pMask->pSourcePict->source.devPrivate.ptr;
 
+	    	xglLeaveServer(pScreen);
+
 		glitz_set_pixels (surface,
 				  pGlyphPriv->pArea->x,
 				  pGlyphPriv->pArea->y,
@@ -461,6 +476,8 @@ xglCacheGlyph (xglGlyphCachePtr pCache,
 		glitz_surface_translate_point (surface, &p1, &p1);
 		glitz_surface_translate_point (surface, &p2, &p2);
 
+	    	xglEnterServer(pScreen);
+
 		pAreaPriv->serial = glyphSerialNumber;
 		if (pTexture->geometryDataType)
 		{
@@ -477,7 +494,9 @@ xglCacheGlyph (xglGlyphCachePtr pCache,
 		    pAreaPriv->u.box.sBox.y2 = p2.y >> 16;
 		}
 	    }
+	    xglLeaveServer(pScreen);
 	    glitz_buffer_destroy (buffer);
+	    xglEnterServer(pScreen);
 	} else
 	    pGlyphPriv->pArea = &zeroSizeArea;
     }
@@ -689,13 +708,20 @@ xglCachedGlyphs (CARD8	       op,
 	    pGeometry = &pCache->u.geometry;
 	    pGeometry->xOff = pGeometry->yOff = 0;
 
+	    xglLeaveServer(pScreen);
+
 	    multiArray = glitz_multi_array_create (nGlyph);
-	    if (!multiArray)
+	    if (!multiArray) {
+	    	xglEnterServer(pScreen);
 		return 1;
+	    }
 
 	    GEOMETRY_SET_MULTI_ARRAY (pGeometry, multiArray);
+
 	    glitz_multi_array_destroy (multiArray);
 
+	    xglEnterServer(pScreen);
+
 	    vData.array.lastX = 0;
 	    vData.array.lastY = 0;
 	}
@@ -708,8 +734,12 @@ xglCachedGlyphs (CARD8	       op,
 	    pGeometry->type = GLITZ_GEOMETRY_TYPE_VERTEX;
 	    pMaskPicture = pCache->u.texture.pMask;
 
+	    xglLeaveServer(pScreen);
+
 	    vData.list.s = glitz_buffer_map (pGeometry->buffer,
 					     GLITZ_BUFFER_ACCESS_WRITE_ONLY);
+
+	    xglEnterServer(pScreen);
 	}
     } else
 	pGeometry = NULL;
@@ -768,11 +798,16 @@ xglCachedGlyphs (CARD8	       op,
 	    pGlyphArea = GLYPH_GET_AREA_PRIV (pArea);
 	    if (depth == 1)
 	    {
+	    	xglLeaveServer(pScreen);
+
 		glitz_multi_array_add (pGeometry->array,
 				       pGlyphArea->u.range.first, 2,
 				       pGlyphArea->u.range.count,
 				       (x1 - vData.array.lastX) << 16,
 				       (y1 - vData.array.lastY) << 16);
+
+	    	xglEnterServer(pScreen);
+
 		vData.array.lastX = x1;
 		vData.array.lastY = y1;
 	    }
@@ -799,7 +834,9 @@ xglCachedGlyphs (CARD8	       op,
     {
 	if (depth != 1)
 	{
+	    xglLeaveServer(pScreen);
 	    glitz_buffer_unmap (pGeometry->buffer);
+	    xglEnterServer(pScreen);
 	    pGeometry->count = nGlyph * 4;
 	}
 
diff --git a/xgl/xglsolid.c b/xgl/xglsolid.c
index 97ef7d1..4452960 100644
--- a/xgl/xglsolid.c
+++ b/xgl/xglsolid.c
@@ -53,8 +53,10 @@ xglSolid (DrawablePtr	   pDrawable,
 
     if (pGeometry)
     {
+        xglLeaveServer(pDrawable->pScreen);
 	glitz_surface_set_clip_region (surface, xOff, yOff,
 				       (glitz_box_t *) pBox, nBox);
+	xglEnterServer(pDrawable->pScreen);
     }
     else
     {
@@ -64,10 +66,10 @@ xglSolid (DrawablePtr	   pDrawable,
 
     GEOMETRY_TRANSLATE (pGeometry, xOff, yOff);
 
-    if (!GEOMETRY_ENABLE (pGeometry, surface))
+    if (!GEOMETRY_ENABLE (pDrawable->pScreen, pGeometry, surface))
 	return FALSE;
 
-    xglLeaveServer();
+    xglLeaveServer(pDrawable->pScreen);
     glitz_composite (op,
 		     solid, NULL, surface,
 		     0, 0,
@@ -75,9 +77,9 @@ xglSolid (DrawablePtr	   pDrawable,
 		     x + xOff,
 		     y + yOff,
 		     width, height);
-    xglEnterServer();
 
     glitz_surface_set_clip_region (surface, 0, 0, NULL, 0);
+    xglEnterServer(pDrawable->pScreen);
 
     if (glitz_surface_get_status (surface))
 	return FALSE;
diff --git a/xgl/xglsync.c b/xgl/xglsync.c
index 94417a0..13c9cfe 100644
--- a/xgl/xglsync.c
+++ b/xgl/xglsync.c
@@ -151,10 +151,10 @@ xglSyncBits (DrawablePtr pDrawable,
 	    format.scanline_order = GLITZ_PIXEL_SCANLINE_ORDER_TOP_DOWN;
 	}
 
+	xglLeaveServer(pDrawable->pScreen);
 	glitz_surface_set_clip_region (pPixmapPriv->surface,
 				       0, 0, (glitz_box_t *) pBox, nBox);
 
-	xglLeaveServer();
 	glitz_get_pixels (pPixmapPriv->surface,
 			  pExt->x1,
 			  pExt->y1,
@@ -162,9 +162,9 @@ xglSyncBits (DrawablePtr pDrawable,
 			  pExt->y2 - pExt->y1,
 			  &format,
 			  pPixmapPriv->buffer);
-	xglEnterServer();
 
 	glitz_surface_set_clip_region (pPixmapPriv->surface, 0, 0, NULL, 0);
+	xglEnterServer(pDrawable->pScreen);
     }
 
     REGION_UNINIT (pDrawable->pScreen, &region);
@@ -274,10 +274,10 @@ xglSyncSurface (DrawablePtr pDrawable)
 	    }
 	}
 
+	xglLeaveServer(pDrawable->pScreen);
 	glitz_surface_set_clip_region (pPixmapPriv->surface,
 				       0, 0, (glitz_box_t *) pBox, nBox);
 
-	xglLeaveServer();
 	glitz_set_pixels (pPixmapPriv->surface,
 			  pExt->x1,
 			  pExt->y1,
@@ -285,9 +285,9 @@ xglSyncSurface (DrawablePtr pDrawable)
 			  pExt->y2 - pExt->y1,
 			  &format,
 			  pPixmapPriv->buffer);
-	xglEnterServer();
 
 	glitz_surface_set_clip_region (pPixmapPriv->surface, 0, 0, NULL, 0);
+	xglEnterServer(pDrawable->pScreen);
 
 	REGION_EMPTY (pDrawable->pScreen, pRegion);
     }
@@ -319,6 +319,11 @@ xglPrepareTarget (DrawablePtr pDrawable)
 		width  = pPixmap->drawable.width;
 		height = pPixmap->drawable.height;
 
+		if (!format)
+			return FALSE;
+
+	    	xglLeaveServer(pDrawable->pScreen);
+
 		if (pPixmapPriv->pVisual->pbuffer)
 		{
 		    pPixmapPriv->drawable =
@@ -331,14 +336,20 @@ xglPrepareTarget (DrawablePtr pDrawable)
 			glitz_create_drawable (pScreenPriv->drawable,
 					       format, width, height);
 		}
+
+	    	xglEnterServer(pDrawable->pScreen);
 	    }
 
 	    if (pPixmapPriv->drawable)
 	    {
+	    	xglLeaveServer(pDrawable->pScreen);
+
 		glitz_surface_attach (pPixmapPriv->surface,
 				      pPixmapPriv->drawable,
 				      GLITZ_DRAWABLE_BUFFER_FRONT_COLOR);
 
+	    	xglEnterServer(pDrawable->pScreen);
+
 		pPixmapPriv->target = xglPixmapTargetIn;
 
 		return TRUE;
@@ -475,15 +486,6 @@ xglAddCurrentBitDamage (DrawablePtr pDrawable)
 {
     XGL_DRAWABLE_PIXMAP_PRIV (pDrawable);
 
-    {
-    	/* This is a little severe as it also impacts xgl - tune me */
-    	XGL_SCREEN_PRIV (pDrawable->pScreen);
-	xglLeaveServer();
-	glitz_surface_flush (pScreenPriv->surface);
-	glitz_drawable_finish (pScreenPriv->drawable);
-	xglEnterServer();
-    }
-
     if (REGION_NOTEMPTY (pDrawable->pScreen, &pPixmapPriv->bitRegion))
     {
 	BoxPtr pBitExt;
diff --git a/xgl/xgltile.c b/xgl/xgltile.c
index 5c5fad1..91bb0e9 100644
--- a/xgl/xgltile.c
+++ b/xgl/xgltile.c
@@ -74,8 +74,12 @@ xglTiledBoxGeometry (PixmapPtr pTile,
 						     GEOMETRY_DATA_TYPE_FLOAT,
 						     8 * size);
 
+    xglLeaveServer(pScreen);
+
     data = glitz_buffer_map (pGeometry->buffer,
 			     GLITZ_BUFFER_ACCESS_WRITE_ONLY);
+	
+    xglEnterServer(pScreen);
 
     while (nBox--)
     {
@@ -106,9 +110,13 @@ xglTiledBoxGeometry (PixmapPtr pTile,
 		p2.x = (xTileTmp + widthTile) << 16;
 		p2.y = (yTile + heightTile) << 16;
 
+    		xglLeaveServer(pScreen);
+
 		glitz_surface_translate_point (pPixmapPriv->surface, &p1, &p1);
 		glitz_surface_translate_point (pPixmapPriv->surface, &p2, &p2);
 
+    		xglEnterServer(pScreen);
+
 		x1 = FIXED_TO_FLOAT (p1.x);
 		y1 = FIXED_TO_FLOAT (p1.y);
 		x2 = FIXED_TO_FLOAT (p2.x);
@@ -149,16 +157,24 @@ xglTiledBoxGeometry (PixmapPtr pTile,
 	pBox++;
     }
 
-    if (glitz_buffer_unmap (pGeometry->buffer))
+    xglLeaveServer(pScreen);
+
+    if (glitz_buffer_unmap (pGeometry->buffer)) {
+    	xglEnterServer(pScreen);
+
 	return NULL;
+    }
 
     pGeometry->f     = tileGeometryFormat;
     pGeometry->count =
 	pGeometry->endOffset / tileGeometryFormat.vertex.bytes_per_vertex;
 
     pPixmapPriv->pictureMask |= xglPCFillMask;
+
     glitz_surface_set_fill (pPixmapPriv->surface, GLITZ_FILL_TRANSPARENT);
 
+    xglEnterServer(pScreen);
+
     return pGeometry;
 }
 
@@ -194,17 +210,27 @@ xglTile (DrawablePtr	  pDrawable,
     pTilePriv = XGL_GET_PIXMAP_PRIV (pTile);
 
     pTilePriv->pictureMask |= xglPCFilterMask | xglPCTransformMask;
+
+    xglLeaveServer(pDrawable->pScreen);
+
     glitz_surface_set_filter (pTilePriv->surface,
 			      GLITZ_FILTER_NEAREST,
 			      NULL, 0);
     glitz_surface_set_transform (pTilePriv->surface, NULL);
 
+    xglEnterServer(pDrawable->pScreen);
+
     if (pTilePriv->acceleratedTile)
     {
 	if (pGeometry)
 	{
+    	    xglLeaveServer(pDrawable->pScreen);
+
 	    glitz_surface_set_clip_region (surface, xOff, yOff,
 					   (glitz_box_t *) pBox, nBox);
+
+    	    xglEnterServer(pDrawable->pScreen);
+
 	    nBox = 0;
 	}
 	else
@@ -216,13 +242,15 @@ xglTile (DrawablePtr	  pDrawable,
 
 	GEOMETRY_TRANSLATE (pGeometry, xOff, yOff);
 
-	if (!GEOMETRY_ENABLE (pGeometry, surface))
+	if (!GEOMETRY_ENABLE (pDrawable->pScreen, pGeometry, surface))
 	    return FALSE;
 
 	pTilePriv->pictureMask |= xglPCFillMask;
+	
+	xglLeaveServer(pDrawable->pScreen);
+
 	glitz_surface_set_fill (pTilePriv->surface, GLITZ_FILL_REPEAT);
 
-	xglLeaveServer();
 	glitz_composite (op,
 			 pTilePriv->surface, NULL, surface,
 			 x + tileX,
@@ -231,10 +259,11 @@ xglTile (DrawablePtr	  pDrawable,
 			 x + xOff,
 			 y + yOff,
 			 width, height);
-	xglEnterServer();
 
 	glitz_surface_set_clip_region (surface, 0, 0, NULL, 0);
 
+	xglEnterServer(pDrawable->pScreen);
+
 	if (!glitz_surface_get_status (surface))
 	    return TRUE;
 
@@ -253,10 +282,10 @@ xglTile (DrawablePtr	  pDrawable,
 
     GEOMETRY_TRANSLATE (pGeometry, xOff, yOff);
 
-    if (!GEOMETRY_ENABLE (pGeometry, surface))
+    if (!GEOMETRY_ENABLE (pDrawable->pScreen, pGeometry, surface))
 	return FALSE;
 
-    xglLeaveServer();
+    xglLeaveServer(pDrawable->pScreen);
     glitz_composite (op,
 		     pTilePriv->surface, NULL, surface,
 		     0, 0,
@@ -264,7 +293,7 @@ xglTile (DrawablePtr	  pDrawable,
 		     x + xOff,
 		     y + yOff,
 		     width, height);
-    xglEnterServer();
+    xglEnterServer(pDrawable->pScreen);
 
     if (glitz_surface_get_status (surface))
 	return FALSE;
diff --git a/xgl/xgltrap.c b/xgl/xgltrap.c
index 6e7a508..f80e421 100644
--- a/xgl/xgltrap.c
+++ b/xgl/xgltrap.c
@@ -279,12 +279,16 @@ xglTrapezoids (CARD8	     op,
 		    return;
 		}
 
+		xglLeaveServer(pScreen);
+
 		offset +=
 		    glitz_add_trapezoids (pGeometry->buffer,
 					  offset, size - offset, format->type,
 					  mask, (glitz_trapezoid_t *) pTrap, n,
 					  &nAddedTrap);
 
+		xglEnterServer(pScreen);
+
 		n     -= nAddedTrap;
 		pTrap += nAddedTrap;
 		size  *= 2;
@@ -437,12 +441,16 @@ xglAddTraps (PicturePtr pDst,
 	    if (!pGeometry->buffer)
 		return;
 
+	    xglLeaveServer(pScreen);
+	    
 	    offset +=
 		glitz_add_traps (pGeometry->buffer,
 				 offset, size - offset, format->type, mask,
 				 (glitz_trap_t *) pTrap, n,
 				 &nAddedTrap);
 
+	    xglEnterServer(pScreen);
+
 	    n     -= nAddedTrap;
 	    pTrap += nAddedTrap;
 	    size  *= 2;
diff --git a/xgl/xglwindow.c b/xgl/xglwindow.c
index 393f01d..e391eb5 100644
--- a/xgl/xglwindow.c
+++ b/xgl/xglwindow.c
@@ -26,6 +26,8 @@
 #include "xgl.h"
 #include "fb.h"
 
+DevPrivateKey xglWinPrivateKey = &xglWinPrivateKey;
+
 #define XGL_WINDOW_FALLBACK_PROLOGUE(pWin, func)		       \
     if (!xglMapPixmapBits (XGL_GET_DRAWABLE_PIXMAP (&pWin->drawable))) \
 	FatalError (XGL_SW_FAILURE_STRING);			       \

More information about the xorg-commit mailing list