libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 312 insertions, 398 deletions

diff --git a/xorg-server/hw/xfree86/xaa/xaaGC.c b/xorg-server/hw/xfree86/xaa/xaaGC.c
index 1bc35d9f3..d55f1e445 100644
--- a/xorg-server/hw/xfree86/xaa/xaaGC.c
+++ b/xorg-server/hw/xfree86/xaa/xaaGC.c
@@ -37,614 +37,528 @@ extern GCOps XAAPixmapOps;
 Bool
 XAACreateGC(GCPtr pGC)
 {
-    ScreenPtr    pScreen = pGC->pScreen;
-    XAAGCPtr     pGCPriv = (XAAGCPtr)dixLookupPrivate(&pGC->devPrivates,
-						      XAAGetGCKey());
-    Bool         ret;
-
-    XAA_SCREEN_PROLOGUE(pScreen,CreateGC);
-
-    if((ret = (*pScreen->CreateGC)(pGC))) {	
-	pGCPriv->wrapOps = NULL;
-	pGCPriv->wrapFuncs = pGC->funcs;
-	pGCPriv->XAAOps = &XAAFallbackOps;
-	pGC->funcs = &XAAGCFuncs;
+    ScreenPtr pScreen = pGC->pScreen;
+    XAAGCPtr pGCPriv = (XAAGCPtr) dixLookupPrivate(&pGC->devPrivates,
+                                                   XAAGetGCKey());
+    Bool ret;
+
+    XAA_SCREEN_PROLOGUE(pScreen, CreateGC);
+
+    if ((ret = (*pScreen->CreateGC) (pGC))) {
+        pGCPriv->wrapOps = NULL;
+        pGCPriv->wrapFuncs = pGC->funcs;
+        pGCPriv->XAAOps = &XAAFallbackOps;
+        pGC->funcs = &XAAGCFuncs;
     }
- 
-    XAA_SCREEN_EPILOGUE(pScreen,CreateGC,XAACreateGC);
+
+    XAA_SCREEN_EPILOGUE(pScreen, CreateGC, XAACreateGC);
 
     return ret;
 }
 
-
 static void
-XAAValidateGC(
-   GCPtr         pGC,
-   unsigned long changes,
-   DrawablePtr   pDraw 
-){
+XAAValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+
     XAA_GC_FUNC_PROLOGUE(pGC);
 
-    (*pGC->funcs->ValidateGC)(pGC, changes, pDraw);
+    (*pGC->funcs->ValidateGC) (pGC, changes, pDraw);
 
-    if((changes & GCPlaneMask) &&
-       ((pGC->planemask & infoRec->FullPlanemasks[pGC->depth - 1]) == 
-	 infoRec->FullPlanemasks[pGC->depth - 1]))
-    {	
-	pGC->planemask = ~0;
+    if ((changes & GCPlaneMask) &&
+        ((pGC->planemask & infoRec->FullPlanemasks[pGC->depth - 1]) ==
+         infoRec->FullPlanemasks[pGC->depth - 1])) {
+        pGC->planemask = ~0;
     }
 
-    if(pGC->depth != 32) {
-	/* 0xffffffff is reserved for transparency */
-	if(pGC->bgPixel == 0xffffffff)
-	    pGC->bgPixel = 0x7fffffff;
-	if(pGC->fgPixel == 0xffffffff)
-	    pGC->fgPixel = 0x7fffffff;
+    if (pGC->depth != 32) {
+        /* 0xffffffff is reserved for transparency */
+        if (pGC->bgPixel == 0xffffffff)
+            pGC->bgPixel = 0x7fffffff;
+        if (pGC->fgPixel == 0xffffffff)
+            pGC->fgPixel = 0x7fffffff;
     }
 
-    if((pDraw->type == DRAWABLE_PIXMAP) && !IS_OFFSCREEN_PIXMAP(pDraw)){
-	pGCPriv->flags = OPS_ARE_PIXMAP;
+    if ((pDraw->type == DRAWABLE_PIXMAP) && !IS_OFFSCREEN_PIXMAP(pDraw)) {
+        pGCPriv->flags = OPS_ARE_PIXMAP;
         pGCPriv->changes |= changes;
 
-	/* make sure we're not using videomemory pixmaps to render
-	   onto system memory drawables */
+        /* make sure we're not using videomemory pixmaps to render
+           onto system memory drawables */
 
-	if((pGC->fillStyle == FillTiled) && 
-	    IS_OFFSCREEN_PIXMAP(pGC->tile.pixmap) &&
-	    !OFFSCREEN_PIXMAP_LOCKED(pGC->tile.pixmap)) {
+        if ((pGC->fillStyle == FillTiled) &&
+            IS_OFFSCREEN_PIXMAP(pGC->tile.pixmap) &&
+            !OFFSCREEN_PIXMAP_LOCKED(pGC->tile.pixmap)) {
 
-	    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-	    FBAreaPtr area = pPriv->offscreenArea;
+            XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
+            FBAreaPtr area = pPriv->offscreenArea;
 
-	    XAARemoveAreaCallback(area); /* clobbers pPriv->offscreenArea */
-	    xf86FreeOffscreenArea(area);
-	}
-    } 
-    else if(!infoRec->pScrn->vtSema && (pDraw->type == DRAWABLE_WINDOW)) {
-	pGCPriv->flags = 0;
+            XAARemoveAreaCallback(area);        /* clobbers pPriv->offscreenArea */
+            xf86FreeOffscreenArea(area);
+        }
+    }
+    else if (!infoRec->pScrn->vtSema && (pDraw->type == DRAWABLE_WINDOW)) {
+        pGCPriv->flags = 0;
         pGCPriv->changes |= changes;
     }
     else {
-	if(!(pGCPriv->flags & OPS_ARE_ACCEL)) {	
-	    changes |= pGCPriv->changes;
-	    pGCPriv->changes = 0;
-	}
-	pGCPriv->flags = OPS_ARE_ACCEL;
+        if (!(pGCPriv->flags & OPS_ARE_ACCEL)) {
+            changes |= pGCPriv->changes;
+            pGCPriv->changes = 0;
+        }
+        pGCPriv->flags = OPS_ARE_ACCEL;
 
 #if 1
-	/* Ugh.  If we can't use the blitter on offscreen pixmaps used
-	   as tiles, then we need to move them out as cfb can't handle
-	   tiles with non-zero origins */
+        /* Ugh.  If we can't use the blitter on offscreen pixmaps used
+           as tiles, then we need to move them out as cfb can't handle
+           tiles with non-zero origins */
 
-	if((pGC->fillStyle == FillTiled) && 
-	    IS_OFFSCREEN_PIXMAP(pGC->tile.pixmap) &&
-	    (DO_PIXMAP_COPY != (*infoRec->TiledFillChooser)(pGC))) {
+        if ((pGC->fillStyle == FillTiled) &&
+            IS_OFFSCREEN_PIXMAP(pGC->tile.pixmap) &&
+            (DO_PIXMAP_COPY != (*infoRec->TiledFillChooser) (pGC))) {
 
-	    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-	    FBAreaPtr area = pPriv->offscreenArea;
+            XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
+            FBAreaPtr area = pPriv->offscreenArea;
 
-	    XAARemoveAreaCallback(area); /* clobbers pPriv->offscreenArea */
-	    xf86FreeOffscreenArea(area);
-	}
+            XAARemoveAreaCallback(area);        /* clobbers pPriv->offscreenArea */
+            xf86FreeOffscreenArea(area);
+        }
 #endif
     }
 
     XAA_GC_FUNC_EPILOGUE(pGC);
 
-    if(!(pGCPriv->flags & OPS_ARE_ACCEL)) return;
+    if (!(pGCPriv->flags & OPS_ARE_ACCEL))
+        return;
+
+    if ((changes & GCTile) && !pGC->tileIsPixel && pGC->tile.pixmap) {
+        XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
 
-    if((changes & GCTile) && !pGC->tileIsPixel && pGC->tile.pixmap){
-	XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-		
-	if(pixPriv->flags & DIRTY) {
-	    pixPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
-	    pGC->tile.pixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
-	}
+        if (pixPriv->flags & DIRTY) {
+            pixPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
+            pGC->tile.pixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+        }
     }
-    if((changes & GCStipple) && pGC->stipple){
-	XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-		
-	if(pixPriv->flags & DIRTY) {
-	    pixPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
-	    pGC->stipple->drawable.serialNumber = NEXT_SERIAL_NUMBER;
-	}
+    if ((changes & GCStipple) && pGC->stipple) {
+        XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
+
+        if (pixPriv->flags & DIRTY) {
+            pixPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
+            pGC->stipple->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+        }
     }
 
     /* If our Ops are still the default ones we need to allocate new ones */
-    if(pGC->ops == &XAAFallbackOps) {
-	if(!(pGCPriv->XAAOps = malloc(sizeof(GCOps)))) {
-	    pGCPriv->XAAOps = &XAAFallbackOps;
-	    return;
-	}
-	/* make a modifiable copy of the default ops */
-	memcpy(pGCPriv->XAAOps, &XAAFallbackOps, sizeof(GCOps));
-	pGC->ops = pGCPriv->XAAOps;
-	changes = ~0;
+    if (pGC->ops == &XAAFallbackOps) {
+        if (!(pGCPriv->XAAOps = malloc(sizeof(GCOps)))) {
+            pGCPriv->XAAOps = &XAAFallbackOps;
+            return;
+        }
+        /* make a modifiable copy of the default ops */
+        memcpy(pGCPriv->XAAOps, &XAAFallbackOps, sizeof(GCOps));
+        pGC->ops = pGCPriv->XAAOps;
+        changes = ~0;
     }
 
-    if(!changes) return;
+    if (!changes)
+        return;
 
-    if((changes & GCDashList) && infoRec->ComputeDash)
-	infoRec->ComputeDash(pGC);
+    if ((changes & GCDashList) && infoRec->ComputeDash)
+        infoRec->ComputeDash(pGC);
 
-    if(changes & infoRec->FillSpansMask)
-	(*infoRec->ValidateFillSpans)(pGC, changes, pDraw); 	
+    if (changes & infoRec->FillSpansMask)
+        (*infoRec->ValidateFillSpans) (pGC, changes, pDraw);
 
-    if(changes & infoRec->SetSpansMask)
-	(*infoRec->ValidateSetSpans)(pGC, changes, pDraw); 	
+    if (changes & infoRec->SetSpansMask)
+        (*infoRec->ValidateSetSpans) (pGC, changes, pDraw);
 
-    if(changes & infoRec->PutImageMask)
-	(*infoRec->ValidatePutImage)(pGC, changes, pDraw); 	
+    if (changes & infoRec->PutImageMask)
+        (*infoRec->ValidatePutImage) (pGC, changes, pDraw);
 
-    if(changes & infoRec->CopyAreaMask)
-	(*infoRec->ValidateCopyArea)(pGC, changes, pDraw); 	
+    if (changes & infoRec->CopyAreaMask)
+        (*infoRec->ValidateCopyArea) (pGC, changes, pDraw);
 
-    if(changes & infoRec->CopyPlaneMask)
-	(*infoRec->ValidateCopyPlane)(pGC, changes, pDraw); 	
+    if (changes & infoRec->CopyPlaneMask)
+        (*infoRec->ValidateCopyPlane) (pGC, changes, pDraw);
 
-    if(changes & infoRec->PolyPointMask)
-	(*infoRec->ValidatePolyPoint)(pGC, changes, pDraw); 	
+    if (changes & infoRec->PolyPointMask)
+        (*infoRec->ValidatePolyPoint) (pGC, changes, pDraw);
 
-    if(changes & infoRec->PolylinesMask)
-	(*infoRec->ValidatePolylines)(pGC, changes, pDraw); 	
+    if (changes & infoRec->PolylinesMask)
+        (*infoRec->ValidatePolylines) (pGC, changes, pDraw);
 
-    if(changes & infoRec->PolySegmentMask)
-	(*infoRec->ValidatePolySegment)(pGC, changes, pDraw); 	
+    if (changes & infoRec->PolySegmentMask)
+        (*infoRec->ValidatePolySegment) (pGC, changes, pDraw);
 
-    if(changes & infoRec->PolyRectangleMask)
-	(*infoRec->ValidatePolyRectangle)(pGC, changes, pDraw); 	
+    if (changes & infoRec->PolyRectangleMask)
+        (*infoRec->ValidatePolyRectangle) (pGC, changes, pDraw);
 
-    if(changes & infoRec->PolyArcMask)
-	(*infoRec->ValidatePolyArc)(pGC, changes, pDraw); 	
+    if (changes & infoRec->PolyArcMask)
+        (*infoRec->ValidatePolyArc) (pGC, changes, pDraw);
 
-    if(changes & infoRec->FillPolygonMask)
-	(*infoRec->ValidateFillPolygon)(pGC, changes, pDraw); 	
+    if (changes & infoRec->FillPolygonMask)
+        (*infoRec->ValidateFillPolygon) (pGC, changes, pDraw);
 
-    if(changes & infoRec->PolyFillRectMask)
-	(*infoRec->ValidatePolyFillRect)(pGC, changes, pDraw); 	
- 
-    if(changes & infoRec->PolyFillArcMask)
-	(*infoRec->ValidatePolyFillArc)(pGC, changes, pDraw); 	
+    if (changes & infoRec->PolyFillRectMask)
+        (*infoRec->ValidatePolyFillRect) (pGC, changes, pDraw);
 
-    if(changes & infoRec->PolyGlyphBltMask)
-	(*infoRec->ValidatePolyGlyphBlt)(pGC, changes, pDraw);
+    if (changes & infoRec->PolyFillArcMask)
+        (*infoRec->ValidatePolyFillArc) (pGC, changes, pDraw);
 
-    if(changes & infoRec->ImageGlyphBltMask)
-	(*infoRec->ValidateImageGlyphBlt)(pGC, changes, pDraw);
+    if (changes & infoRec->PolyGlyphBltMask)
+        (*infoRec->ValidatePolyGlyphBlt) (pGC, changes, pDraw);
 
-    if(changes & infoRec->PolyText8Mask)
-	(*infoRec->ValidatePolyText8)(pGC, changes, pDraw);
-    
-    if(changes & infoRec->PolyText16Mask)
-	(*infoRec->ValidatePolyText16)(pGC, changes, pDraw);
+    if (changes & infoRec->ImageGlyphBltMask)
+        (*infoRec->ValidateImageGlyphBlt) (pGC, changes, pDraw);
 
-    if(changes & infoRec->ImageText8Mask)
-	(*infoRec->ValidateImageText8)(pGC, changes, pDraw);
-    
-    if(changes & infoRec->ImageText16Mask)
-	(*infoRec->ValidateImageText16)(pGC, changes, pDraw);
- 
-    if(changes & infoRec->PushPixelsMask) 
-	(*infoRec->ValidatePushPixels)(pGC, changes, pDraw); 	
-}
+    if (changes & infoRec->PolyText8Mask)
+        (*infoRec->ValidatePolyText8) (pGC, changes, pDraw);
 
+    if (changes & infoRec->PolyText16Mask)
+        (*infoRec->ValidatePolyText16) (pGC, changes, pDraw);
+
+    if (changes & infoRec->ImageText8Mask)
+        (*infoRec->ValidateImageText8) (pGC, changes, pDraw);
+
+    if (changes & infoRec->ImageText16Mask)
+        (*infoRec->ValidateImageText16) (pGC, changes, pDraw);
+
+    if (changes & infoRec->PushPixelsMask)
+        (*infoRec->ValidatePushPixels) (pGC, changes, pDraw);
+}
 
 static void
 XAADestroyGC(GCPtr pGC)
 {
-    XAA_GC_FUNC_PROLOGUE (pGC);
-     
-    if(pGCPriv->XAAOps != &XAAFallbackOps)
-	free(pGCPriv->XAAOps);
+    XAA_GC_FUNC_PROLOGUE(pGC);
+
+    if (pGCPriv->XAAOps != &XAAFallbackOps)
+        free(pGCPriv->XAAOps);
 
     free(pGCPriv->DashPattern);
     pGCPriv->flags = 0;
 
-    (*pGC->funcs->DestroyGC)(pGC);
-    XAA_GC_FUNC_EPILOGUE (pGC);
+    (*pGC->funcs->DestroyGC) (pGC);
+    XAA_GC_FUNC_EPILOGUE(pGC);
 }
 
 static void
-XAAChangeGC (
-    GCPtr	    pGC,
-    unsigned long   mask
-)
+XAAChangeGC(GCPtr pGC, unsigned long mask)
 {
-    XAA_GC_FUNC_PROLOGUE (pGC);
+    XAA_GC_FUNC_PROLOGUE(pGC);
     (*pGC->funcs->ChangeGC) (pGC, mask);
-    XAA_GC_FUNC_EPILOGUE (pGC);
+    XAA_GC_FUNC_EPILOGUE(pGC);
 
-   /* we have to assume that shared memory pixmaps are dirty 
-      because we can't wrap all operations on them */
+    /* we have to assume that shared memory pixmaps are dirty 
+       because we can't wrap all operations on them */
 
-    if((mask & GCTile) && !pGC->tileIsPixel &&
-	PIXMAP_IS_SHARED(pGC->tile.pixmap))
-    {
-	XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-	pPixPriv->flags |= DIRTY;
+    if ((mask & GCTile) && !pGC->tileIsPixel &&
+        PIXMAP_IS_SHARED(pGC->tile.pixmap)) {
+        XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
+
+        pPixPriv->flags |= DIRTY;
     }
 
-    if((mask & GCStipple) && PIXMAP_IS_SHARED(pGC->stipple)){
-	XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-	pPixPriv->flags |= DIRTY;
+    if ((mask & GCStipple) && PIXMAP_IS_SHARED(pGC->stipple)) {
+        XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
+
+        pPixPriv->flags |= DIRTY;
     }
 }
 
 static void
-XAACopyGC (
-    GCPtr	    pGCSrc, 
-    unsigned long   mask,
-    GCPtr	    pGCDst)
+XAACopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst)
 {
-    XAA_GC_FUNC_PROLOGUE (pGCDst);
+    XAA_GC_FUNC_PROLOGUE(pGCDst);
     (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
-    XAA_GC_FUNC_EPILOGUE (pGCDst);
+    XAA_GC_FUNC_EPILOGUE(pGCDst);
 }
+
 static void
-XAAChangeClip (
-    GCPtr   pGC,
-    int		type,
-    pointer	pvalue,
-    int		nrects )
+XAAChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects)
 {
-    XAA_GC_FUNC_PROLOGUE (pGC);
+    XAA_GC_FUNC_PROLOGUE(pGC);
     (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
-    XAA_GC_FUNC_EPILOGUE (pGC);
+    XAA_GC_FUNC_EPILOGUE(pGC);
 }
 
 static void
 XAACopyClip(GCPtr pgcDst, GCPtr pgcSrc)
 {
-    XAA_GC_FUNC_PROLOGUE (pgcDst);
-    (* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc);
-    XAA_GC_FUNC_EPILOGUE (pgcDst);
+    XAA_GC_FUNC_PROLOGUE(pgcDst);
+    (*pgcDst->funcs->CopyClip) (pgcDst, pgcSrc);
+    XAA_GC_FUNC_EPILOGUE(pgcDst);
 }
 
 static void
 XAADestroyClip(GCPtr pGC)
 {
-    XAA_GC_FUNC_PROLOGUE (pGC);
-    (* pGC->funcs->DestroyClip)(pGC);
-    XAA_GC_FUNC_EPILOGUE (pGC);
+    XAA_GC_FUNC_PROLOGUE(pGC);
+    (*pGC->funcs->DestroyClip) (pGC);
+    XAA_GC_FUNC_EPILOGUE(pGC);
 }
- 
-/**** Pixmap Wrappers ****/
-
 
+/**** Pixmap Wrappers ****/
 
 static void
-XAAFillSpansPixmap(
-    DrawablePtr pDraw,
-    GC		*pGC,
-    int		nInit,	
-    DDXPointPtr pptInit,	
-    int *pwidthInit,		
-    int fSorted 
-){
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);    
-    (*pGC->ops->FillSpans)(pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
+XAAFillSpansPixmap(DrawablePtr pDraw,
+                   GC * pGC,
+                   int nInit, DDXPointPtr pptInit, int *pwidthInit, int fSorted)
+{
+    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->FillSpans) (pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
 static void
-XAASetSpansPixmap(
-    DrawablePtr		pDraw,
-    GCPtr		pGC,
-    char		*pcharsrc,
-    register DDXPointPtr ppt,
-    int			*pwidth,
-    int			nspans,
-    int			fSorted 
-){
+XAASetSpansPixmap(DrawablePtr pDraw,
+                  GCPtr pGC,
+                  char *pcharsrc,
+                  register DDXPointPtr ppt,
+                  int *pwidth, int nspans, int fSorted)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted);
+    (*pGC->ops->SetSpans) (pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
 static void
-XAAPutImagePixmap(
-    DrawablePtr pDraw,
-    GCPtr	pGC,
-    int		depth, 
-    int x, int y, int w, int h,
-    int		leftPad,
-    int		format,
-    char 	*pImage 
-){
+XAAPutImagePixmap(DrawablePtr pDraw,
+                  GCPtr pGC,
+                  int depth,
+                  int x, int y, int w, int h,
+                  int leftPad, int format, char *pImage)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PutImage)(pDraw, pGC, depth, x, y, w, h, 
-		leftPad, format, pImage);
+    (*pGC->ops->PutImage) (pDraw, pGC, depth, x, y, w, h,
+                           leftPad, format, pImage);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
 static RegionPtr
-XAACopyAreaPixmap(
-    DrawablePtr pSrc,
-    DrawablePtr pDst,
-    GC *pGC,
-    int srcx, int srcy,
-    int width, int height,
-    int dstx, int dsty 
-){
+XAACopyAreaPixmap(DrawablePtr pSrc,
+                  DrawablePtr pDst,
+                  GC * pGC,
+                  int srcx, int srcy, int width, int height, int dstx, int dsty)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
     RegionPtr ret;
 
-    if(infoRec->pScrn->vtSema && 
-	((pSrc->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pSrc))) 
-    {
-	if(infoRec->ReadPixmap && (pGC->alu == GXcopy) &&
-           (pSrc->bitsPerPixel == pDst->bitsPerPixel) &&
-          ((pGC->planemask & infoRec->FullPlanemasks[pSrc->depth - 1])
-              == infoRec->FullPlanemasks[pSrc->depth - 1]))
-        {
-            XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE((PixmapPtr)(pDst));
-	    pixPriv->flags |= DIRTY; 
-
-            return (XAABitBlt( pSrc, pDst, pGC,
-                srcx, srcy, width, height, dstx, dsty,
-                XAADoImageRead, 0L));
-        } else
-	if(infoRec->NeedToSync) {
-	   (*infoRec->Sync)(infoRec->pScrn);
-	    infoRec->NeedToSync = FALSE;
-	}
-    }    
+    if (infoRec->pScrn->vtSema &&
+        ((pSrc->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pSrc))) {
+        if (infoRec->ReadPixmap && (pGC->alu == GXcopy) &&
+            (pSrc->bitsPerPixel == pDst->bitsPerPixel) &&
+            ((pGC->planemask & infoRec->FullPlanemasks[pSrc->depth - 1])
+             == infoRec->FullPlanemasks[pSrc->depth - 1])) {
+            XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE((PixmapPtr) (pDst));
+
+            pixPriv->flags |= DIRTY;
+
+            return (XAABitBlt(pSrc, pDst, pGC,
+                              srcx, srcy, width, height, dstx, dsty,
+                              XAADoImageRead, 0L));
+        }
+        else if (infoRec->NeedToSync) {
+            (*infoRec->Sync) (infoRec->pScrn);
+            infoRec->NeedToSync = FALSE;
+        }
+    }
 
     {
-	XAA_PIXMAP_OP_PROLOGUE(pGC, pDst);
-	ret = (*pGC->ops->CopyArea)(pSrc, pDst,
-            pGC, srcx, srcy, width, height, dstx, dsty);
-	XAA_PIXMAP_OP_EPILOGUE(pGC);
+        XAA_PIXMAP_OP_PROLOGUE(pGC, pDst);
+        ret = (*pGC->ops->CopyArea) (pSrc, pDst,
+                                     pGC, srcx, srcy, width, height, dstx,
+                                     dsty);
+        XAA_PIXMAP_OP_EPILOGUE(pGC);
     }
     return ret;
 }
 
 static RegionPtr
-XAACopyPlanePixmap(
-    DrawablePtr	pSrc,
-    DrawablePtr	pDst,
-    GCPtr pGC,
-    int	srcx, int srcy,
-    int	width, int height,
-    int	dstx, int dsty,
-    unsigned long bitPlane 
-){
+XAACopyPlanePixmap(DrawablePtr pSrc,
+                   DrawablePtr pDst,
+                   GCPtr pGC,
+                   int srcx, int srcy,
+                   int width, int height,
+                   int dstx, int dsty, unsigned long bitPlane)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
     RegionPtr ret;
 
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDst);
 
-    if(infoRec->pScrn->vtSema && 
-	((pSrc->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pSrc))){
-	if(infoRec->NeedToSync) {
-	   (*infoRec->Sync)(infoRec->pScrn);
-	    infoRec->NeedToSync = FALSE;
-	}
-    }    
+    if (infoRec->pScrn->vtSema &&
+        ((pSrc->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pSrc))) {
+        if (infoRec->NeedToSync) {
+            (*infoRec->Sync) (infoRec->pScrn);
+            infoRec->NeedToSync = FALSE;
+        }
+    }
 
-    ret = (*pGC->ops->CopyPlane)(pSrc, pDst,
-	       pGC, srcx, srcy, width, height, dstx, dsty, bitPlane);
+    ret = (*pGC->ops->CopyPlane) (pSrc, pDst,
+                                  pGC, srcx, srcy, width, height, dstx, dsty,
+                                  bitPlane);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
     return ret;
 }
 
 static void
-XAAPolyPointPixmap(
-    DrawablePtr pDraw,
-    GCPtr pGC,
-    int mode,
-    int npt,
-    xPoint *pptInit 
-){
+XAAPolyPointPixmap(DrawablePtr pDraw,
+                   GCPtr pGC, int mode, int npt, xPoint * pptInit)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyPoint)(pDraw, pGC, mode, npt, pptInit);
+    (*pGC->ops->PolyPoint) (pDraw, pGC, mode, npt, pptInit);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
-
 static void
-XAAPolylinesPixmap(
-    DrawablePtr pDraw,
-    GCPtr	pGC,
-    int		mode,		
-    int		npt,		
-    DDXPointPtr pptInit 
-){
+XAAPolylinesPixmap(DrawablePtr pDraw,
+                   GCPtr pGC, int mode, int npt, DDXPointPtr pptInit)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);
+    (*pGC->ops->Polylines) (pDraw, pGC, mode, npt, pptInit);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
-static void 
-XAAPolySegmentPixmap(
-    DrawablePtr	pDraw,
-    GCPtr	pGC,
-    int		nseg,
-    xSegment	*pSeg 
-){
+static void
+XAAPolySegmentPixmap(DrawablePtr pDraw, GCPtr pGC, int nseg, xSegment * pSeg)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolySegment)(pDraw, pGC, nseg, pSeg);
+    (*pGC->ops->PolySegment) (pDraw, pGC, nseg, pSeg);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
 static void
-XAAPolyRectanglePixmap(
-    DrawablePtr  pDraw,
-    GCPtr        pGC,
-    int	         nRectsInit,
-    xRectangle  *pRectsInit 
-){
+XAAPolyRectanglePixmap(DrawablePtr pDraw,
+                       GCPtr pGC, int nRectsInit, xRectangle *pRectsInit)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyRectangle)(pDraw, pGC, nRectsInit, pRectsInit);
+    (*pGC->ops->PolyRectangle) (pDraw, pGC, nRectsInit, pRectsInit);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
 static void
-XAAPolyArcPixmap(
-    DrawablePtr	pDraw,
-    GCPtr	pGC,
-    int		narcs,
-    xArc	*parcs 
-){
+XAAPolyArcPixmap(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyArc)(pDraw, pGC, narcs, parcs);
+    (*pGC->ops->PolyArc) (pDraw, pGC, narcs, parcs);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
 static void
-XAAFillPolygonPixmap(
-    DrawablePtr	pDraw,
-    GCPtr	pGC,
-    int		shape,
-    int		mode,
-    int		count,
-    DDXPointPtr	ptsIn 
-){
+XAAFillPolygonPixmap(DrawablePtr pDraw,
+                     GCPtr pGC,
+                     int shape, int mode, int count, DDXPointPtr ptsIn)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->FillPolygon)(pDraw, pGC, shape, mode, count, ptsIn);
+    (*pGC->ops->FillPolygon) (pDraw, pGC, shape, mode, count, ptsIn);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
-
-static void 
-XAAPolyFillRectPixmap(
-    DrawablePtr	pDraw,
-    GCPtr	pGC,
-    int		nrectFill, 
-    xRectangle	*prectInit 
-){
+static void
+XAAPolyFillRectPixmap(DrawablePtr pDraw,
+                      GCPtr pGC, int nrectFill, xRectangle *prectInit)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyFillRect)(pDraw, pGC, nrectFill, prectInit);
+    (*pGC->ops->PolyFillRect) (pDraw, pGC, nrectFill, prectInit);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
-
 static void
-XAAPolyFillArcPixmap(
-    DrawablePtr	pDraw,
-    GCPtr	pGC,
-    int		narcs,
-    xArc	*parcs 
-){
+XAAPolyFillArcPixmap(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyFillArc)(pDraw, pGC, narcs, parcs);
+    (*pGC->ops->PolyFillArc) (pDraw, pGC, narcs, parcs);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
 static int
-XAAPolyText8Pixmap(
-    DrawablePtr pDraw,
-    GCPtr	pGC,
-    int		x, 
-    int 	y,
-    int 	count,
-    char	*chars 
-){
+XAAPolyText8Pixmap(DrawablePtr pDraw,
+                   GCPtr pGC, int x, int y, int count, char *chars)
+{
     int ret;
 
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    ret = (*pGC->ops->PolyText8)(pDraw, pGC, x, y, count, chars);
+    ret = (*pGC->ops->PolyText8) (pDraw, pGC, x, y, count, chars);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
     return ret;
 }
 
 static int
-XAAPolyText16Pixmap(
-    DrawablePtr pDraw,
-    GCPtr	pGC,
-    int		x,
-    int		y,
-    int 	count,
-    unsigned short *chars 
-){
+XAAPolyText16Pixmap(DrawablePtr pDraw,
+                    GCPtr pGC, int x, int y, int count, unsigned short *chars)
+{
     int ret;
 
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    ret = (*pGC->ops->PolyText16)(pDraw, pGC, x, y, count, chars);
+    ret = (*pGC->ops->PolyText16) (pDraw, pGC, x, y, count, chars);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
     return ret;
 }
 
 static void
-XAAImageText8Pixmap(
-    DrawablePtr pDraw,
-    GCPtr	pGC,
-    int		x, 
-    int		y,
-    int 	count,
-    char	*chars 
-){
+XAAImageText8Pixmap(DrawablePtr pDraw,
+                    GCPtr pGC, int x, int y, int count, char *chars)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->ImageText8)(pDraw, pGC, x, y, count, chars);
+    (*pGC->ops->ImageText8) (pDraw, pGC, x, y, count, chars);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
+
 static void
-XAAImageText16Pixmap(
-    DrawablePtr pDraw,
-    GCPtr	pGC,
-    int		x,
-    int		y,
-    int 	count,
-    unsigned short *chars 
-){
+XAAImageText16Pixmap(DrawablePtr pDraw,
+                     GCPtr pGC, int x, int y, int count, unsigned short *chars)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->ImageText16)(pDraw, pGC, x, y, count, chars);
+    (*pGC->ops->ImageText16) (pDraw, pGC, x, y, count, chars);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
-
 static void
-XAAImageGlyphBltPixmap(
-    DrawablePtr pDraw,
-    GCPtr pGC,
-    int xInit, int yInit,
-    unsigned int nglyph,
-    CharInfoPtr *ppci,
-    pointer pglyphBase 
-){
+XAAImageGlyphBltPixmap(DrawablePtr pDraw,
+                       GCPtr pGC,
+                       int xInit, int yInit,
+                       unsigned int nglyph,
+                       CharInfoPtr * ppci, pointer pglyphBase)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->ImageGlyphBlt)(pDraw, pGC, xInit, yInit, nglyph, 
-					ppci, pglyphBase);
+    (*pGC->ops->ImageGlyphBlt) (pDraw, pGC, xInit, yInit, nglyph,
+                                ppci, pglyphBase);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
 static void
-XAAPolyGlyphBltPixmap(
-    DrawablePtr pDraw,
-    GCPtr pGC,
-    int xInit, int yInit,
-    unsigned int nglyph,
-    CharInfoPtr *ppci,
-    pointer pglyphBase 
-){
+XAAPolyGlyphBltPixmap(DrawablePtr pDraw,
+                      GCPtr pGC,
+                      int xInit, int yInit,
+                      unsigned int nglyph,
+                      CharInfoPtr * ppci, pointer pglyphBase)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyGlyphBlt)(pDraw, pGC, xInit, yInit, nglyph, 
-				ppci, pglyphBase);
+    (*pGC->ops->PolyGlyphBlt) (pDraw, pGC, xInit, yInit, nglyph,
+                               ppci, pglyphBase);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
 static void
-XAAPushPixelsPixmap(
-    GCPtr	pGC,
-    PixmapPtr	pBitMap,
-    DrawablePtr pDraw,
-    int	dx, int dy, int xOrg, int yOrg 
-){
+XAAPushPixelsPixmap(GCPtr pGC,
+                    PixmapPtr pBitMap,
+                    DrawablePtr pDraw, int dx, int dy, int xOrg, int yOrg)
+{
     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PushPixels)(pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
+    (*pGC->ops->PushPixels) (pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
     XAA_PIXMAP_OP_EPILOGUE(pGC);
 }
 
 GCOps XAAPixmapOps = {
-    XAAFillSpansPixmap, XAASetSpansPixmap, 
-    XAAPutImagePixmap, XAACopyAreaPixmap, 
-    XAACopyPlanePixmap, XAAPolyPointPixmap, 
-    XAAPolylinesPixmap, XAAPolySegmentPixmap, 
-    XAAPolyRectanglePixmap, XAAPolyArcPixmap, 
-    XAAFillPolygonPixmap, XAAPolyFillRectPixmap, 
-    XAAPolyFillArcPixmap, XAAPolyText8Pixmap, 
-    XAAPolyText16Pixmap, XAAImageText8Pixmap, 
-    XAAImageText16Pixmap, XAAImageGlyphBltPixmap, 
+    XAAFillSpansPixmap, XAASetSpansPixmap,
+    XAAPutImagePixmap, XAACopyAreaPixmap,
+    XAACopyPlanePixmap, XAAPolyPointPixmap,
+    XAAPolylinesPixmap, XAAPolySegmentPixmap,
+    XAAPolyRectanglePixmap, XAAPolyArcPixmap,
+    XAAFillPolygonPixmap, XAAPolyFillRectPixmap,
+    XAAPolyFillArcPixmap, XAAPolyText8Pixmap,
+    XAAPolyText16Pixmap, XAAImageText8Pixmap,
+    XAAImageText16Pixmap, XAAImageGlyphBltPixmap,
     XAAPolyGlyphBltPixmap, XAAPushPixelsPixmap,
 };