diff options
Diffstat (limited to 'miext/damage')
| -rw-r--r-- | miext/damage/damage.c | 2479 | ||||
| -rw-r--r-- | miext/damage/damage.h | 85 | ||||
| -rw-r--r-- | miext/damage/damagestr.h | 72 |
3 files changed, 1265 insertions, 1371 deletions
diff --git a/miext/damage/damage.c b/miext/damage/damage.c index d79121165..72ed65997 100644 --- a/miext/damage/damage.c +++ b/miext/damage/damage.c @@ -71,41 +71,43 @@ #define pixmapDamage(pPixmap) damagePixPriv(pPixmap) static DevPrivateKeyRec damageScrPrivateKeyRec; + #define damageScrPrivateKey (&damageScrPrivateKeyRec) static DevPrivateKeyRec damagePixPrivateKeyRec; + #define damagePixPrivateKey (&damagePixPrivateKeyRec) static DevPrivateKeyRec damageGCPrivateKeyRec; + #define damageGCPrivateKey (&damageGCPrivateKeyRec) static DevPrivateKeyRec damageWinPrivateKeyRec; + #define damageWinPrivateKey (&damageWinPrivateKeyRec) static DamagePtr * -getDrawableDamageRef (DrawablePtr pDrawable) +getDrawableDamageRef(DrawablePtr pDrawable) { - PixmapPtr pPixmap; - - if (WindowDrawable(pDrawable->type)) - { - ScreenPtr pScreen = pDrawable->pScreen; + PixmapPtr pPixmap; - pPixmap = 0; - if (pScreen->GetWindowPixmap + if (WindowDrawable(pDrawable->type)) { + ScreenPtr pScreen = pDrawable->pScreen; + + pPixmap = 0; + if (pScreen->GetWindowPixmap #ifdef ROOTLESS_WORKAROUND - && ((WindowPtr)pDrawable)->viewable + && ((WindowPtr) pDrawable)->viewable #endif - ) - pPixmap = (*pScreen->GetWindowPixmap) ((WindowPtr)pDrawable); + ) + pPixmap = (*pScreen->GetWindowPixmap) ((WindowPtr) pDrawable); - if (!pPixmap) - { - damageScrPriv(pScreen); + if (!pPixmap) { + damageScrPriv(pScreen); - return &pScrPriv->pScreenDamage; - } + return &pScrPriv->pScreenDamage; + } } else - pPixmap = (PixmapPtr) pDrawable; - return getPixmapDamageRef (pPixmap); + pPixmap = (PixmapPtr) pDrawable; + return getPixmapDamageRef(pPixmap); } #define getDrawableDamage(pDrawable) (*getDrawableDamageRef (pDrawable)) @@ -121,7 +123,8 @@ getDrawableDamageRef (DrawablePtr pDrawable) dixLookupPrivateAddr(&(pWindow)->devPrivates, damageWinPrivateKey) static void -damageReportDamagePostRendering (DamagePtr pDamage, RegionPtr pOldDamage, RegionPtr pDamageRegion) +damageReportDamagePostRendering(DamagePtr pDamage, RegionPtr pOldDamage, + RegionPtr pDamageRegion) { BoxRec tmpBox; RegionRec tmpRegion, newDamage; @@ -131,32 +134,34 @@ damageReportDamagePostRendering (DamagePtr pDamage, RegionPtr pOldDamage, Region switch (pDamage->damageLevel) { case DamageReportRawRegion: - (*pDamage->damageReportPostRendering) (pDamage, pDamageRegion, pDamage->closure); - break; + (*pDamage->damageReportPostRendering) (pDamage, pDamageRegion, + pDamage->closure); + break; case DamageReportDeltaRegion: - RegionNull(&tmpRegion); - RegionSubtract(&tmpRegion, pDamageRegion, pOldDamage); - if (RegionNotEmpty(&tmpRegion)) { - (*pDamage->damageReportPostRendering) (pDamage, &tmpRegion, pDamage->closure); - } - RegionUninit(&tmpRegion); - break; + RegionNull(&tmpRegion); + RegionSubtract(&tmpRegion, pDamageRegion, pOldDamage); + if (RegionNotEmpty(&tmpRegion)) { + (*pDamage->damageReportPostRendering) (pDamage, &tmpRegion, + pDamage->closure); + } + RegionUninit(&tmpRegion); + break; case DamageReportBoundingBox: - tmpBox = *RegionExtents(pOldDamage); - if (!BOX_SAME (&tmpBox, RegionExtents(&newDamage))) { - (*pDamage->damageReportPostRendering) (pDamage, &newDamage, - pDamage->closure); - } - break; + tmpBox = *RegionExtents(pOldDamage); + if (!BOX_SAME(&tmpBox, RegionExtents(&newDamage))) { + (*pDamage->damageReportPostRendering) (pDamage, &newDamage, + pDamage->closure); + } + break; case DamageReportNonEmpty: - was_empty = !RegionNotEmpty(pOldDamage); - if (was_empty && RegionNotEmpty(&newDamage)) { - (*pDamage->damageReportPostRendering) (pDamage, &newDamage, - pDamage->closure); - } - break; + was_empty = !RegionNotEmpty(pOldDamage); + if (was_empty && RegionNotEmpty(&newDamage)) { + (*pDamage->damageReportPostRendering) (pDamage, &newDamage, + pDamage->closure); + } + break; case DamageReportNone: - break; + break; } RegionUninit(&newDamage); @@ -164,217 +169,215 @@ damageReportDamagePostRendering (DamagePtr pDamage, RegionPtr pOldDamage, Region #if DAMAGE_DEBUG_ENABLE static void -_damageRegionAppend (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip, int subWindowMode, const char *where) +_damageRegionAppend(DrawablePtr pDrawable, RegionPtr pRegion, Bool clip, + int subWindowMode, const char *where) #define damageRegionAppend(d,r,c,m) _damageRegionAppend(d,r,c,m,__FUNCTION__) #else static void -damageRegionAppend (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip, - int subWindowMode) +damageRegionAppend(DrawablePtr pDrawable, RegionPtr pRegion, Bool clip, + int subWindowMode) #endif { - ScreenPtr pScreen = pDrawable->pScreen; + ScreenPtr pScreen = pDrawable->pScreen; + damageScrPriv(pScreen); drawableDamage(pDrawable); - DamagePtr pNext; - RegionRec clippedRec; - RegionPtr pDamageRegion; - RegionRec pixClip; - int draw_x, draw_y; + DamagePtr pNext; + RegionRec clippedRec; + RegionPtr pDamageRegion; + RegionRec pixClip; + int draw_x, draw_y; + #ifdef COMPOSITE - int screen_x = 0, screen_y = 0; + int screen_x = 0, screen_y = 0; #endif /* short circuit for empty regions */ if (!RegionNotEmpty(pRegion)) - return; - + return; + #ifdef COMPOSITE /* * When drawing to a pixmap which is storing window contents, * the region presented is in pixmap relative coordinates which * need to be converted to screen relative coordinates */ - if (pDrawable->type != DRAWABLE_WINDOW) - { - screen_x = ((PixmapPtr) pDrawable)->screen_x - pDrawable->x; - screen_y = ((PixmapPtr) pDrawable)->screen_y - pDrawable->y; + if (pDrawable->type != DRAWABLE_WINDOW) { + screen_x = ((PixmapPtr) pDrawable)->screen_x - pDrawable->x; + screen_y = ((PixmapPtr) pDrawable)->screen_y - pDrawable->y; } if (screen_x || screen_y) RegionTranslate(pRegion, screen_x, screen_y); #endif - + if (pDrawable->type == DRAWABLE_WINDOW && - ((WindowPtr)(pDrawable))->backingStore == NotUseful) - { - if (subWindowMode == ClipByChildren) - { - RegionIntersect(pRegion, pRegion, - &((WindowPtr)(pDrawable))->clipList); - } - else if (subWindowMode == IncludeInferiors) - { - RegionPtr pTempRegion = - NotClippedByChildren((WindowPtr)(pDrawable)); - RegionIntersect(pRegion, pRegion, pTempRegion); - RegionDestroy(pTempRegion); - } - /* If subWindowMode is set to an invalid value, don't perform - * any drawable-based clipping. */ + ((WindowPtr) (pDrawable))->backingStore == NotUseful) { + if (subWindowMode == ClipByChildren) { + RegionIntersect(pRegion, pRegion, + &((WindowPtr) (pDrawable))->clipList); + } + else if (subWindowMode == IncludeInferiors) { + RegionPtr pTempRegion = + NotClippedByChildren((WindowPtr) (pDrawable)); + RegionIntersect(pRegion, pRegion, pTempRegion); + RegionDestroy(pTempRegion); + } + /* If subWindowMode is set to an invalid value, don't perform + * any drawable-based clipping. */ } - RegionNull(&clippedRec); - for (; pDamage; pDamage = pNext) - { - pNext = pDamage->pNext; - /* - * Check for internal damage and don't send events - */ - if (pScrPriv->internalLevel > 0 && !pDamage->isInternal) - { - DAMAGE_DEBUG (("non internal damage, skipping at %d\n", - pScrPriv->internalLevel)); - continue; - } - /* - * Check for unrealized windows - */ - if (pDamage->pDrawable->type == DRAWABLE_WINDOW && - !((WindowPtr) (pDamage->pDrawable))->realized) - { - continue; - } - - draw_x = pDamage->pDrawable->x; - draw_y = pDamage->pDrawable->y; + for (; pDamage; pDamage = pNext) { + pNext = pDamage->pNext; + /* + * Check for internal damage and don't send events + */ + if (pScrPriv->internalLevel > 0 && !pDamage->isInternal) { + DAMAGE_DEBUG(("non internal damage, skipping at %d\n", + pScrPriv->internalLevel)); + continue; + } + /* + * Check for unrealized windows + */ + if (pDamage->pDrawable->type == DRAWABLE_WINDOW && + !((WindowPtr) (pDamage->pDrawable))->realized) { + continue; + } + + draw_x = pDamage->pDrawable->x; + draw_y = pDamage->pDrawable->y; #ifdef COMPOSITE - /* - * Need to move everyone to screen coordinates - * XXX what about off-screen pixmaps with non-zero x/y? - */ - if (!WindowDrawable(pDamage->pDrawable->type)) - { - draw_x += ((PixmapPtr) pDamage->pDrawable)->screen_x; - draw_y += ((PixmapPtr) pDamage->pDrawable)->screen_y; - } + /* + * Need to move everyone to screen coordinates + * XXX what about off-screen pixmaps with non-zero x/y? + */ + if (!WindowDrawable(pDamage->pDrawable->type)) { + draw_x += ((PixmapPtr) pDamage->pDrawable)->screen_x; + draw_y += ((PixmapPtr) pDamage->pDrawable)->screen_y; + } #endif - - /* - * Clip against border or pixmap bounds - */ - - pDamageRegion = pRegion; - if (clip || pDamage->pDrawable != pDrawable) - { - pDamageRegion = &clippedRec; - if (pDamage->pDrawable->type == DRAWABLE_WINDOW) { - RegionIntersect(pDamageRegion, pRegion, - &((WindowPtr)(pDamage->pDrawable))->borderClip); - } else { - BoxRec box; - box.x1 = draw_x; - box.y1 = draw_y; - box.x2 = draw_x + pDamage->pDrawable->width; - box.y2 = draw_y + pDamage->pDrawable->height; - RegionInit(&pixClip, &box, 1); - RegionIntersect(pDamageRegion, pRegion, &pixClip); - RegionUninit(&pixClip); - } - /* - * Short circuit empty results - */ - if (!RegionNotEmpty(pDamageRegion)) - continue; - } - - DAMAGE_DEBUG (("%s %d x %d +%d +%d (target 0x%lx monitor 0x%lx)\n", - where, - pDamageRegion->extents.x2 - pDamageRegion->extents.x1, - pDamageRegion->extents.y2 - pDamageRegion->extents.y1, - pDamageRegion->extents.x1, pDamageRegion->extents.y1, - pDrawable->id, pDamage->pDrawable->id)); - - /* - * Move region to target coordinate space - */ - if (draw_x || draw_y) - RegionTranslate(pDamageRegion, -draw_x, -draw_y); - - /* Store damage region if needed after submission. */ - if (pDamage->reportAfter || pDamage->damageMarker) - RegionUnion(&pDamage->pendingDamage, - &pDamage->pendingDamage, pDamageRegion); - - /* Duplicate current damage if needed. */ - if (pDamage->damageMarker) - RegionCopy(&pDamage->backupDamage, &pDamage->damage); - - /* Report damage now, if desired. */ - if (!pDamage->reportAfter) { - if (pDamage->damageReport) - DamageReportDamage (pDamage, pDamageRegion); - else - RegionUnion(&pDamage->damage, - &pDamage->damage, pDamageRegion); - } - - /* - * translate original region back - */ - if (pDamageRegion == pRegion && (draw_x || draw_y)) - RegionTranslate(pDamageRegion, draw_x, draw_y); + + /* + * Clip against border or pixmap bounds + */ + + pDamageRegion = pRegion; + if (clip || pDamage->pDrawable != pDrawable) { + pDamageRegion = &clippedRec; + if (pDamage->pDrawable->type == DRAWABLE_WINDOW) { + RegionIntersect(pDamageRegion, pRegion, + &((WindowPtr) (pDamage->pDrawable))-> + borderClip); + } + else { + BoxRec box; + + box.x1 = draw_x; + box.y1 = draw_y; + box.x2 = draw_x + pDamage->pDrawable->width; + box.y2 = draw_y + pDamage->pDrawable->height; + RegionInit(&pixClip, &box, 1); + RegionIntersect(pDamageRegion, pRegion, &pixClip); + RegionUninit(&pixClip); + } + /* + * Short circuit empty results + */ + if (!RegionNotEmpty(pDamageRegion)) + continue; + } + + DAMAGE_DEBUG(("%s %d x %d +%d +%d (target 0x%lx monitor 0x%lx)\n", + where, + pDamageRegion->extents.x2 - pDamageRegion->extents.x1, + pDamageRegion->extents.y2 - pDamageRegion->extents.y1, + pDamageRegion->extents.x1, pDamageRegion->extents.y1, + pDrawable->id, pDamage->pDrawable->id)); + + /* + * Move region to target coordinate space + */ + if (draw_x || draw_y) + RegionTranslate(pDamageRegion, -draw_x, -draw_y); + + /* Store damage region if needed after submission. */ + if (pDamage->reportAfter || pDamage->damageMarker) + RegionUnion(&pDamage->pendingDamage, + &pDamage->pendingDamage, pDamageRegion); + + /* Duplicate current damage if needed. */ + if (pDamage->damageMarker) + RegionCopy(&pDamage->backupDamage, &pDamage->damage); + + /* Report damage now, if desired. */ + if (!pDamage->reportAfter) { + if (pDamage->damageReport) + DamageReportDamage(pDamage, pDamageRegion); + else + RegionUnion(&pDamage->damage, &pDamage->damage, pDamageRegion); + } + + /* + * translate original region back + */ + if (pDamageRegion == pRegion && (draw_x || draw_y)) + RegionTranslate(pDamageRegion, draw_x, draw_y); } #ifdef COMPOSITE if (screen_x || screen_y) - RegionTranslate(pRegion, -screen_x, -screen_y); + RegionTranslate(pRegion, -screen_x, -screen_y); #endif - + RegionUninit(&clippedRec); } static void -damageRegionProcessPending (DrawablePtr pDrawable) +damageRegionProcessPending(DrawablePtr pDrawable) { drawableDamage(pDrawable); - for (; pDamage != NULL; pDamage = pDamage->pNext) - { - /* submit damage marker whenever possible. */ - if (pDamage->damageMarker) - (*pDamage->damageMarker) (pDrawable, pDamage, &pDamage->backupDamage, &pDamage->pendingDamage, pDamage->closure); - if (pDamage->reportAfter) { - /* It's possible that there is only interest in postRendering reporting. */ - if (pDamage->damageReport) - DamageReportDamage (pDamage, &pDamage->pendingDamage); - else - RegionUnion(&pDamage->damage, &pDamage->damage, - &pDamage->pendingDamage); - } - - if (pDamage->reportAfter || pDamage->damageMarker) - RegionEmpty(&pDamage->pendingDamage); - if (pDamage->damageMarker) - RegionEmpty(&pDamage->backupDamage); + for (; pDamage != NULL; pDamage = pDamage->pNext) { + /* submit damage marker whenever possible. */ + if (pDamage->damageMarker) + (*pDamage->damageMarker) (pDrawable, pDamage, + &pDamage->backupDamage, + &pDamage->pendingDamage, + pDamage->closure); + if (pDamage->reportAfter) { + /* It's possible that there is only interest in postRendering reporting. */ + if (pDamage->damageReport) + DamageReportDamage(pDamage, &pDamage->pendingDamage); + else + RegionUnion(&pDamage->damage, &pDamage->damage, + &pDamage->pendingDamage); + } + + if (pDamage->reportAfter || pDamage->damageMarker) + RegionEmpty(&pDamage->pendingDamage); + if (pDamage->damageMarker) + RegionEmpty(&pDamage->backupDamage); } - + } #if DAMAGE_DEBUG_ENABLE #define damageDamageBox(d,b,m) _damageDamageBox(d,b,m,__FUNCTION__) static void -_damageDamageBox (DrawablePtr pDrawable, BoxPtr pBox, int subWindowMode, const char *where) +_damageDamageBox(DrawablePtr pDrawable, BoxPtr pBox, int subWindowMode, + const char *where) #else static void -damageDamageBox (DrawablePtr pDrawable, BoxPtr pBox, int subWindowMode) +damageDamageBox(DrawablePtr pDrawable, BoxPtr pBox, int subWindowMode) #endif { - RegionRec region; + RegionRec region; RegionInit(®ion, pBox, 1); #if DAMAGE_DEBUG_ENABLE - _damageRegionAppend (pDrawable, ®ion, TRUE, subWindowMode, where); + _damageRegionAppend(pDrawable, ®ion, TRUE, subWindowMode, where); #else - damageRegionAppend (pDrawable, ®ion, TRUE, subWindowMode); + damageRegionAppend(pDrawable, ®ion, TRUE, subWindowMode); #endif RegionUninit(®ion); } @@ -398,17 +401,18 @@ static Bool damageCreateGC(GCPtr pGC) { ScreenPtr pScreen = pGC->pScreen; + damageScrPriv(pScreen); damageGCPriv(pGC); Bool ret; - unwrap (pScrPriv, pScreen, CreateGC); - if((ret = (*pScreen->CreateGC) (pGC))) { - pGCPriv->ops = NULL; - pGCPriv->funcs = pGC->funcs; - pGC->funcs = &damageGCFuncs; + unwrap(pScrPriv, pScreen, CreateGC); + if ((ret = (*pScreen->CreateGC) (pGC))) { + pGCPriv->ops = NULL; + pGCPriv->funcs = pGC->funcs; + pGC->funcs = &damageGCFuncs; } - wrap (pScrPriv, pScreen, CreateGC, damageCreateGC); + wrap(pScrPriv, pScreen, CreateGC, damageCreateGC); return ret; } @@ -433,68 +437,60 @@ damageCreateGC(GCPtr pGC) if (pGCPriv->ops) wrap(pGCPriv, pGC, ops, &damageGCOps) static void -damageValidateGC(GCPtr pGC, - unsigned long changes, - DrawablePtr pDrawable) +damageValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable) { - DAMAGE_GC_FUNC_PROLOGUE (pGC); - (*pGC->funcs->ValidateGC)(pGC, changes, pDrawable); - pGCPriv->ops = pGC->ops; /* just so it's not NULL */ - DAMAGE_GC_FUNC_EPILOGUE (pGC); + DAMAGE_GC_FUNC_PROLOGUE(pGC); + (*pGC->funcs->ValidateGC) (pGC, changes, pDrawable); + pGCPriv->ops = pGC->ops; /* just so it's not NULL */ + DAMAGE_GC_FUNC_EPILOGUE(pGC); } static void damageDestroyGC(GCPtr pGC) { - DAMAGE_GC_FUNC_PROLOGUE (pGC); - (*pGC->funcs->DestroyGC)(pGC); - DAMAGE_GC_FUNC_EPILOGUE (pGC); + DAMAGE_GC_FUNC_PROLOGUE(pGC); + (*pGC->funcs->DestroyGC) (pGC); + DAMAGE_GC_FUNC_EPILOGUE(pGC); } static void -damageChangeGC (GCPtr pGC, - unsigned long mask) +damageChangeGC(GCPtr pGC, unsigned long mask) { - DAMAGE_GC_FUNC_PROLOGUE (pGC); + DAMAGE_GC_FUNC_PROLOGUE(pGC); (*pGC->funcs->ChangeGC) (pGC, mask); - DAMAGE_GC_FUNC_EPILOGUE (pGC); + DAMAGE_GC_FUNC_EPILOGUE(pGC); } static void -damageCopyGC (GCPtr pGCSrc, - unsigned long mask, - GCPtr pGCDst) +damageCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst) { - DAMAGE_GC_FUNC_PROLOGUE (pGCDst); + DAMAGE_GC_FUNC_PROLOGUE(pGCDst); (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst); - DAMAGE_GC_FUNC_EPILOGUE (pGCDst); + DAMAGE_GC_FUNC_EPILOGUE(pGCDst); } static void -damageChangeClip (GCPtr pGC, - int type, - pointer pvalue, - int nrects) +damageChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects) { - DAMAGE_GC_FUNC_PROLOGUE (pGC); + DAMAGE_GC_FUNC_PROLOGUE(pGC); (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects); - DAMAGE_GC_FUNC_EPILOGUE (pGC); + DAMAGE_GC_FUNC_EPILOGUE(pGC); } static void damageCopyClip(GCPtr pgcDst, GCPtr pgcSrc) { - DAMAGE_GC_FUNC_PROLOGUE (pgcDst); - (* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc); - DAMAGE_GC_FUNC_EPILOGUE (pgcDst); + DAMAGE_GC_FUNC_PROLOGUE(pgcDst); + (*pgcDst->funcs->CopyClip) (pgcDst, pgcSrc); + DAMAGE_GC_FUNC_EPILOGUE(pgcDst); } static void damageDestroyClip(GCPtr pGC) { - DAMAGE_GC_FUNC_PROLOGUE (pGC); - (* pGC->funcs->DestroyClip)(pGC); - DAMAGE_GC_FUNC_EPILOGUE (pGC); + DAMAGE_GC_FUNC_PROLOGUE(pGC); + (*pGC->funcs->DestroyClip) (pGC); + DAMAGE_GC_FUNC_EPILOGUE(pGC); } #define TRIM_BOX(box, pGC) if (pGC->pCompositeClip) { \ @@ -531,825 +527,767 @@ damageDestroyClip(GCPtr pGC) if(box.y1 < extents->y1) box.y1 = extents->y1; \ if(box.y2 > extents->y2) box.y2 = extents->y2; \ } - + #define checkPictureDamage(p) (getDrawableDamage(p->pDrawable) && \ RegionNotEmpty(p->pCompositeClip)) static void -damageComposite (CARD8 op, - PicturePtr pSrc, - PicturePtr pMask, - PicturePtr pDst, - INT16 xSrc, - INT16 ySrc, - INT16 xMask, - INT16 yMask, - INT16 xDst, - INT16 yDst, - CARD16 width, - CARD16 height) -{ - ScreenPtr pScreen = pDst->pDrawable->pScreen; - PictureScreenPtr ps = GetPictureScreen(pScreen); +damageComposite(CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xMask, + INT16 yMask, + INT16 xDst, INT16 yDst, CARD16 width, CARD16 height) +{ + ScreenPtr pScreen = pDst->pDrawable->pScreen; + PictureScreenPtr ps = GetPictureScreen(pScreen); + damageScrPriv(pScreen); - if (checkPictureDamage (pDst)) - { - BoxRec box; - - box.x1 = xDst + pDst->pDrawable->x; - box.y1 = yDst + pDst->pDrawable->y; - box.x2 = box.x1 + width; - box.y2 = box.y1 + height; - TRIM_PICTURE_BOX(box, pDst); - if (BOX_NOT_EMPTY(box)) - damageDamageBox (pDst->pDrawable, &box, pDst->subWindowMode); + if (checkPictureDamage(pDst)) { + BoxRec box; + + box.x1 = xDst + pDst->pDrawable->x; + box.y1 = yDst + pDst->pDrawable->y; + box.x2 = box.x1 + width; + box.y2 = box.y1 + height; + TRIM_PICTURE_BOX(box, pDst); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDst->pDrawable, &box, pDst->subWindowMode); } - unwrap (pScrPriv, ps, Composite); + unwrap(pScrPriv, ps, Composite); (*ps->Composite) (op, - pSrc, - pMask, - pDst, - xSrc, - ySrc, - xMask, - yMask, - xDst, - yDst, - width, - height); - damageRegionProcessPending (pDst->pDrawable); - wrap (pScrPriv, ps, Composite, damageComposite); + pSrc, + pMask, + pDst, + xSrc, ySrc, xMask, yMask, xDst, yDst, width, height); + damageRegionProcessPending(pDst->pDrawable); + wrap(pScrPriv, ps, Composite, damageComposite); } static void -damageGlyphs (CARD8 op, - PicturePtr pSrc, - PicturePtr pDst, - PictFormatPtr maskFormat, - INT16 xSrc, - INT16 ySrc, - int nlist, - GlyphListPtr list, - GlyphPtr *glyphs) -{ - ScreenPtr pScreen = pDst->pDrawable->pScreen; - PictureScreenPtr ps = GetPictureScreen(pScreen); +damageGlyphs(CARD8 op, + PicturePtr pSrc, + PicturePtr pDst, + PictFormatPtr maskFormat, + INT16 xSrc, + INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs) +{ + ScreenPtr pScreen = pDst->pDrawable->pScreen; + PictureScreenPtr ps = GetPictureScreen(pScreen); + damageScrPriv(pScreen); - if (checkPictureDamage (pDst)) - { - int nlistTmp = nlist; - GlyphListPtr listTmp = list; - GlyphPtr *glyphsTmp = glyphs; - int x, y; - int n; - GlyphPtr glyph; - BoxRec box; - int x1, y1, x2, y2; - - box.x1 = 32767; - box.y1 = 32767; - box.x2 = -32767; - box.y2 = -32767; - x = pDst->pDrawable->x; - y = pDst->pDrawable->y; - while (nlistTmp--) - { - x += listTmp->xOff; - y += listTmp->yOff; - n = listTmp->len; - while (n--) - { - glyph = *glyphsTmp++; - x1 = x - glyph->info.x; - y1 = y - glyph->info.y; - x2 = x1 + glyph->info.width; - y2 = y1 + glyph->info.height; - if (x1 < box.x1) - box.x1 = x1; - if (y1 < box.y1) - box.y1 = y1; - if (x2 > box.x2) - box.x2 = x2; - if (y2 > box.y2) - box.y2 = y2; - x += glyph->info.xOff; - y += glyph->info.yOff; - } - listTmp++; - } - TRIM_PICTURE_BOX (box, pDst); - if (BOX_NOT_EMPTY(box)) - damageDamageBox (pDst->pDrawable, &box, pDst->subWindowMode); + if (checkPictureDamage(pDst)) { + int nlistTmp = nlist; + GlyphListPtr listTmp = list; + GlyphPtr *glyphsTmp = glyphs; + int x, y; + int n; + GlyphPtr glyph; + BoxRec box; + int x1, y1, x2, y2; + + box.x1 = 32767; + box.y1 = 32767; + box.x2 = -32767; + box.y2 = -32767; + x = pDst->pDrawable->x; + y = pDst->pDrawable->y; + while (nlistTmp--) { + x += listTmp->xOff; + y += listTmp->yOff; + n = listTmp->len; + while (n--) { + glyph = *glyphsTmp++; + x1 = x - glyph->info.x; + y1 = y - glyph->info.y; + x2 = x1 + glyph->info.width; + y2 = y1 + glyph->info.height; + if (x1 < box.x1) + box.x1 = x1; + if (y1 < box.y1) + box.y1 = y1; + if (x2 > box.x2) + box.x2 = x2; + if (y2 > box.y2) + box.y2 = y2; + x += glyph->info.xOff; + y += glyph->info.yOff; + } + listTmp++; + } + TRIM_PICTURE_BOX(box, pDst); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDst->pDrawable, &box, pDst->subWindowMode); } - unwrap (pScrPriv, ps, Glyphs); + unwrap(pScrPriv, ps, Glyphs); (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs); - damageRegionProcessPending (pDst->pDrawable); - wrap (pScrPriv, ps, Glyphs, damageGlyphs); + damageRegionProcessPending(pDst->pDrawable); + wrap(pScrPriv, ps, Glyphs, damageGlyphs); } static void -damageAddTraps (PicturePtr pPicture, - INT16 x_off, - INT16 y_off, - int ntrap, - xTrap *traps) -{ - ScreenPtr pScreen = pPicture->pDrawable->pScreen; - PictureScreenPtr ps = GetPictureScreen(pScreen); +damageAddTraps(PicturePtr pPicture, + INT16 x_off, INT16 y_off, int ntrap, xTrap * traps) +{ + ScreenPtr pScreen = pPicture->pDrawable->pScreen; + PictureScreenPtr ps = GetPictureScreen(pScreen); + damageScrPriv(pScreen); - if (checkPictureDamage (pPicture)) - { - BoxRec box; - int i; - int x, y; - xTrap *t = traps; - - box.x1 = 32767; - box.y1 = 32767; - box.x2 = -32767; - box.y2 = -32767; - x = pPicture->pDrawable->x + x_off; - y = pPicture->pDrawable->y + y_off; - for (i = 0; i < ntrap; i++) - { - pixman_fixed_t l = min (t->top.l, t->bot.l); - pixman_fixed_t r = max (t->top.r, t->bot.r); - int x1 = x + pixman_fixed_to_int (l); - int x2 = x + pixman_fixed_to_int (pixman_fixed_ceil (r)); - int y1 = y + pixman_fixed_to_int (t->top.y); - int y2 = y + pixman_fixed_to_int (pixman_fixed_ceil (t->bot.y)); - - if (x1 < box.x1) - box.x1 = x1; - if (x2 > box.x2) - box.x2 = x2; - if (y1 < box.y1) - box.y1 = y1; - if (y2 > box.y2) - box.y2 = y2; - } - TRIM_PICTURE_BOX (box, pPicture); - if (BOX_NOT_EMPTY(box)) - damageDamageBox (pPicture->pDrawable, &box, pPicture->subWindowMode); + if (checkPictureDamage(pPicture)) { + BoxRec box; + int i; + int x, y; + xTrap *t = traps; + + box.x1 = 32767; + box.y1 = 32767; + box.x2 = -32767; + box.y2 = -32767; + x = pPicture->pDrawable->x + x_off; + y = pPicture->pDrawable->y + y_off; + for (i = 0; i < ntrap; i++) { + pixman_fixed_t l = min(t->top.l, t->bot.l); + pixman_fixed_t r = max(t->top.r, t->bot.r); + int x1 = x + pixman_fixed_to_int(l); + int x2 = x + pixman_fixed_to_int(pixman_fixed_ceil(r)); + int y1 = y + pixman_fixed_to_int(t->top.y); + int y2 = y + pixman_fixed_to_int(pixman_fixed_ceil(t->bot.y)); + + if (x1 < box.x1) + box.x1 = x1; + if (x2 > box.x2) + box.x2 = x2; + if (y1 < box.y1) + box.y1 = y1; + if (y2 > box.y2) + box.y2 = y2; + } + TRIM_PICTURE_BOX(box, pPicture); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pPicture->pDrawable, &box, pPicture->subWindowMode); } - unwrap (pScrPriv, ps, AddTraps); + unwrap(pScrPriv, ps, AddTraps); (*ps->AddTraps) (pPicture, x_off, y_off, ntrap, traps); - damageRegionProcessPending (pPicture->pDrawable); - wrap (pScrPriv, ps, AddTraps, damageAddTraps); + damageRegionProcessPending(pPicture->pDrawable); + wrap(pScrPriv, ps, AddTraps, damageAddTraps); } /**********************************************************/ - static void damageFillSpans(DrawablePtr pDrawable, - GC *pGC, - int npt, - DDXPointPtr ppt, - int *pwidth, - int fSorted) + GC * pGC, int npt, DDXPointPtr ppt, int *pwidth, int fSorted) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (npt && checkGCDamage (pDrawable, pGC)) - { - int nptTmp = npt; - DDXPointPtr pptTmp = ppt; - int *pwidthTmp = pwidth; - BoxRec box; - - box.x1 = pptTmp->x; - box.x2 = box.x1 + *pwidthTmp; - box.y2 = box.y1 = pptTmp->y; - - while(--nptTmp) - { - pptTmp++; - pwidthTmp++; - if(box.x1 > pptTmp->x) box.x1 = pptTmp->x; - if(box.x2 < (pptTmp->x + *pwidthTmp)) - box.x2 = pptTmp->x + *pwidthTmp; - if(box.y1 > pptTmp->y) box.y1 = pptTmp->y; - else if(box.y2 < pptTmp->y) box.y2 = pptTmp->y; - } - - box.y2++; - - if(!pGC->miTranslate) { - TRANSLATE_BOX(box, pDrawable); + if (npt && checkGCDamage(pDrawable, pGC)) { + int nptTmp = npt; + DDXPointPtr pptTmp = ppt; + int *pwidthTmp = pwidth; + BoxRec box; + + box.x1 = pptTmp->x; + box.x2 = box.x1 + *pwidthTmp; + box.y2 = box.y1 = pptTmp->y; + + while (--nptTmp) { + pptTmp++; + pwidthTmp++; + if (box.x1 > pptTmp->x) + box.x1 = pptTmp->x; + if (box.x2 < (pptTmp->x + *pwidthTmp)) + box.x2 = pptTmp->x + *pwidthTmp; + if (box.y1 > pptTmp->y) + box.y1 = pptTmp->y; + else if (box.y2 < pptTmp->y) + box.y2 = pptTmp->y; } - TRIM_BOX(box, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + box.y2++; + + if (!pGC->miTranslate) { + TRANSLATE_BOX(box, pDrawable); + } + TRIM_BOX(box, pGC); + + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - - (*pGC->ops->FillSpans)(pDrawable, pGC, npt, ppt, pwidth, fSorted); - damageRegionProcessPending (pDrawable); + (*pGC->ops->FillSpans) (pDrawable, pGC, npt, ppt, pwidth, fSorted); + + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void -damageSetSpans(DrawablePtr pDrawable, - GCPtr pGC, - char *pcharsrc, - DDXPointPtr ppt, - int *pwidth, - int npt, - int fSorted) +damageSetSpans(DrawablePtr pDrawable, + GCPtr pGC, + char *pcharsrc, + DDXPointPtr ppt, int *pwidth, int npt, int fSorted) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (npt && checkGCDamage (pDrawable, pGC)) - { - DDXPointPtr pptTmp = ppt; - int *pwidthTmp = pwidth; - int nptTmp = npt; - BoxRec box; - - box.x1 = pptTmp->x; - box.x2 = box.x1 + *pwidthTmp; - box.y2 = box.y1 = pptTmp->y; - - while(--nptTmp) - { - pptTmp++; - pwidthTmp++; - if(box.x1 > pptTmp->x) box.x1 = pptTmp->x; - if(box.x2 < (pptTmp->x + *pwidthTmp)) - box.x2 = pptTmp->x + *pwidthTmp; - if(box.y1 > pptTmp->y) box.y1 = pptTmp->y; - else if(box.y2 < pptTmp->y) box.y2 = pptTmp->y; - } - - box.y2++; - - if(!pGC->miTranslate) { - TRANSLATE_BOX(box, pDrawable); + if (npt && checkGCDamage(pDrawable, pGC)) { + DDXPointPtr pptTmp = ppt; + int *pwidthTmp = pwidth; + int nptTmp = npt; + BoxRec box; + + box.x1 = pptTmp->x; + box.x2 = box.x1 + *pwidthTmp; + box.y2 = box.y1 = pptTmp->y; + + while (--nptTmp) { + pptTmp++; + pwidthTmp++; + if (box.x1 > pptTmp->x) + box.x1 = pptTmp->x; + if (box.x2 < (pptTmp->x + *pwidthTmp)) + box.x2 = pptTmp->x + *pwidthTmp; + if (box.y1 > pptTmp->y) + box.y1 = pptTmp->y; + else if (box.y2 < pptTmp->y) + box.y2 = pptTmp->y; } - TRIM_BOX(box, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + box.y2++; + + if (!pGC->miTranslate) { + TRANSLATE_BOX(box, pDrawable); + } + TRIM_BOX(box, pGC); + + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - (*pGC->ops->SetSpans)(pDrawable, pGC, pcharsrc, ppt, pwidth, npt, fSorted); - damageRegionProcessPending (pDrawable); + (*pGC->ops->SetSpans) (pDrawable, pGC, pcharsrc, ppt, pwidth, npt, fSorted); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void -damagePutImage(DrawablePtr pDrawable, - GCPtr pGC, - int depth, - int x, - int y, - int w, - int h, - int leftPad, - int format, - char *pImage) +damagePutImage(DrawablePtr pDrawable, + GCPtr pGC, + int depth, + int x, + int y, int w, int h, int leftPad, int format, char *pImage) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (checkGCDamage (pDrawable, pGC)) - { - BoxRec box; - - box.x1 = x + pDrawable->x; - box.x2 = box.x1 + w; - box.y1 = y + pDrawable->y; - box.y2 = box.y1 + h; - - TRIM_BOX(box, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + if (checkGCDamage(pDrawable, pGC)) { + BoxRec box; + + box.x1 = x + pDrawable->x; + box.x2 = box.x1 + w; + box.y1 = y + pDrawable->y; + box.y2 = box.y1 + h; + + TRIM_BOX(box, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - (*pGC->ops->PutImage)(pDrawable, pGC, depth, x, y, w, h, - leftPad, format, pImage); - damageRegionProcessPending (pDrawable); + (*pGC->ops->PutImage) (pDrawable, pGC, depth, x, y, w, h, + leftPad, format, pImage); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static RegionPtr -damageCopyArea(DrawablePtr pSrc, - DrawablePtr pDst, - GC *pGC, - int srcx, - int srcy, - int width, - int height, - int dstx, - int dsty) +damageCopyArea(DrawablePtr pSrc, + DrawablePtr pDst, + GC * pGC, + int srcx, int srcy, int width, int height, int dstx, int dsty) { RegionPtr ret; + DAMAGE_GC_OP_PROLOGUE(pGC, pDst); - - if (checkGCDamage (pDst, pGC)) - { - BoxRec box; - - box.x1 = dstx + pDst->x; - box.x2 = box.x1 + width; - box.y1 = dsty + pDst->y; - box.y2 = box.y1 + height; - - TRIM_BOX(box, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDst, &box, pGC->subWindowMode); + + if (checkGCDamage(pDst, pGC)) { + BoxRec box; + + box.x1 = dstx + pDst->x; + box.x2 = box.x1 + width; + box.y1 = dsty + pDst->y; + box.y2 = box.y1 + height; + + TRIM_BOX(box, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDst, &box, pGC->subWindowMode); } - ret = (*pGC->ops->CopyArea)(pSrc, pDst, - pGC, srcx, srcy, width, height, dstx, dsty); - damageRegionProcessPending (pDst); + ret = (*pGC->ops->CopyArea) (pSrc, pDst, + pGC, srcx, srcy, width, height, dstx, dsty); + damageRegionProcessPending(pDst); DAMAGE_GC_OP_EPILOGUE(pGC, pDst); return ret; } static RegionPtr -damageCopyPlane(DrawablePtr pSrc, - DrawablePtr pDst, - GCPtr pGC, - int srcx, - int srcy, - int width, - int height, - int dstx, - int dsty, - unsigned long bitPlane) +damageCopyPlane(DrawablePtr pSrc, + DrawablePtr pDst, + GCPtr pGC, + int srcx, + int srcy, + int width, + int height, int dstx, int dsty, unsigned long bitPlane) { RegionPtr ret; + DAMAGE_GC_OP_PROLOGUE(pGC, pDst); - if (checkGCDamage (pDst, pGC)) - { - BoxRec box; + if (checkGCDamage(pDst, pGC)) { + BoxRec box; - box.x1 = dstx + pDst->x; - box.x2 = box.x1 + width; - box.y1 = dsty + pDst->y; - box.y2 = box.y1 + height; + box.x1 = dstx + pDst->x; + box.x2 = box.x1 + width; + box.y1 = dsty + pDst->y; + box.y2 = box.y1 + height; - TRIM_BOX(box, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDst, &box, pGC->subWindowMode); + TRIM_BOX(box, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDst, &box, pGC->subWindowMode); } - ret = (*pGC->ops->CopyPlane)(pSrc, pDst, - pGC, srcx, srcy, width, height, dstx, dsty, bitPlane); - damageRegionProcessPending (pDst); + ret = (*pGC->ops->CopyPlane) (pSrc, pDst, + pGC, srcx, srcy, width, height, dstx, dsty, + bitPlane); + damageRegionProcessPending(pDst); DAMAGE_GC_OP_EPILOGUE(pGC, pDst); return ret; } static void damagePolyPoint(DrawablePtr pDrawable, - GCPtr pGC, - int mode, - int npt, - xPoint *ppt) + GCPtr pGC, int mode, int npt, xPoint * ppt) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (npt && checkGCDamage (pDrawable, pGC)) - { - BoxRec box; - int nptTmp = npt; - xPoint *pptTmp = ppt; - - box.x2 = box.x1 = pptTmp->x; - box.y2 = box.y1 = pptTmp->y; - - /* this could be slow if the points were spread out */ - - while(--nptTmp) - { - pptTmp++; - if(box.x1 > pptTmp->x) box.x1 = pptTmp->x; - else if(box.x2 < pptTmp->x) box.x2 = pptTmp->x; - if(box.y1 > pptTmp->y) box.y1 = pptTmp->y; - else if(box.y2 < pptTmp->y) box.y2 = pptTmp->y; - } + if (npt && checkGCDamage(pDrawable, pGC)) { + BoxRec box; + int nptTmp = npt; + xPoint *pptTmp = ppt; + + box.x2 = box.x1 = pptTmp->x; + box.y2 = box.y1 = pptTmp->y; + + /* this could be slow if the points were spread out */ + + while (--nptTmp) { + pptTmp++; + if (box.x1 > pptTmp->x) + box.x1 = pptTmp->x; + else if (box.x2 < pptTmp->x) + box.x2 = pptTmp->x; + if (box.y1 > pptTmp->y) + box.y1 = pptTmp->y; + else if (box.y2 < pptTmp->y) + box.y2 = pptTmp->y; + } - box.x2++; - box.y2++; + box.x2++; + box.y2++; - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - (*pGC->ops->PolyPoint)(pDrawable, pGC, mode, npt, ppt); - damageRegionProcessPending (pDrawable); + (*pGC->ops->PolyPoint) (pDrawable, pGC, mode, npt, ppt); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void damagePolylines(DrawablePtr pDrawable, - GCPtr pGC, - int mode, - int npt, - DDXPointPtr ppt) + GCPtr pGC, int mode, int npt, DDXPointPtr ppt) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (npt && checkGCDamage (pDrawable, pGC)) - { - int nptTmp = npt; - DDXPointPtr pptTmp = ppt; - BoxRec box; - int extra = pGC->lineWidth >> 1; - - box.x2 = box.x1 = pptTmp->x; - box.y2 = box.y1 = pptTmp->y; - - if(nptTmp > 1) - { - if(pGC->joinStyle == JoinMiter) - extra = 6 * pGC->lineWidth; - else if(pGC->capStyle == CapProjecting) - extra = pGC->lineWidth; + if (npt && checkGCDamage(pDrawable, pGC)) { + int nptTmp = npt; + DDXPointPtr pptTmp = ppt; + BoxRec box; + int extra = pGC->lineWidth >> 1; + + box.x2 = box.x1 = pptTmp->x; + box.y2 = box.y1 = pptTmp->y; + + if (nptTmp > 1) { + if (pGC->joinStyle == JoinMiter) + extra = 6 * pGC->lineWidth; + else if (pGC->capStyle == CapProjecting) + extra = pGC->lineWidth; } - if(mode == CoordModePrevious) - { - int x = box.x1; - int y = box.y1; - while(--nptTmp) - { - pptTmp++; - x += pptTmp->x; - y += pptTmp->y; - if(box.x1 > x) box.x1 = x; - else if(box.x2 < x) box.x2 = x; - if(box.y1 > y) box.y1 = y; - else if(box.y2 < y) box.y2 = y; - } - } - else - { - while(--nptTmp) - { - pptTmp++; - if(box.x1 > pptTmp->x) box.x1 = pptTmp->x; - else if(box.x2 < pptTmp->x) box.x2 = pptTmp->x; - if(box.y1 > pptTmp->y) box.y1 = pptTmp->y; - else if(box.y2 < pptTmp->y) box.y2 = pptTmp->y; - } - } - - box.x2++; - box.y2++; - - if(extra) - { - box.x1 -= extra; - box.x2 += extra; - box.y1 -= extra; - box.y2 += extra; + if (mode == CoordModePrevious) { + int x = box.x1; + int y = box.y1; + + while (--nptTmp) { + pptTmp++; + x += pptTmp->x; + y += pptTmp->y; + if (box.x1 > x) + box.x1 = x; + else if (box.x2 < x) + box.x2 = x; + if (box.y1 > y) + box.y1 = y; + else if (box.y2 < y) + box.y2 = y; + } } + else { + while (--nptTmp) { + pptTmp++; + if (box.x1 > pptTmp->x) + box.x1 = pptTmp->x; + else if (box.x2 < pptTmp->x) + box.x2 = pptTmp->x; + if (box.y1 > pptTmp->y) + box.y1 = pptTmp->y; + else if (box.y2 < pptTmp->y) + box.y2 = pptTmp->y; + } + } + + box.x2++; + box.y2++; - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + if (extra) { + box.x1 -= extra; + box.x2 += extra; + box.y1 -= extra; + box.y2 += extra; + } + + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - (*pGC->ops->Polylines)(pDrawable, pGC, mode, npt, ppt); - damageRegionProcessPending (pDrawable); + (*pGC->ops->Polylines) (pDrawable, pGC, mode, npt, ppt); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void -damagePolySegment(DrawablePtr pDrawable, - GCPtr pGC, - int nSeg, - xSegment *pSeg) +damagePolySegment(DrawablePtr pDrawable, GCPtr pGC, int nSeg, xSegment * pSeg) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (nSeg && checkGCDamage (pDrawable, pGC)) - { - BoxRec box; - int extra = pGC->lineWidth; - int nsegTmp = nSeg; - xSegment *pSegTmp = pSeg; - - if(pGC->capStyle != CapProjecting) - extra >>= 1; - - if(pSegTmp->x2 > pSegTmp->x1) { - box.x1 = pSegTmp->x1; - box.x2 = pSegTmp->x2; - } else { - box.x2 = pSegTmp->x1; - box.x1 = pSegTmp->x2; - } - - if(pSegTmp->y2 > pSegTmp->y1) { - box.y1 = pSegTmp->y1; - box.y2 = pSegTmp->y2; - } else { - box.y2 = pSegTmp->y1; - box.y1 = pSegTmp->y2; - } - - while(--nsegTmp) - { - pSegTmp++; - if(pSegTmp->x2 > pSegTmp->x1) - { - if(pSegTmp->x1 < box.x1) box.x1 = pSegTmp->x1; - if(pSegTmp->x2 > box.x2) box.x2 = pSegTmp->x2; - } - else - { - if(pSegTmp->x2 < box.x1) box.x1 = pSegTmp->x2; - if(pSegTmp->x1 > box.x2) box.x2 = pSegTmp->x1; - } - if(pSegTmp->y2 > pSegTmp->y1) - { - if(pSegTmp->y1 < box.y1) box.y1 = pSegTmp->y1; - if(pSegTmp->y2 > box.y2) box.y2 = pSegTmp->y2; - } - else - { - if(pSegTmp->y2 < box.y1) box.y1 = pSegTmp->y2; - if(pSegTmp->y1 > box.y2) box.y2 = pSegTmp->y1; - } - } - - box.x2++; - box.y2++; - - if(extra) - { - box.x1 -= extra; - box.x2 += extra; - box.y1 -= extra; - box.y2 += extra; + if (nSeg && checkGCDamage(pDrawable, pGC)) { + BoxRec box; + int extra = pGC->lineWidth; + int nsegTmp = nSeg; + xSegment *pSegTmp = pSeg; + + if (pGC->capStyle != CapProjecting) + extra >>= 1; + + if (pSegTmp->x2 > pSegTmp->x1) { + box.x1 = pSegTmp->x1; + box.x2 = pSegTmp->x2; + } + else { + box.x2 = pSegTmp->x1; + box.x1 = pSegTmp->x2; + } + + if (pSegTmp->y2 > pSegTmp->y1) { + box.y1 = pSegTmp->y1; + box.y2 = pSegTmp->y2; + } + else { + box.y2 = pSegTmp->y1; + box.y1 = pSegTmp->y2; + } + + while (--nsegTmp) { + pSegTmp++; + if (pSegTmp->x2 > pSegTmp->x1) { + if (pSegTmp->x1 < box.x1) + box.x1 = pSegTmp->x1; + if (pSegTmp->x2 > box.x2) + box.x2 = pSegTmp->x2; + } + else { + if (pSegTmp->x2 < box.x1) + box.x1 = pSegTmp->x2; + if (pSegTmp->x1 > box.x2) + box.x2 = pSegTmp->x1; + } + if (pSegTmp->y2 > pSegTmp->y1) { + if (pSegTmp->y1 < box.y1) + box.y1 = pSegTmp->y1; + if (pSegTmp->y2 > box.y2) + box.y2 = pSegTmp->y2; + } + else { + if (pSegTmp->y2 < box.y1) + box.y1 = pSegTmp->y2; + if (pSegTmp->y1 > box.y2) + box.y2 = pSegTmp->y1; + } + } + + box.x2++; + box.y2++; + + if (extra) { + box.x1 -= extra; + box.x2 += extra; + box.y1 -= extra; + box.y2 += extra; } - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - (*pGC->ops->PolySegment)(pDrawable, pGC, nSeg, pSeg); - damageRegionProcessPending (pDrawable); + (*pGC->ops->PolySegment) (pDrawable, pGC, nSeg, pSeg); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void -damagePolyRectangle(DrawablePtr pDrawable, - GCPtr pGC, - int nRects, - xRectangle *pRects) +damagePolyRectangle(DrawablePtr pDrawable, + GCPtr pGC, int nRects, xRectangle *pRects) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (nRects && checkGCDamage (pDrawable, pGC)) - { - BoxRec box; - int offset1, offset2, offset3; - int nRectsTmp = nRects; - xRectangle *pRectsTmp = pRects; - - offset2 = pGC->lineWidth; - if(!offset2) offset2 = 1; - offset1 = offset2 >> 1; - offset3 = offset2 - offset1; - - while(nRectsTmp--) - { - box.x1 = pRectsTmp->x - offset1; - box.y1 = pRectsTmp->y - offset1; - box.x2 = box.x1 + pRectsTmp->width + offset2; - box.y2 = box.y1 + offset2; - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); - - box.x1 = pRectsTmp->x - offset1; - box.y1 = pRectsTmp->y + offset3; - box.x2 = box.x1 + offset2; - box.y2 = box.y1 + pRectsTmp->height - offset2; - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); - - box.x1 = pRectsTmp->x + pRectsTmp->width - offset1; - box.y1 = pRectsTmp->y + offset3; - box.x2 = box.x1 + offset2; - box.y2 = box.y1 + pRectsTmp->height - offset2; - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); - - box.x1 = pRectsTmp->x - offset1; - box.y1 = pRectsTmp->y + pRectsTmp->height - offset1; - box.x2 = box.x1 + pRectsTmp->width + offset2; - box.y2 = box.y1 + offset2; - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); - - pRectsTmp++; - } + if (nRects && checkGCDamage(pDrawable, pGC)) { + BoxRec box; + int offset1, offset2, offset3; + int nRectsTmp = nRects; + xRectangle *pRectsTmp = pRects; + + offset2 = pGC->lineWidth; + if (!offset2) + offset2 = 1; + offset1 = offset2 >> 1; + offset3 = offset2 - offset1; + + while (nRectsTmp--) { + box.x1 = pRectsTmp->x - offset1; + box.y1 = pRectsTmp->y - offset1; + box.x2 = box.x1 + pRectsTmp->width + offset2; + box.y2 = box.y1 + offset2; + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); + + box.x1 = pRectsTmp->x - offset1; + box.y1 = pRectsTmp->y + offset3; + box.x2 = box.x1 + offset2; + box.y2 = box.y1 + pRectsTmp->height - offset2; + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); + + box.x1 = pRectsTmp->x + pRectsTmp->width - offset1; + box.y1 = pRectsTmp->y + offset3; + box.x2 = box.x1 + offset2; + box.y2 = box.y1 + pRectsTmp->height - offset2; + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); + + box.x1 = pRectsTmp->x - offset1; + box.y1 = pRectsTmp->y + pRectsTmp->height - offset1; + box.x2 = box.x1 + pRectsTmp->width + offset2; + box.y2 = box.y1 + offset2; + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); + + pRectsTmp++; + } } - (*pGC->ops->PolyRectangle)(pDrawable, pGC, nRects, pRects); - damageRegionProcessPending (pDrawable); + (*pGC->ops->PolyRectangle) (pDrawable, pGC, nRects, pRects); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void -damagePolyArc(DrawablePtr pDrawable, - GCPtr pGC, - int nArcs, - xArc *pArcs) +damagePolyArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc * pArcs) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (nArcs && checkGCDamage (pDrawable, pGC)) - { - int extra = pGC->lineWidth >> 1; - BoxRec box; - int nArcsTmp = nArcs; - xArc *pArcsTmp = pArcs; - - box.x1 = pArcsTmp->x; - box.x2 = box.x1 + pArcsTmp->width; - box.y1 = pArcsTmp->y; - box.y2 = box.y1 + pArcsTmp->height; - - while(--nArcsTmp) - { - pArcsTmp++; - if(box.x1 > pArcsTmp->x) - box.x1 = pArcsTmp->x; - if(box.x2 < (pArcsTmp->x + pArcsTmp->width)) - box.x2 = pArcsTmp->x + pArcsTmp->width; - if(box.y1 > pArcsTmp->y) - box.y1 = pArcsTmp->y; - if(box.y2 < (pArcsTmp->y + pArcsTmp->height)) - box.y2 = pArcsTmp->y + pArcsTmp->height; + if (nArcs && checkGCDamage(pDrawable, pGC)) { + int extra = pGC->lineWidth >> 1; + BoxRec box; + int nArcsTmp = nArcs; + xArc *pArcsTmp = pArcs; + + box.x1 = pArcsTmp->x; + box.x2 = box.x1 + pArcsTmp->width; + box.y1 = pArcsTmp->y; + box.y2 = box.y1 + pArcsTmp->height; + + while (--nArcsTmp) { + pArcsTmp++; + if (box.x1 > pArcsTmp->x) + box.x1 = pArcsTmp->x; + if (box.x2 < (pArcsTmp->x + pArcsTmp->width)) + box.x2 = pArcsTmp->x + pArcsTmp->width; + if (box.y1 > pArcsTmp->y) + box.y1 = pArcsTmp->y; + if (box.y2 < (pArcsTmp->y + pArcsTmp->height)) + box.y2 = pArcsTmp->y + pArcsTmp->height; } - if(extra) - { - box.x1 -= extra; - box.x2 += extra; - box.y1 -= extra; - box.y2 += extra; + if (extra) { + box.x1 -= extra; + box.x2 += extra; + box.y1 -= extra; + box.y2 += extra; } - box.x2++; - box.y2++; + box.x2++; + box.y2++; - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - (*pGC->ops->PolyArc)(pDrawable, pGC, nArcs, pArcs); - damageRegionProcessPending (pDrawable); + (*pGC->ops->PolyArc) (pDrawable, pGC, nArcs, pArcs); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void -damageFillPolygon(DrawablePtr pDrawable, - GCPtr pGC, - int shape, - int mode, - int npt, - DDXPointPtr ppt) +damageFillPolygon(DrawablePtr pDrawable, + GCPtr pGC, int shape, int mode, int npt, DDXPointPtr ppt) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (npt > 2 && checkGCDamage (pDrawable, pGC)) - { - DDXPointPtr pptTmp = ppt; - int nptTmp = npt; - BoxRec box; - - box.x2 = box.x1 = pptTmp->x; - box.y2 = box.y1 = pptTmp->y; - - if(mode != CoordModeOrigin) - { - int x = box.x1; - int y = box.y1; - while(--nptTmp) - { - pptTmp++; - x += pptTmp->x; - y += pptTmp->y; - if(box.x1 > x) box.x1 = x; - else if(box.x2 < x) box.x2 = x; - if(box.y1 > y) box.y1 = y; - else if(box.y2 < y) box.y2 = y; - } - } - else - { - while(--nptTmp) - { - pptTmp++; - if(box.x1 > pptTmp->x) box.x1 = pptTmp->x; - else if(box.x2 < pptTmp->x) box.x2 = pptTmp->x; - if(box.y1 > pptTmp->y) box.y1 = pptTmp->y; - else if(box.y2 < pptTmp->y) box.y2 = pptTmp->y; - } - } - - box.x2++; - box.y2++; - - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + if (npt > 2 && checkGCDamage(pDrawable, pGC)) { + DDXPointPtr pptTmp = ppt; + int nptTmp = npt; + BoxRec box; + + box.x2 = box.x1 = pptTmp->x; + box.y2 = box.y1 = pptTmp->y; + + if (mode != CoordModeOrigin) { + int x = box.x1; + int y = box.y1; + + while (--nptTmp) { + pptTmp++; + x += pptTmp->x; + y += pptTmp->y; + if (box.x1 > x) + box.x1 = x; + else if (box.x2 < x) + box.x2 = x; + if (box.y1 > y) + box.y1 = y; + else if (box.y2 < y) + box.y2 = y; + } + } + else { + while (--nptTmp) { + pptTmp++; + if (box.x1 > pptTmp->x) + box.x1 = pptTmp->x; + else if (box.x2 < pptTmp->x) + box.x2 = pptTmp->x; + if (box.y1 > pptTmp->y) + box.y1 = pptTmp->y; + else if (box.y2 < pptTmp->y) + box.y2 = pptTmp->y; + } + } + + box.x2++; + box.y2++; + + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - - (*pGC->ops->FillPolygon)(pDrawable, pGC, shape, mode, npt, ppt); - damageRegionProcessPending (pDrawable); + + (*pGC->ops->FillPolygon) (pDrawable, pGC, shape, mode, npt, ppt); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } - static void -damagePolyFillRect(DrawablePtr pDrawable, - GCPtr pGC, - int nRects, - xRectangle *pRects) +damagePolyFillRect(DrawablePtr pDrawable, + GCPtr pGC, int nRects, xRectangle *pRects) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (nRects && checkGCDamage (pDrawable, pGC)) - { - BoxRec box; - xRectangle *pRectsTmp = pRects; - int nRectsTmp = nRects; - - box.x1 = pRectsTmp->x; - box.x2 = box.x1 + pRectsTmp->width; - box.y1 = pRectsTmp->y; - box.y2 = box.y1 + pRectsTmp->height; - - while(--nRectsTmp) - { - pRectsTmp++; - if(box.x1 > pRectsTmp->x) box.x1 = pRectsTmp->x; - if(box.x2 < (pRectsTmp->x + pRectsTmp->width)) - box.x2 = pRectsTmp->x + pRectsTmp->width; - if(box.y1 > pRectsTmp->y) box.y1 = pRectsTmp->y; - if(box.y2 < (pRectsTmp->y + pRectsTmp->height)) - box.y2 = pRectsTmp->y + pRectsTmp->height; - } - - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + if (nRects && checkGCDamage(pDrawable, pGC)) { + BoxRec box; + xRectangle *pRectsTmp = pRects; + int nRectsTmp = nRects; + + box.x1 = pRectsTmp->x; + box.x2 = box.x1 + pRectsTmp->width; + box.y1 = pRectsTmp->y; + box.y2 = box.y1 + pRectsTmp->height; + + while (--nRectsTmp) { + pRectsTmp++; + if (box.x1 > pRectsTmp->x) + box.x1 = pRectsTmp->x; + if (box.x2 < (pRectsTmp->x + pRectsTmp->width)) + box.x2 = pRectsTmp->x + pRectsTmp->width; + if (box.y1 > pRectsTmp->y) + box.y1 = pRectsTmp->y; + if (box.y2 < (pRectsTmp->y + pRectsTmp->height)) + box.y2 = pRectsTmp->y + pRectsTmp->height; + } + + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - (*pGC->ops->PolyFillRect)(pDrawable, pGC, nRects, pRects); - damageRegionProcessPending (pDrawable); + (*pGC->ops->PolyFillRect) (pDrawable, pGC, nRects, pRects); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } - static void -damagePolyFillArc(DrawablePtr pDrawable, - GCPtr pGC, - int nArcs, - xArc *pArcs) +damagePolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc * pArcs) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (nArcs && checkGCDamage (pDrawable, pGC)) - { - BoxRec box; - int nArcsTmp = nArcs; - xArc *pArcsTmp = pArcs; - - box.x1 = pArcsTmp->x; - box.x2 = box.x1 + pArcsTmp->width; - box.y1 = pArcsTmp->y; - box.y2 = box.y1 + pArcsTmp->height; - - while(--nArcsTmp) - { - pArcsTmp++; - if(box.x1 > pArcsTmp->x) - box.x1 = pArcsTmp->x; - if(box.x2 < (pArcsTmp->x + pArcsTmp->width)) - box.x2 = pArcsTmp->x + pArcsTmp->width; - if(box.y1 > pArcsTmp->y) - box.y1 = pArcsTmp->y; - if(box.y2 < (pArcsTmp->y + pArcsTmp->height)) - box.y2 = pArcsTmp->y + pArcsTmp->height; + if (nArcs && checkGCDamage(pDrawable, pGC)) { + BoxRec box; + int nArcsTmp = nArcs; + xArc *pArcsTmp = pArcs; + + box.x1 = pArcsTmp->x; + box.x2 = box.x1 + pArcsTmp->width; + box.y1 = pArcsTmp->y; + box.y2 = box.y1 + pArcsTmp->height; + + while (--nArcsTmp) { + pArcsTmp++; + if (box.x1 > pArcsTmp->x) + box.x1 = pArcsTmp->x; + if (box.x2 < (pArcsTmp->x + pArcsTmp->width)) + box.x2 = pArcsTmp->x + pArcsTmp->width; + if (box.y1 > pArcsTmp->y) + box.y1 = pArcsTmp->y; + if (box.y2 < (pArcsTmp->y + pArcsTmp->height)) + box.y2 = pArcsTmp->y + pArcsTmp->height; } - TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - (*pGC->ops->PolyFillArc)(pDrawable, pGC, nArcs, pArcs); - damageRegionProcessPending (pDrawable); + (*pGC->ops->PolyFillArc) (pDrawable, pGC, nArcs, pArcs); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } @@ -1359,37 +1297,34 @@ damagePolyFillArc(DrawablePtr pDrawable, */ static void -damageDamageChars (DrawablePtr pDrawable, - FontPtr font, - int x, - int y, - unsigned int n, - CharInfoPtr *charinfo, - Bool imageblt, - int subWindowMode) -{ - ExtentInfoRec extents; - BoxRec box; +damageDamageChars(DrawablePtr pDrawable, + FontPtr font, + int x, + int y, + unsigned int n, + CharInfoPtr * charinfo, Bool imageblt, int subWindowMode) +{ + ExtentInfoRec extents; + BoxRec box; QueryGlyphExtents(font, charinfo, n, &extents); - if (imageblt) - { - if (extents.overallWidth > extents.overallRight) - extents.overallRight = extents.overallWidth; - if (extents.overallWidth < extents.overallLeft) - extents.overallLeft = extents.overallWidth; - if (extents.overallLeft > 0) - extents.overallLeft = 0; - if (extents.fontAscent > extents.overallAscent) - extents.overallAscent = extents.fontAscent; - if (extents.fontDescent > extents.overallDescent) - extents.overallDescent = extents.fontDescent; + if (imageblt) { + if (extents.overallWidth > extents.overallRight) + extents.overallRight = extents.overallWidth; + if (extents.overallWidth < extents.overallLeft) + extents.overallLeft = extents.overallWidth; + if (extents.overallLeft > 0) + extents.overallLeft = 0; + if (extents.fontAscent > extents.overallAscent) + extents.overallAscent = extents.fontAscent; + if (extents.fontDescent > extents.overallDescent) + extents.overallDescent = extents.fontDescent; } box.x1 = x + extents.overallLeft; box.y1 = y - extents.overallAscent; box.x2 = x + extents.overallRight; box.y2 = y + extents.overallDescent; - damageDamageBox (pDrawable, &box, subWindowMode); + damageDamageBox(pDrawable, &box, subWindowMode); } /* @@ -1400,46 +1335,45 @@ damageDamageChars (DrawablePtr pDrawable, #define TT_POLY16 2 #define TT_IMAGE16 3 -static int -damageText (DrawablePtr pDrawable, - GCPtr pGC, - int x, - int y, - unsigned long count, - char *chars, - FontEncoding fontEncoding, - Bool textType) -{ - CharInfoPtr *charinfo; - CharInfoPtr *info; - unsigned long i; - unsigned int n; - int w; - Bool imageblt; +static int +damageText(DrawablePtr pDrawable, + GCPtr pGC, + int x, + int y, + unsigned long count, + char *chars, FontEncoding fontEncoding, Bool textType) +{ + CharInfoPtr *charinfo; + CharInfoPtr *info; + unsigned long i; + unsigned int n; + int w; + Bool imageblt; imageblt = (textType == TT_IMAGE8) || (textType == TT_IMAGE16); charinfo = malloc(count * sizeof(CharInfoPtr)); if (!charinfo) - return x; + return x; - GetGlyphs(pGC->font, count, (unsigned char *)chars, - fontEncoding, &i, charinfo); - n = (unsigned int)i; + GetGlyphs(pGC->font, count, (unsigned char *) chars, + fontEncoding, &i, charinfo); + n = (unsigned int) i; w = 0; if (!imageblt) - for (info = charinfo; i--; info++) - w += (*info)->metrics.characterWidth; + for (info = charinfo; i--; info++) + w += (*info)->metrics.characterWidth; if (n != 0) { - damageDamageChars (pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y, n, - charinfo, imageblt, pGC->subWindowMode); - if (imageblt) - (*pGC->ops->ImageGlyphBlt)(pDrawable, pGC, x, y, n, charinfo, - FONTGLYPHS(pGC->font)); - else - (*pGC->ops->PolyGlyphBlt)(pDrawable, pGC, x, y, n, charinfo, - FONTGLYPHS(pGC->font)); + damageDamageChars(pDrawable, pGC->font, x + pDrawable->x, + y + pDrawable->y, n, charinfo, imageblt, + pGC->subWindowMode); + if (imageblt) + (*pGC->ops->ImageGlyphBlt) (pDrawable, pGC, x, y, n, charinfo, + FONTGLYPHS(pGC->font)); + else + (*pGC->ops->PolyGlyphBlt) (pDrawable, pGC, x, y, n, charinfo, + FONTGLYPHS(pGC->font)); } free(charinfo); return x + w; @@ -1447,238 +1381,206 @@ damageText (DrawablePtr pDrawable, static int damagePolyText8(DrawablePtr pDrawable, - GCPtr pGC, - int x, - int y, - int count, - char *chars) + GCPtr pGC, int x, int y, int count, char *chars) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (checkGCDamage (pDrawable, pGC)) - x = damageText (pDrawable, pGC, x, y, (unsigned long) count, chars, - Linear8Bit, TT_POLY8); + if (checkGCDamage(pDrawable, pGC)) + x = damageText(pDrawable, pGC, x, y, (unsigned long) count, chars, + Linear8Bit, TT_POLY8); else - x = (*pGC->ops->PolyText8)(pDrawable, pGC, x, y, count, chars); - damageRegionProcessPending (pDrawable); + x = (*pGC->ops->PolyText8) (pDrawable, pGC, x, y, count, chars); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); return x; } static int -damagePolyText16(DrawablePtr pDrawable, - GCPtr pGC, - int x, - int y, - int count, - unsigned short *chars) +damagePolyText16(DrawablePtr pDrawable, + GCPtr pGC, int x, int y, int count, unsigned short *chars) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (checkGCDamage (pDrawable, pGC)) - x = damageText (pDrawable, pGC, x, y, (unsigned long) count, (char *) chars, - FONTLASTROW(pGC->font) == 0 ? Linear16Bit : TwoD16Bit, - TT_POLY16); + if (checkGCDamage(pDrawable, pGC)) + x = damageText(pDrawable, pGC, x, y, (unsigned long) count, + (char *) chars, + FONTLASTROW(pGC->font) == 0 ? Linear16Bit : TwoD16Bit, + TT_POLY16); else - x = (*pGC->ops->PolyText16)(pDrawable, pGC, x, y, count, chars); - damageRegionProcessPending (pDrawable); + x = (*pGC->ops->PolyText16) (pDrawable, pGC, x, y, count, chars); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); return x; } static void -damageImageText8(DrawablePtr pDrawable, - GCPtr pGC, - int x, - int y, - int count, - char *chars) +damageImageText8(DrawablePtr pDrawable, + GCPtr pGC, int x, int y, int count, char *chars) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (checkGCDamage (pDrawable, pGC)) - damageText (pDrawable, pGC, x, y, (unsigned long) count, chars, - Linear8Bit, TT_IMAGE8); + if (checkGCDamage(pDrawable, pGC)) + damageText(pDrawable, pGC, x, y, (unsigned long) count, chars, + Linear8Bit, TT_IMAGE8); else - (*pGC->ops->ImageText8)(pDrawable, pGC, x, y, count, chars); - damageRegionProcessPending (pDrawable); + (*pGC->ops->ImageText8) (pDrawable, pGC, x, y, count, chars); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void -damageImageText16(DrawablePtr pDrawable, - GCPtr pGC, - int x, - int y, - int count, - unsigned short *chars) +damageImageText16(DrawablePtr pDrawable, + GCPtr pGC, int x, int y, int count, unsigned short *chars) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if (checkGCDamage (pDrawable, pGC)) - damageText (pDrawable, pGC, x, y, (unsigned long) count, (char *) chars, - FONTLASTROW(pGC->font) == 0 ? Linear16Bit : TwoD16Bit, - TT_IMAGE16); + if (checkGCDamage(pDrawable, pGC)) + damageText(pDrawable, pGC, x, y, (unsigned long) count, (char *) chars, + FONTLASTROW(pGC->font) == 0 ? Linear16Bit : TwoD16Bit, + TT_IMAGE16); else - (*pGC->ops->ImageText16)(pDrawable, pGC, x, y, count, chars); - damageRegionProcessPending (pDrawable); + (*pGC->ops->ImageText16) (pDrawable, pGC, x, y, count, chars); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } - static void -damageImageGlyphBlt(DrawablePtr pDrawable, - GCPtr pGC, - int x, - int y, - unsigned int nglyph, - CharInfoPtr *ppci, - pointer pglyphBase) +damageImageGlyphBlt(DrawablePtr pDrawable, + GCPtr pGC, + int x, + int y, + unsigned int nglyph, CharInfoPtr * ppci, pointer pglyphBase) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - damageDamageChars (pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y, - nglyph, ppci, TRUE, pGC->subWindowMode); - (*pGC->ops->ImageGlyphBlt)(pDrawable, pGC, x, y, nglyph, - ppci, pglyphBase); - damageRegionProcessPending (pDrawable); + damageDamageChars(pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y, + nglyph, ppci, TRUE, pGC->subWindowMode); + (*pGC->ops->ImageGlyphBlt) (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void -damagePolyGlyphBlt(DrawablePtr pDrawable, - GCPtr pGC, - int x, - int y, - unsigned int nglyph, - CharInfoPtr *ppci, - pointer pglyphBase) +damagePolyGlyphBlt(DrawablePtr pDrawable, + GCPtr pGC, + int x, + int y, + unsigned int nglyph, CharInfoPtr * ppci, pointer pglyphBase) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - damageDamageChars (pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y, - nglyph, ppci, FALSE, pGC->subWindowMode); - (*pGC->ops->PolyGlyphBlt)(pDrawable, pGC, x, y, nglyph, - ppci, pglyphBase); - damageRegionProcessPending (pDrawable); + damageDamageChars(pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y, + nglyph, ppci, FALSE, pGC->subWindowMode); + (*pGC->ops->PolyGlyphBlt) (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void -damagePushPixels(GCPtr pGC, - PixmapPtr pBitMap, - DrawablePtr pDrawable, - int dx, - int dy, - int xOrg, - int yOrg) +damagePushPixels(GCPtr pGC, + PixmapPtr pBitMap, + DrawablePtr pDrawable, int dx, int dy, int xOrg, int yOrg) { DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable); - if(checkGCDamage (pDrawable, pGC)) - { - BoxRec box; + if (checkGCDamage(pDrawable, pGC)) { + BoxRec box; box.x1 = xOrg; box.y1 = yOrg; - if(!pGC->miTranslate) { - box.x1 += pDrawable->x; - box.y1 += pDrawable->y; + if (!pGC->miTranslate) { + box.x1 += pDrawable->x; + box.y1 += pDrawable->y; } - box.x2 = box.x1 + dx; - box.y2 = box.y1 + dy; + box.x2 = box.x1 + dx; + box.y2 = box.y1 + dy; - TRIM_BOX(box, pGC); - if(BOX_NOT_EMPTY(box)) - damageDamageBox (pDrawable, &box, pGC->subWindowMode); + TRIM_BOX(box, pGC); + if (BOX_NOT_EMPTY(box)) + damageDamageBox(pDrawable, &box, pGC->subWindowMode); } - (*pGC->ops->PushPixels)(pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg); - damageRegionProcessPending (pDrawable); + (*pGC->ops->PushPixels) (pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg); + damageRegionProcessPending(pDrawable); DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable); } static void -damageRemoveDamage (DamagePtr *pPrev, DamagePtr pDamage) -{ - while (*pPrev) - { - if (*pPrev == pDamage) - { - *pPrev = pDamage->pNext; - return; - } - pPrev = &(*pPrev)->pNext; +damageRemoveDamage(DamagePtr * pPrev, DamagePtr pDamage) +{ + while (*pPrev) { + if (*pPrev == pDamage) { + *pPrev = pDamage->pNext; + return; + } + pPrev = &(*pPrev)->pNext; } #if DAMAGE_VALIDATE_ENABLE - ErrorF ("Damage not on list\n"); - OsAbort (); + ErrorF("Damage not on list\n"); + OsAbort(); #endif } static void -damageInsertDamage (DamagePtr *pPrev, DamagePtr pDamage) +damageInsertDamage(DamagePtr * pPrev, DamagePtr pDamage) { #if DAMAGE_VALIDATE_ENABLE - DamagePtr pOld; + DamagePtr pOld; for (pOld = *pPrev; pOld; pOld = pOld->pNext) - if (pOld == pDamage) { - ErrorF ("Damage already on list\n"); - OsAbort (); - } + if (pOld == pDamage) { + ErrorF("Damage already on list\n"); + OsAbort(); + } #endif pDamage->pNext = *pPrev; *pPrev = pDamage; } static Bool -damageDestroyPixmap (PixmapPtr pPixmap) +damageDestroyPixmap(PixmapPtr pPixmap) { - ScreenPtr pScreen = pPixmap->drawable.pScreen; + ScreenPtr pScreen = pPixmap->drawable.pScreen; + damageScrPriv(pScreen); - if (pPixmap->refcnt == 1) - { - DamagePtr *pPrev = getPixmapDamageRef (pPixmap); - DamagePtr pDamage; - - while ((pDamage = *pPrev)) - { - damageRemoveDamage (pPrev, pDamage); - if (!pDamage->isWindow) - DamageDestroy (pDamage); - } + if (pPixmap->refcnt == 1) { + DamagePtr *pPrev = getPixmapDamageRef(pPixmap); + DamagePtr pDamage; + + while ((pDamage = *pPrev)) { + damageRemoveDamage(pPrev, pDamage); + if (!pDamage->isWindow) + DamageDestroy(pDamage); + } } - unwrap (pScrPriv, pScreen, DestroyPixmap); + unwrap(pScrPriv, pScreen, DestroyPixmap); (*pScreen->DestroyPixmap) (pPixmap); - wrap (pScrPriv, pScreen, DestroyPixmap, damageDestroyPixmap); + wrap(pScrPriv, pScreen, DestroyPixmap, damageDestroyPixmap); return TRUE; } static void -damageCopyWindow(WindowPtr pWindow, - DDXPointRec ptOldOrg, - RegionPtr prgnSrc) +damageCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc) { ScreenPtr pScreen = pWindow->drawable.pScreen; + damageScrPriv(pScreen); - if (getWindowDamage (pWindow)) - { - int dx = pWindow->drawable.x - ptOldOrg.x; - int dy = pWindow->drawable.y - ptOldOrg.y; - - /* - * The region comes in source relative, but the damage occurs - * at the destination location. Translate back and forth. - */ - RegionTranslate(prgnSrc, dx, dy); - damageRegionAppend (&pWindow->drawable, prgnSrc, FALSE, -1); - RegionTranslate(prgnSrc, -dx, -dy); + if (getWindowDamage(pWindow)) { + int dx = pWindow->drawable.x - ptOldOrg.x; + int dy = pWindow->drawable.y - ptOldOrg.y; + + /* + * The region comes in source relative, but the damage occurs + * at the destination location. Translate back and forth. + */ + RegionTranslate(prgnSrc, dx, dy); + damageRegionAppend(&pWindow->drawable, prgnSrc, FALSE, -1); + RegionTranslate(prgnSrc, -dx, -dy); } - unwrap (pScrPriv, pScreen, CopyWindow); + unwrap(pScrPriv, pScreen, CopyWindow); (*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc); - damageRegionProcessPending (&pWindow->drawable); - wrap (pScrPriv, pScreen, CopyWindow, damageCopyWindow); + damageRegionProcessPending(&pWindow->drawable); + wrap(pScrPriv, pScreen, CopyWindow, damageCopyWindow); } static GCOps damageGCOps = { @@ -1695,66 +1597,63 @@ static GCOps damageGCOps = { }; static void -damageSetWindowPixmap (WindowPtr pWindow, PixmapPtr pPixmap) +damageSetWindowPixmap(WindowPtr pWindow, PixmapPtr pPixmap) { - DamagePtr pDamage; - ScreenPtr pScreen = pWindow->drawable.pScreen; + DamagePtr pDamage; + ScreenPtr pScreen = pWindow->drawable.pScreen; + damageScrPriv(pScreen); - if ((pDamage = damageGetWinPriv(pWindow))) - { - PixmapPtr pOldPixmap = (*pScreen->GetWindowPixmap) (pWindow); - DamagePtr *pPrev = getPixmapDamageRef(pOldPixmap); - - while (pDamage) - { - damageRemoveDamage (pPrev, pDamage); - pDamage = pDamage->pNextWin; - } + if ((pDamage = damageGetWinPriv(pWindow))) { + PixmapPtr pOldPixmap = (*pScreen->GetWindowPixmap) (pWindow); + DamagePtr *pPrev = getPixmapDamageRef(pOldPixmap); + + while (pDamage) { + damageRemoveDamage(pPrev, pDamage); + pDamage = pDamage->pNextWin; + } } - unwrap (pScrPriv, pScreen, SetWindowPixmap); + unwrap(pScrPriv, pScreen, SetWindowPixmap); (*pScreen->SetWindowPixmap) (pWindow, pPixmap); - wrap (pScrPriv, pScreen, SetWindowPixmap, damageSetWindowPixmap); - if ((pDamage = damageGetWinPriv(pWindow))) - { - DamagePtr *pPrev = getPixmapDamageRef(pPixmap); - - while (pDamage) - { - damageInsertDamage (pPrev, pDamage); - pDamage = pDamage->pNextWin; - } + wrap(pScrPriv, pScreen, SetWindowPixmap, damageSetWindowPixmap); + if ((pDamage = damageGetWinPriv(pWindow))) { + DamagePtr *pPrev = getPixmapDamageRef(pPixmap); + + while (pDamage) { + damageInsertDamage(pPrev, pDamage); + pDamage = pDamage->pNextWin; + } } } static Bool -damageDestroyWindow (WindowPtr pWindow) +damageDestroyWindow(WindowPtr pWindow) { - DamagePtr pDamage; - ScreenPtr pScreen = pWindow->drawable.pScreen; - Bool ret; + DamagePtr pDamage; + ScreenPtr pScreen = pWindow->drawable.pScreen; + Bool ret; + damageScrPriv(pScreen); - while ((pDamage = damageGetWinPriv(pWindow))) - { - DamageUnregister (&pWindow->drawable, pDamage); - DamageDestroy (pDamage); + while ((pDamage = damageGetWinPriv(pWindow))) { + DamageUnregister(&pWindow->drawable, pDamage); + DamageDestroy(pDamage); } - unwrap (pScrPriv, pScreen, DestroyWindow); + unwrap(pScrPriv, pScreen, DestroyWindow); ret = (*pScreen->DestroyWindow) (pWindow); - wrap (pScrPriv, pScreen, DestroyWindow, damageDestroyWindow); + wrap(pScrPriv, pScreen, DestroyWindow, damageDestroyWindow); return ret; } static Bool -damageCloseScreen (int i, ScreenPtr pScreen) +damageCloseScreen(int i, ScreenPtr pScreen) { damageScrPriv(pScreen); - unwrap (pScrPriv, pScreen, DestroyPixmap); - unwrap (pScrPriv, pScreen, CreateGC); - unwrap (pScrPriv, pScreen, CopyWindow); - unwrap (pScrPriv, pScreen, CloseScreen); + unwrap(pScrPriv, pScreen, DestroyPixmap); + unwrap(pScrPriv, pScreen, CreateGC); + unwrap(pScrPriv, pScreen, CopyWindow); + unwrap(pScrPriv, pScreen, CloseScreen); free(pScrPriv); return (*pScreen->CloseScreen) (i, pScreen); } @@ -1762,19 +1661,23 @@ damageCloseScreen (int i, ScreenPtr pScreen) /** * Default implementations of the damage management functions. */ -void miDamageCreate (DamagePtr pDamage) +void +miDamageCreate(DamagePtr pDamage) { } -void miDamageRegister (DrawablePtr pDrawable, DamagePtr pDamage) +void +miDamageRegister(DrawablePtr pDrawable, DamagePtr pDamage) { } -void miDamageUnregister (DrawablePtr pDrawable, DamagePtr pDamage) +void +miDamageUnregister(DrawablePtr pDrawable, DamagePtr pDamage) { } -void miDamageDestroy (DamagePtr pDamage) +void +miDamageDestroy(DamagePtr pDamage) { } @@ -1783,46 +1686,48 @@ void miDamageDestroy (DamagePtr pDamage) */ Bool -DamageSetup (ScreenPtr pScreen) +DamageSetup(ScreenPtr pScreen) { - DamageScrPrivPtr pScrPriv; - PictureScreenPtr ps = GetPictureScreenIfSet(pScreen); + DamageScrPrivPtr pScrPriv; + PictureScreenPtr ps = GetPictureScreenIfSet(pScreen); + const DamageScreenFuncsRec miFuncs = { - miDamageCreate, miDamageRegister, miDamageUnregister, miDamageDestroy + miDamageCreate, miDamageRegister, miDamageUnregister, miDamageDestroy }; if (!dixRegisterPrivateKey(&damageScrPrivateKeyRec, PRIVATE_SCREEN, 0)) - return FALSE; + return FALSE; if (dixLookupPrivate(&pScreen->devPrivates, damageScrPrivateKey)) - return TRUE; + return TRUE; - if (!dixRegisterPrivateKey(&damageGCPrivateKeyRec, PRIVATE_GC, sizeof(DamageGCPrivRec))) - return FALSE; + if (!dixRegisterPrivateKey + (&damageGCPrivateKeyRec, PRIVATE_GC, sizeof(DamageGCPrivRec))) + return FALSE; if (!dixRegisterPrivateKey(&damagePixPrivateKeyRec, PRIVATE_PIXMAP, 0)) - return FALSE; + return FALSE; if (!dixRegisterPrivateKey(&damageWinPrivateKeyRec, PRIVATE_WINDOW, 0)) - return FALSE; + return FALSE; - pScrPriv = malloc(sizeof (DamageScrPrivRec)); + pScrPriv = malloc(sizeof(DamageScrPrivRec)); if (!pScrPriv) - return FALSE; + return FALSE; pScrPriv->internalLevel = 0; pScrPriv->pScreenDamage = 0; - wrap (pScrPriv, pScreen, DestroyPixmap, damageDestroyPixmap); - wrap (pScrPriv, pScreen, CreateGC, damageCreateGC); - wrap (pScrPriv, pScreen, DestroyWindow, damageDestroyWindow); - wrap (pScrPriv, pScreen, SetWindowPixmap, damageSetWindowPixmap); - wrap (pScrPriv, pScreen, CopyWindow, damageCopyWindow); - wrap (pScrPriv, pScreen, CloseScreen, damageCloseScreen); + wrap(pScrPriv, pScreen, DestroyPixmap, damageDestroyPixmap); + wrap(pScrPriv, pScreen, CreateGC, damageCreateGC); + wrap(pScrPriv, pScreen, DestroyWindow, damageDestroyWindow); + wrap(pScrPriv, pScreen, SetWindowPixmap, damageSetWindowPixmap); + wrap(pScrPriv, pScreen, CopyWindow, damageCopyWindow); + wrap(pScrPriv, pScreen, CloseScreen, damageCloseScreen); if (ps) { - wrap (pScrPriv, ps, Glyphs, damageGlyphs); - wrap (pScrPriv, ps, Composite, damageComposite); - wrap (pScrPriv, ps, AddTraps, damageAddTraps); + wrap(pScrPriv, ps, Glyphs, damageGlyphs); + wrap(pScrPriv, ps, Composite, damageComposite); + wrap(pScrPriv, ps, AddTraps, damageAddTraps); } pScrPriv->funcs = miFuncs; @@ -1832,24 +1737,22 @@ DamageSetup (ScreenPtr pScreen) } DamagePtr -DamageCreate (DamageReportFunc damageReport, - DamageDestroyFunc damageDestroy, - DamageReportLevel damageLevel, - Bool isInternal, - ScreenPtr pScreen, - void *closure) +DamageCreate(DamageReportFunc damageReport, + DamageDestroyFunc damageDestroy, + DamageReportLevel damageLevel, + Bool isInternal, ScreenPtr pScreen, void *closure) { damageScrPriv(pScreen); - DamagePtr pDamage; + DamagePtr pDamage; pDamage = dixAllocateObjectWithPrivates(DamageRec, PRIVATE_DAMAGE); if (!pDamage) - return 0; + return 0; pDamage->pNext = 0; pDamage->pNextWin = 0; RegionNull(&pDamage->damage); RegionNull(&pDamage->pendingDamage); - + pDamage->damageLevel = damageLevel; pDamage->isInternal = isInternal; pDamage->closure = closure; @@ -1869,101 +1772,99 @@ DamageCreate (DamageReportFunc damageReport, } void -DamageRegister (DrawablePtr pDrawable, - DamagePtr pDamage) +DamageRegister(DrawablePtr pDrawable, DamagePtr pDamage) { ScreenPtr pScreen = pDrawable->pScreen; + damageScrPriv(pScreen); #if DAMAGE_VALIDATE_ENABLE - if (pDrawable->pScreen != pDamage->pScreen) - { - ErrorF ("DamageRegister called with mismatched screens\n"); - OsAbort (); + if (pDrawable->pScreen != pDamage->pScreen) { + ErrorF("DamageRegister called with mismatched screens\n"); + OsAbort(); } #endif - if (pDrawable->type == DRAWABLE_WINDOW) - { - WindowPtr pWindow = (WindowPtr) pDrawable; - winDamageRef(pWindow); + if (pDrawable->type == DRAWABLE_WINDOW) { + WindowPtr pWindow = (WindowPtr) pDrawable; + + winDamageRef(pWindow); #if DAMAGE_VALIDATE_ENABLE - DamagePtr pOld; - - for (pOld = *pPrev; pOld; pOld = pOld->pNextWin) - if (pOld == pDamage) { - ErrorF ("Damage already on window list\n"); - OsAbort (); - } + DamagePtr pOld; + + for (pOld = *pPrev; pOld; pOld = pOld->pNextWin) + if (pOld == pDamage) { + ErrorF("Damage already on window list\n"); + OsAbort(); + } #endif - pDamage->pNextWin = *pPrev; - *pPrev = pDamage; - pDamage->isWindow = TRUE; + pDamage->pNextWin = *pPrev; + *pPrev = pDamage; + pDamage->isWindow = TRUE; } else - pDamage->isWindow = FALSE; + pDamage->isWindow = FALSE; pDamage->pDrawable = pDrawable; - damageInsertDamage (getDrawableDamageRef (pDrawable), pDamage); + damageInsertDamage(getDrawableDamageRef(pDrawable), pDamage); (*pScrPriv->funcs.Register) (pDrawable, pDamage); } void -DamageDrawInternal (ScreenPtr pScreen, Bool enable) +DamageDrawInternal(ScreenPtr pScreen, Bool enable) { - damageScrPriv (pScreen); + damageScrPriv(pScreen); pScrPriv->internalLevel += enable ? 1 : -1; } void -DamageUnregister (DrawablePtr pDrawable, - DamagePtr pDamage) +DamageUnregister(DrawablePtr pDrawable, DamagePtr pDamage) { ScreenPtr pScreen = pDrawable->pScreen; + damageScrPriv(pScreen); (*pScrPriv->funcs.Unregister) (pDrawable, pDamage); - if (pDrawable->type == DRAWABLE_WINDOW) - { - WindowPtr pWindow = (WindowPtr) pDrawable; - winDamageRef (pWindow); + if (pDrawable->type == DRAWABLE_WINDOW) { + WindowPtr pWindow = (WindowPtr) pDrawable; + + winDamageRef(pWindow); #if DAMAGE_VALIDATE_ENABLE - int found = 0; + int found = 0; #endif - while (*pPrev) - { - if (*pPrev == pDamage) - { - *pPrev = pDamage->pNextWin; + while (*pPrev) { + if (*pPrev == pDamage) { + *pPrev = pDamage->pNextWin; #if DAMAGE_VALIDATE_ENABLE - found = 1; + found = 1; #endif - break; - } - pPrev = &(*pPrev)->pNextWin; - } + break; + } + pPrev = &(*pPrev)->pNextWin; + } #if DAMAGE_VALIDATE_ENABLE - if (!found) { - ErrorF ("Damage not on window list\n"); - OsAbort (); - } + if (!found) { + ErrorF("Damage not on window list\n"); + OsAbort(); + } #endif } pDamage->pDrawable = 0; - damageRemoveDamage (getDrawableDamageRef (pDrawable), pDamage); + damageRemoveDamage(getDrawableDamageRef(pDrawable), pDamage); } void -DamageDestroy (DamagePtr pDamage) +DamageDestroy(DamagePtr pDamage) { ScreenPtr pScreen = pDamage->pScreen; + damageScrPriv(pScreen); if (pDamage->damageDestroy) - (*pDamage->damageDestroy) (pDamage, pDamage->closure); + (*pDamage->damageDestroy) (pDamage, pDamage->closure); (*pScrPriv->funcs.Destroy) (pDamage); RegionUninit(&pDamage->damage); RegionUninit(&pDamage->pendingDamage); @@ -1971,115 +1872,113 @@ DamageDestroy (DamagePtr pDamage) } Bool -DamageSubtract (DamagePtr pDamage, - const RegionPtr pRegion) +DamageSubtract(DamagePtr pDamage, const RegionPtr pRegion) { - RegionPtr pClip; - RegionRec pixmapClip; - DrawablePtr pDrawable = pDamage->pDrawable; - + RegionPtr pClip; + RegionRec pixmapClip; + DrawablePtr pDrawable = pDamage->pDrawable; + RegionSubtract(&pDamage->damage, &pDamage->damage, pRegion); - if (pDrawable) - { - if (pDrawable->type == DRAWABLE_WINDOW) - pClip = &((WindowPtr) pDrawable)->borderClip; - else - { - BoxRec box; - - box.x1 = pDrawable->x; - box.y1 = pDrawable->y; - box.x2 = pDrawable->x + pDrawable->width; - box.y2 = pDrawable->y + pDrawable->height; - RegionInit(&pixmapClip, &box, 1); - pClip = &pixmapClip; - } - RegionTranslate(&pDamage->damage, pDrawable->x, pDrawable->y); - RegionIntersect(&pDamage->damage, &pDamage->damage, pClip); - RegionTranslate(&pDamage->damage, -pDrawable->x, -pDrawable->y); - if (pDrawable->type != DRAWABLE_WINDOW) - RegionUninit(&pixmapClip); + if (pDrawable) { + if (pDrawable->type == DRAWABLE_WINDOW) + pClip = &((WindowPtr) pDrawable)->borderClip; + else { + BoxRec box; + + box.x1 = pDrawable->x; + box.y1 = pDrawable->y; + box.x2 = pDrawable->x + pDrawable->width; + box.y2 = pDrawable->y + pDrawable->height; + RegionInit(&pixmapClip, &box, 1); + pClip = &pixmapClip; + } + RegionTranslate(&pDamage->damage, pDrawable->x, pDrawable->y); + RegionIntersect(&pDamage->damage, &pDamage->damage, pClip); + RegionTranslate(&pDamage->damage, -pDrawable->x, -pDrawable->y); + if (pDrawable->type != DRAWABLE_WINDOW) + RegionUninit(&pixmapClip); } return RegionNotEmpty(&pDamage->damage); } void -DamageEmpty (DamagePtr pDamage) +DamageEmpty(DamagePtr pDamage) { RegionEmpty(&pDamage->damage); } RegionPtr -DamageRegion (DamagePtr pDamage) +DamageRegion(DamagePtr pDamage) { return &pDamage->damage; } RegionPtr -DamagePendingRegion (DamagePtr pDamage) +DamagePendingRegion(DamagePtr pDamage) { return &pDamage->pendingDamage; } void -DamageRegionAppend (DrawablePtr pDrawable, RegionPtr pRegion) +DamageRegionAppend(DrawablePtr pDrawable, RegionPtr pRegion) { - damageRegionAppend (pDrawable, pRegion, FALSE, -1); + damageRegionAppend(pDrawable, pRegion, FALSE, -1); } void -DamageRegionProcessPending (DrawablePtr pDrawable) +DamageRegionProcessPending(DrawablePtr pDrawable) { - damageRegionProcessPending (pDrawable); + damageRegionProcessPending(pDrawable); } /* If a damage marker is provided, then this function must be called after rendering is done. */ /* Please do call back so any future enhancements can assume this function is called. */ /* There are no strict timing requirements for calling this function, just as soon as (is cheaply) possible. */ void -DamageRegionRendered (DrawablePtr pDrawable, DamagePtr pDamage, RegionPtr pOldDamage, RegionPtr pRegion) +DamageRegionRendered(DrawablePtr pDrawable, DamagePtr pDamage, + RegionPtr pOldDamage, RegionPtr pRegion) { if (pDamage->damageReportPostRendering) - damageReportDamagePostRendering (pDamage, pOldDamage, pRegion); + damageReportDamagePostRendering(pDamage, pOldDamage, pRegion); } /* This call is very odd, i'm leaving it intact for API sake, but please don't use it. */ void -DamageDamageRegion (DrawablePtr pDrawable, - RegionPtr pRegion) +DamageDamageRegion(DrawablePtr pDrawable, RegionPtr pRegion) { - damageRegionAppend (pDrawable, pRegion, FALSE, -1); + damageRegionAppend(pDrawable, pRegion, FALSE, -1); /* Go back and report this damage for DamagePtrs with reportAfter set, since * this call isn't part of an in-progress drawing op in the call chain and * the DDX probably just wants to know about it right away. */ - damageRegionProcessPending (pDrawable); + damageRegionProcessPending(pDrawable); } void -DamageSetReportAfterOp (DamagePtr pDamage, Bool reportAfter) +DamageSetReportAfterOp(DamagePtr pDamage, Bool reportAfter) { pDamage->reportAfter = reportAfter; } void -DamageSetPostRenderingFunctions(DamagePtr pDamage, DamageReportFunc damageReportPostRendering, - DamageMarkerFunc damageMarker) +DamageSetPostRenderingFunctions(DamagePtr pDamage, + DamageReportFunc damageReportPostRendering, + DamageMarkerFunc damageMarker) { pDamage->damageReportPostRendering = damageReportPostRendering; pDamage->damageMarker = damageMarker; } DamageScreenFuncsPtr -DamageGetScreenFuncs (ScreenPtr pScreen) +DamageGetScreenFuncs(ScreenPtr pScreen) { damageScrPriv(pScreen); return &pScrPriv->funcs; } void -DamageReportDamage (DamagePtr pDamage, RegionPtr pDamageRegion) +DamageReportDamage(DamagePtr pDamage, RegionPtr pDamageRegion) { BoxRec tmpBox; RegionRec tmpRegion; @@ -2087,42 +1986,36 @@ DamageReportDamage (DamagePtr pDamage, RegionPtr pDamageRegion) switch (pDamage->damageLevel) { case DamageReportRawRegion: - RegionUnion(&pDamage->damage, &pDamage->damage, - pDamageRegion); - (*pDamage->damageReport) (pDamage, pDamageRegion, pDamage->closure); - break; + RegionUnion(&pDamage->damage, &pDamage->damage, pDamageRegion); + (*pDamage->damageReport) (pDamage, pDamageRegion, pDamage->closure); + break; case DamageReportDeltaRegion: - RegionNull(&tmpRegion); - RegionSubtract(&tmpRegion, pDamageRegion, &pDamage->damage); - if (RegionNotEmpty(&tmpRegion)) { - RegionUnion(&pDamage->damage, &pDamage->damage, - pDamageRegion); - (*pDamage->damageReport) (pDamage, &tmpRegion, pDamage->closure); - } - RegionUninit(&tmpRegion); - break; + RegionNull(&tmpRegion); + RegionSubtract(&tmpRegion, pDamageRegion, &pDamage->damage); + if (RegionNotEmpty(&tmpRegion)) { + RegionUnion(&pDamage->damage, &pDamage->damage, pDamageRegion); + (*pDamage->damageReport) (pDamage, &tmpRegion, pDamage->closure); + } + RegionUninit(&tmpRegion); + break; case DamageReportBoundingBox: - tmpBox = *RegionExtents(&pDamage->damage); - RegionUnion(&pDamage->damage, &pDamage->damage, - pDamageRegion); - if (!BOX_SAME (&tmpBox, RegionExtents(&pDamage->damage))) { - (*pDamage->damageReport) (pDamage, &pDamage->damage, - pDamage->closure); - } - break; + tmpBox = *RegionExtents(&pDamage->damage); + RegionUnion(&pDamage->damage, &pDamage->damage, pDamageRegion); + if (!BOX_SAME(&tmpBox, RegionExtents(&pDamage->damage))) { + (*pDamage->damageReport) (pDamage, &pDamage->damage, + pDamage->closure); + } + break; case DamageReportNonEmpty: - was_empty = !RegionNotEmpty(&pDamage->damage); - RegionUnion(&pDamage->damage, &pDamage->damage, - pDamageRegion); - if (was_empty && RegionNotEmpty(&pDamage->damage)) { - (*pDamage->damageReport) (pDamage, &pDamage->damage, - pDamage->closure); - } - break; + was_empty = !RegionNotEmpty(&pDamage->damage); + RegionUnion(&pDamage->damage, &pDamage->damage, pDamageRegion); + if (was_empty && RegionNotEmpty(&pDamage->damage)) { + (*pDamage->damageReport) (pDamage, &pDamage->damage, + pDamage->closure); + } + break; case DamageReportNone: - RegionUnion(&pDamage->damage, &pDamage->damage, - pDamageRegion); - break; + RegionUnion(&pDamage->damage, &pDamage->damage, pDamageRegion); + break; } } - diff --git a/miext/damage/damage.h b/miext/damage/damage.h index 0c7fc316c..c2c313a15 100644 --- a/miext/damage/damage.h +++ b/miext/damage/damage.h @@ -27,7 +27,7 @@ #ifndef _DAMAGE_H_ #define _DAMAGE_H_ -typedef struct _damage *DamagePtr; +typedef struct _damage *DamagePtr; typedef enum _damageReportLevel { DamageReportRawRegion, @@ -37,11 +37,15 @@ typedef enum _damageReportLevel { DamageReportNone } DamageReportLevel; -typedef void (*DamageReportFunc) (DamagePtr pDamage, RegionPtr pRegion, void *closure); +typedef void (*DamageReportFunc) (DamagePtr pDamage, RegionPtr pRegion, + void *closure); typedef void (*DamageDestroyFunc) (DamagePtr pDamage, void *closure); + /* It's the responsibility of the driver to duplicate both regions. */ /* At some point DamageRegionRendered() must be called. */ -typedef void (*DamageMarkerFunc) (DrawablePtr pDrawable, DamagePtr pDamage, RegionPtr pOldDamage, RegionPtr pRegion, void *closure); +typedef void (*DamageMarkerFunc) (DrawablePtr pDrawable, DamagePtr pDamage, + RegionPtr pOldDamage, RegionPtr pRegion, + void *closure); typedef void (*DamageScreenCreateFunc) (DamagePtr); typedef void (*DamageScreenRegisterFunc) (DrawablePtr, DamagePtr); @@ -49,84 +53,81 @@ typedef void (*DamageScreenUnregisterFunc) (DrawablePtr, DamagePtr); typedef void (*DamageScreenDestroyFunc) (DamagePtr); typedef struct _damageScreenFuncs { - DamageScreenCreateFunc Create; - DamageScreenRegisterFunc Register; - DamageScreenUnregisterFunc Unregister; - DamageScreenDestroyFunc Destroy; + DamageScreenCreateFunc Create; + DamageScreenRegisterFunc Register; + DamageScreenUnregisterFunc Unregister; + DamageScreenDestroyFunc Destroy; } DamageScreenFuncsRec, *DamageScreenFuncsPtr; -extern _X_EXPORT void miDamageCreate (DamagePtr); -extern _X_EXPORT void miDamageRegister (DrawablePtr, DamagePtr); -extern _X_EXPORT void miDamageUnregister (DrawablePtr, DamagePtr); -extern _X_EXPORT void miDamageDestroy (DamagePtr); +extern _X_EXPORT void miDamageCreate(DamagePtr); +extern _X_EXPORT void miDamageRegister(DrawablePtr, DamagePtr); +extern _X_EXPORT void miDamageUnregister(DrawablePtr, DamagePtr); +extern _X_EXPORT void miDamageDestroy(DamagePtr); extern _X_EXPORT Bool -DamageSetup (ScreenPtr pScreen); - + DamageSetup(ScreenPtr pScreen); + extern _X_EXPORT DamagePtr -DamageCreate (DamageReportFunc damageReport, - DamageDestroyFunc damageDestroy, - DamageReportLevel damageLevel, - Bool isInternal, - ScreenPtr pScreen, - void * closure); +DamageCreate(DamageReportFunc damageReport, + DamageDestroyFunc damageDestroy, + DamageReportLevel damageLevel, + Bool isInternal, ScreenPtr pScreen, void *closure); extern _X_EXPORT void -DamageDrawInternal (ScreenPtr pScreen, Bool enable); + DamageDrawInternal(ScreenPtr pScreen, Bool enable); extern _X_EXPORT void -DamageRegister (DrawablePtr pDrawable, - DamagePtr pDamage); + DamageRegister(DrawablePtr pDrawable, DamagePtr pDamage); extern _X_EXPORT void -DamageUnregister (DrawablePtr pDrawable, - DamagePtr pDamage); + DamageUnregister(DrawablePtr pDrawable, DamagePtr pDamage); extern _X_EXPORT void -DamageDestroy (DamagePtr pDamage); + DamageDestroy(DamagePtr pDamage); extern _X_EXPORT Bool -DamageSubtract (DamagePtr pDamage, - const RegionPtr pRegion); + DamageSubtract(DamagePtr pDamage, const RegionPtr pRegion); extern _X_EXPORT void -DamageEmpty (DamagePtr pDamage); + DamageEmpty(DamagePtr pDamage); extern _X_EXPORT RegionPtr -DamageRegion (DamagePtr pDamage); + DamageRegion(DamagePtr pDamage); extern _X_EXPORT RegionPtr -DamagePendingRegion (DamagePtr pDamage); + DamagePendingRegion(DamagePtr pDamage); /* In case of rendering, call this before the submitting the commands. */ extern _X_EXPORT void -DamageRegionAppend (DrawablePtr pDrawable, RegionPtr pRegion); + DamageRegionAppend(DrawablePtr pDrawable, RegionPtr pRegion); /* Call this directly after the rendering operation has been submitted. */ extern _X_EXPORT void -DamageRegionProcessPending (DrawablePtr pDrawable); + DamageRegionProcessPending(DrawablePtr pDrawable); /* Call this some time after rendering is done, only relevant when a damageMarker is provided. */ extern _X_EXPORT void -DamageRegionRendered (DrawablePtr pDrawable, DamagePtr pDamage, RegionPtr pOldDamage, RegionPtr pRegion); + +DamageRegionRendered(DrawablePtr pDrawable, DamagePtr pDamage, + RegionPtr pOldDamage, RegionPtr pRegion); /* Call this when you create a new Damage and you wish to send an initial damage message (to it). */ extern _X_EXPORT void -DamageReportDamage (DamagePtr pDamage, RegionPtr pDamageRegion); + DamageReportDamage(DamagePtr pDamage, RegionPtr pDamageRegion); /* Avoid using this call, it only exists for API compatibility. */ extern _X_EXPORT void -DamageDamageRegion (DrawablePtr pDrawable, - const RegionPtr pRegion); + DamageDamageRegion(DrawablePtr pDrawable, const RegionPtr pRegion); extern _X_EXPORT void -DamageSetReportAfterOp (DamagePtr pDamage, Bool reportAfter); + DamageSetReportAfterOp(DamagePtr pDamage, Bool reportAfter); extern _X_EXPORT void -DamageSetPostRenderingFunctions(DamagePtr pDamage, DamageReportFunc damageReportPostRendering, - DamageMarkerFunc damageMarker); -extern _X_EXPORT DamageScreenFuncsPtr -DamageGetScreenFuncs (ScreenPtr); +DamageSetPostRenderingFunctions(DamagePtr pDamage, + DamageReportFunc damageReportPostRendering, + DamageMarkerFunc damageMarker); + +extern _X_EXPORT DamageScreenFuncsPtr DamageGetScreenFuncs(ScreenPtr); -#endif /* _DAMAGE_H_ */ +#endif /* _DAMAGE_H_ */ diff --git a/miext/damage/damagestr.h b/miext/damage/damagestr.h index b224958d1..89189905e 100644 --- a/miext/damage/damagestr.h +++ b/miext/damage/damagestr.h @@ -30,56 +30,56 @@ #include "damage.h" #include "gcstruct.h" #include "privates.h" -# include "picturestr.h" +#include "picturestr.h" typedef struct _damage { - DamagePtr pNext; - DamagePtr pNextWin; - RegionRec damage; - - DamageReportLevel damageLevel; - Bool isInternal; - void *closure; - Bool isWindow; - DrawablePtr pDrawable; - - DamageReportFunc damageReport; - DamageReportFunc damageReportPostRendering; - DamageDestroyFunc damageDestroy; - DamageMarkerFunc damageMarker; - - Bool reportAfter; - RegionRec pendingDamage; /* will be flushed post submission at the latest */ - RegionRec backupDamage; /* for use with damageMarker */ - ScreenPtr pScreen; - PrivateRec *devPrivates; + DamagePtr pNext; + DamagePtr pNextWin; + RegionRec damage; + + DamageReportLevel damageLevel; + Bool isInternal; + void *closure; + Bool isWindow; + DrawablePtr pDrawable; + + DamageReportFunc damageReport; + DamageReportFunc damageReportPostRendering; + DamageDestroyFunc damageDestroy; + DamageMarkerFunc damageMarker; + + Bool reportAfter; + RegionRec pendingDamage; /* will be flushed post submission at the latest */ + RegionRec backupDamage; /* for use with damageMarker */ + ScreenPtr pScreen; + PrivateRec *devPrivates; } DamageRec; typedef struct _damageScrPriv { - int internalLevel; + int internalLevel; /* * For DDXen which don't provide GetScreenPixmap, this provides * a place to hook damage for windows on the screen */ - DamagePtr pScreenDamage; - - CopyWindowProcPtr CopyWindow; - CloseScreenProcPtr CloseScreen; - CreateGCProcPtr CreateGC; - DestroyPixmapProcPtr DestroyPixmap; - SetWindowPixmapProcPtr SetWindowPixmap; - DestroyWindowProcPtr DestroyWindow; - CompositeProcPtr Composite; - GlyphsProcPtr Glyphs; - AddTrapsProcPtr AddTraps; + DamagePtr pScreenDamage; + + CopyWindowProcPtr CopyWindow; + CloseScreenProcPtr CloseScreen; + CreateGCProcPtr CreateGC; + DestroyPixmapProcPtr DestroyPixmap; + SetWindowPixmapProcPtr SetWindowPixmap; + DestroyWindowProcPtr DestroyWindow; + CompositeProcPtr Composite; + GlyphsProcPtr Glyphs; + AddTrapsProcPtr AddTraps; /* Table of wrappable function pointers */ - DamageScreenFuncsRec funcs; + DamageScreenFuncsRec funcs; } DamageScrPrivRec, *DamageScrPrivPtr; typedef struct _damageGCPriv { - GCOps *ops; + GCOps *ops; GCFuncs *funcs; } DamageGCPrivRec, *DamageGCPrivPtr; @@ -111,4 +111,4 @@ typedef struct _damageGCPriv { #define damageSetWinPriv(pWin,d) \ dixSetPrivate(&(pWin)->devPrivates, damageWinPrivateKey, d) -#endif /* _DAMAGESTR_H_ */ +#endif /* _DAMAGESTR_H_ */ |