summaryrefslogtreecommitdiff
path: root/miext/damage
diff options
context:
space:
mode:
authorKeith Packard <keithp@keithp.com>2012-03-21 12:55:09 -0700
committerKeith Packard <keithp@keithp.com>2012-03-21 13:54:42 -0700
commit9838b7032ea9792bec21af424c53c07078636d21 (patch)
treeb72d0827dac50f0f3b8eab29b3b7639546d735d7 /miext/damage
parent75199129c603fc8567185ac31866c9518193cb78 (diff)
Introduce a consistent coding style
This is strictly the application of the script 'x-indent-all.sh' from util/modular. Compared to the patch that Daniel posted in January, I've added a few indent flags: -bap -psl -T PrivatePtr -T pmWait -T _XFUNCPROTOBEGIN -T _XFUNCPROTOEND -T _X_EXPORT The typedefs were needed to make the output of sdksyms.sh match the previous output, otherwise, the code is formatted badly enough that sdksyms.sh generates incorrect output. The generated code was compared with the previous version and found to be essentially identical -- "assert" line numbers and BUILD_TIME were the only differences found. The comparison was done with this script: dir1=$1 dir2=$2 for dir in $dir1 $dir2; do (cd $dir && find . -name '*.o' | while read file; do dir=`dirname $file` base=`basename $file .o` dump=$dir/$base.dump objdump -d $file > $dump done) done find $dir1 -name '*.dump' | while read dump; do otherdump=`echo $dump | sed "s;$dir1;$dir2;"` diff -u $dump $otherdump done Signed-off-by: Keith Packard <keithp@keithp.com> Acked-by: Daniel Stone <daniel@fooishbar.org> Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
Diffstat (limited to 'miext/damage')
-rw-r--r--miext/damage/damage.c2479
-rw-r--r--miext/damage/damage.h85
-rw-r--r--miext/damage/damagestr.h72
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(&region, pBox, 1);
#if DAMAGE_DEBUG_ENABLE
- _damageRegionAppend (pDrawable, &region, TRUE, subWindowMode, where);
+ _damageRegionAppend(pDrawable, &region, TRUE, subWindowMode, where);
#else
- damageRegionAppend (pDrawable, &region, TRUE, subWindowMode);
+ damageRegionAppend(pDrawable, &region, TRUE, subWindowMode);
#endif
RegionUninit(&region);
}
@@ -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_ */