qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
41a86560b4
xenocara/xserver/miext/damage/damage.c
matthieu 61a7d5427d Update to xserver 1.11.2
2011-11-05 13:32:40 +00:00

2129 lines
53 KiB
C
Raw Blame History

/*
* Copyright © 2003 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include "scrnintstr.h"
#include "windowstr.h"
#include <X11/fonts/font.h>
#include "dixfontstr.h"
#include <X11/fonts/fontstruct.h>
#include "mi.h"
#include "regionstr.h"
#include "globals.h"
#include "gcstruct.h"
#include "damage.h"
#include "damagestr.h"
#ifdef COMPOSITE
#include "cw.h"
#endif
#define wrap(priv, real, mem, func) {\
priv->mem = real->mem; \
real->mem = func; \
}
#define unwrap(priv, real, mem) {\
real->mem = priv->mem; \
}
#define BOX_SAME(a,b) \
((a)->x1 == (b)->x1 && \
(a)->y1 == (b)->y1 && \
(a)->x2 == (b)->x2 && \
(a)->y2 == (b)->y2)
#define DAMAGE_VALIDATE_ENABLE 0
#define DAMAGE_DEBUG_ENABLE 0
#if DAMAGE_DEBUG_ENABLE
#define DAMAGE_DEBUG(x) ErrorF x
#else
#define DAMAGE_DEBUG(x)
#endif
#define getPixmapDamageRef(pPixmap) ((DamagePtr *) \
dixLookupPrivateAddr(&(pPixmap)->devPrivates, damagePixPrivateKey))
#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)
{
PixmapPtr pPixmap;
if (WindowDrawable(pDrawable->type))
{
ScreenPtr pScreen = pDrawable->pScreen;
pPixmap = 0;
if (pScreen->GetWindowPixmap
#ifdef ROOTLESS_WORKAROUND
&& ((WindowPtr)pDrawable)->viewable
#endif
)
pPixmap = (*pScreen->GetWindowPixmap) ((WindowPtr)pDrawable);
if (!pPixmap)
{
damageScrPriv(pScreen);
return &pScrPriv->pScreenDamage;
}
}
else
pPixmap = (PixmapPtr) pDrawable;
return getPixmapDamageRef (pPixmap);
}
#define getDrawableDamage(pDrawable) (*getDrawableDamageRef (pDrawable))
#define getWindowDamage(pWin) getDrawableDamage(&(pWin)->drawable)
#define drawableDamage(pDrawable) \
DamagePtr pDamage = getDrawableDamage(pDrawable)
#define windowDamage(pWin) drawableDamage(&(pWin)->drawable)
#define winDamageRef(pWindow) \
DamagePtr *pPrev = (DamagePtr *) \
dixLookupPrivateAddr(&(pWindow)->devPrivates, damageWinPrivateKey)
static void
damageReportDamagePostRendering (DamagePtr pDamage, RegionPtr pOldDamage, RegionPtr pDamageRegion)
{
BoxRec tmpBox;
RegionRec tmpRegion, newDamage;
Bool was_empty;
RegionUnion(&newDamage, pOldDamage, pDamageRegion);
switch (pDamage->damageLevel) {
case DamageReportRawRegion:
(*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;
case DamageReportBoundingBox:
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;
case DamageReportNone:
break;
}
RegionUninit(&newDamage);
}
#if DAMAGE_DEBUG_ENABLE
static void
_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)
#endif
{
ScreenPtr pScreen = pDrawable->pScreen;
damageScrPriv(pScreen);
drawableDamage(pDrawable);
DamagePtr pNext;
RegionRec clippedRec;
RegionPtr pDamageRegion;
RegionRec pixClip;
int draw_x, draw_y;
#ifdef COMPOSITE
int screen_x = 0, screen_y = 0;
#endif
/* short circuit for empty regions */
if (!RegionNotEmpty(pRegion))
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 (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. */
}
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;
#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;
}
#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);
}
#ifdef COMPOSITE
if (screen_x || screen_y)
RegionTranslate(pRegion, -screen_x, -screen_y);
#endif
RegionUninit(&clippedRec);
}
static void
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);
}
}
#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)
#else
static void
damageDamageBox (DrawablePtr pDrawable, BoxPtr pBox, int subWindowMode)
#endif
{
RegionRec region;
RegionInit(&region, pBox, 1);
#if DAMAGE_DEBUG_ENABLE
_damageRegionAppend (pDrawable, &region, TRUE, subWindowMode, where);
#else
damageRegionAppend (pDrawable, &region, TRUE, subWindowMode);
#endif
RegionUninit(&region);
}
static void damageValidateGC(GCPtr, unsigned long, DrawablePtr);
static void damageChangeGC(GCPtr, unsigned long);
static void damageCopyGC(GCPtr, unsigned long, GCPtr);
static void damageDestroyGC(GCPtr);
static void damageChangeClip(GCPtr, int, pointer, int);
static void damageDestroyClip(GCPtr);
static void damageCopyClip(GCPtr, GCPtr);
static GCFuncs damageGCFuncs = {
damageValidateGC, damageChangeGC, damageCopyGC, damageDestroyGC,
damageChangeClip, damageDestroyClip, damageCopyClip
};
static GCOps damageGCOps;
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;
}
wrap (pScrPriv, pScreen, CreateGC, damageCreateGC);
return ret;
}
#define DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable) \
damageGCPriv(pGC); \
GCFuncs *oldFuncs = pGC->funcs; \
unwrap(pGCPriv, pGC, funcs); \
unwrap(pGCPriv, pGC, ops); \
#define DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable) \
wrap(pGCPriv, pGC, funcs, oldFuncs); \
wrap(pGCPriv, pGC, ops, &damageGCOps)
#define DAMAGE_GC_FUNC_PROLOGUE(pGC) \
damageGCPriv(pGC); \
unwrap(pGCPriv, pGC, funcs); \
if (pGCPriv->ops) unwrap(pGCPriv, pGC, ops)
#define DAMAGE_GC_FUNC_EPILOGUE(pGC) \
wrap(pGCPriv, pGC, funcs, &damageGCFuncs); \
if (pGCPriv->ops) wrap(pGCPriv, pGC, ops, &damageGCOps)
static void
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);
}
static void
damageDestroyGC(GCPtr pGC)
{
DAMAGE_GC_FUNC_PROLOGUE (pGC);
(*pGC->funcs->DestroyGC)(pGC);
DAMAGE_GC_FUNC_EPILOGUE (pGC);
}
static void
damageChangeGC (GCPtr pGC,
unsigned long mask)
{
DAMAGE_GC_FUNC_PROLOGUE (pGC);
(*pGC->funcs->ChangeGC) (pGC, mask);
DAMAGE_GC_FUNC_EPILOGUE (pGC);
}
static void
damageCopyGC (GCPtr pGCSrc,
unsigned long mask,
GCPtr pGCDst)
{
DAMAGE_GC_FUNC_PROLOGUE (pGCDst);
(*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
DAMAGE_GC_FUNC_EPILOGUE (pGCDst);
}
static void
damageChangeClip (GCPtr pGC,
int type,
pointer pvalue,
int nrects)
{
DAMAGE_GC_FUNC_PROLOGUE (pGC);
(*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
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);
}
static void
damageDestroyClip(GCPtr pGC)
{
DAMAGE_GC_FUNC_PROLOGUE (pGC);
(* pGC->funcs->DestroyClip)(pGC);
DAMAGE_GC_FUNC_EPILOGUE (pGC);
}
#define TRIM_BOX(box, pGC) if (pGC->pCompositeClip) { \
BoxPtr extents = &pGC->pCompositeClip->extents;\
if(box.x1 < extents->x1) box.x1 = extents->x1; \
if(box.x2 > extents->x2) box.x2 = extents->x2; \
if(box.y1 < extents->y1) box.y1 = extents->y1; \
if(box.y2 > extents->y2) box.y2 = extents->y2; \
}
#define TRANSLATE_BOX(box, pDrawable) { \
box.x1 += pDrawable->x; \
box.x2 += pDrawable->x; \
box.y1 += pDrawable->y; \
box.y2 += pDrawable->y; \
}
#define TRIM_AND_TRANSLATE_BOX(box, pDrawable, pGC) { \
TRANSLATE_BOX(box, pDrawable); \
TRIM_BOX(box, pGC); \
}
#define BOX_NOT_EMPTY(box) \
(((box.x2 - box.x1) > 0) && ((box.y2 - box.y1) > 0))
#define checkGCDamage(d,g) (getDrawableDamage(d) && \
(!g->pCompositeClip ||\
RegionNotEmpty(g->pCompositeClip)))
#define TRIM_PICTURE_BOX(box, pDst) { \
BoxPtr extents = &pDst->pCompositeClip->extents;\
if(box.x1 < extents->x1) box.x1 = extents->x1; \
if(box.x2 > extents->x2) box.x2 = extents->x2; \
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);
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);
}
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);
}
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);
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);
}
unwrap (pScrPriv, ps, Glyphs);
(*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
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);
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);
}
unwrap (pScrPriv, ps, AddTraps);
(*ps->AddTraps) (pPicture, x_off, y_off, ntrap, traps);
damageRegionProcessPending (pPicture->pDrawable);
wrap (pScrPriv, ps, AddTraps, damageAddTraps);
}
/**********************************************************/
static void
damageFillSpans(DrawablePtr pDrawable,
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);
}
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);
DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
}
static void
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);
}
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);
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)
{
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);
}
(*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)
{
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);
}
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)
{
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);
}
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)
{
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;
}
box.x2++;
box.y2++;
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);
DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
}
static void
damagePolylines(DrawablePtr pDrawable,
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(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;
}
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);
DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
}
static void
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;
}
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);
DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
}
static void
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++;
}
}
(*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)
{
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(extra)
{
box.x1 -= extra;
box.x2 += extra;
box.y1 -= extra;
box.y2 += extra;
}
box.x2++;
box.y2++;
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);
DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
}
static void
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);
}
(*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)
{
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);
}
(*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)
{
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;
}
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);
DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
}
/*
* general Poly/Image text function. Extract glyph information,
* compute bounding box and remove cursor if it is overlapped.
*/
static void
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;
}
box.x1 = x + extents.overallLeft;
box.y1 = y - extents.overallAscent;
box.x2 = x + extents.overallRight;
box.y2 = y + extents.overallDescent;
damageDamageBox (pDrawable, &box, subWindowMode);
}
/*
* values for textType:
*/
#define TT_POLY8 0
#define TT_IMAGE8 1
#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;
imageblt = (textType == TT_IMAGE8) || (textType == TT_IMAGE16);
charinfo = malloc(count * sizeof(CharInfoPtr));
if (!charinfo)
return x;
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;
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));
}
free(charinfo);
return x + w;
}
static int
damagePolyText8(DrawablePtr pDrawable,
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);
else
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)
{
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);
else
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)
{
DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
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);
DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
}
static void
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);
else
(*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)
{
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);
DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
}
static void
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);
DAMAGE_GC_OP_EPILOGUE(pGC, pDrawable);
}
static void
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;
box.x1 = xOrg;
box.y1 = yOrg;
if(!pGC->miTranslate) {
box.x1 += pDrawable->x;
box.y1 += pDrawable->y;
}
box.x2 = box.x1 + dx;
box.y2 = box.y1 + dy;
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);
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;
}
#if DAMAGE_VALIDATE_ENABLE
ErrorF ("Damage not on list\n");
OsAbort ();
#endif
}
static void
damageInsertDamage (DamagePtr *pPrev, DamagePtr pDamage)
{
#if DAMAGE_VALIDATE_ENABLE
DamagePtr pOld;
for (pOld = *pPrev; pOld; pOld = pOld->pNext)
if (pOld == pDamage) {
ErrorF ("Damage already on list\n");
OsAbort ();
}
#endif
pDamage->pNext = *pPrev;
*pPrev = pDamage;
}
static Bool
damageDestroyPixmap (PixmapPtr pPixmap)
{
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);
}
}
unwrap (pScrPriv, pScreen, DestroyPixmap);
(*pScreen->DestroyPixmap) (pPixmap);
wrap (pScrPriv, pScreen, DestroyPixmap, damageDestroyPixmap);
return TRUE;
}
static void
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);
}
unwrap (pScrPriv, pScreen, CopyWindow);
(*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc);
damageRegionProcessPending (&pWindow->drawable);
wrap (pScrPriv, pScreen, CopyWindow, damageCopyWindow);
}
static GCOps damageGCOps = {
damageFillSpans, damageSetSpans,
damagePutImage, damageCopyArea,
damageCopyPlane, damagePolyPoint,
damagePolylines, damagePolySegment,
damagePolyRectangle, damagePolyArc,
damageFillPolygon, damagePolyFillRect,
damagePolyFillArc, damagePolyText8,
damagePolyText16, damageImageText8,
damageImageText16, damageImageGlyphBlt,
damagePolyGlyphBlt, damagePushPixels,
};
static void
damageSetWindowPixmap (WindowPtr pWindow, PixmapPtr pPixmap)
{
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;
}
}
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;
}
}
}
static Bool
damageDestroyWindow (WindowPtr pWindow)
{
DamagePtr pDamage;
ScreenPtr pScreen = pWindow->drawable.pScreen;
Bool ret;
damageScrPriv(pScreen);
while ((pDamage = damageGetWinPriv(pWindow)))
{
DamageUnregister (&pWindow->drawable, pDamage);
DamageDestroy (pDamage);
}
unwrap (pScrPriv, pScreen, DestroyWindow);
ret = (*pScreen->DestroyWindow) (pWindow);
wrap (pScrPriv, pScreen, DestroyWindow, damageDestroyWindow);
return ret;
}
static Bool
damageCloseScreen (int i, ScreenPtr pScreen)
{
damageScrPriv(pScreen);
unwrap (pScrPriv, pScreen, DestroyPixmap);
unwrap (pScrPriv, pScreen, CreateGC);
unwrap (pScrPriv, pScreen, CopyWindow);
unwrap (pScrPriv, pScreen, CloseScreen);
free(pScrPriv);
return (*pScreen->CloseScreen) (i, pScreen);
}
/**
* Default implementations of the damage management functions.
*/
void miDamageCreate (DamagePtr pDamage)
{
}
void miDamageRegister (DrawablePtr pDrawable, DamagePtr pDamage)
{
}
void miDamageUnregister (DrawablePtr pDrawable, DamagePtr pDamage)
{
}
void miDamageDestroy (DamagePtr pDamage)
{
}
/**
* Public functions for consumption outside this file.
*/
Bool
DamageSetup (ScreenPtr pScreen)
{
DamageScrPrivPtr pScrPriv;
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
const DamageScreenFuncsRec miFuncs = {
miDamageCreate, miDamageRegister, miDamageUnregister, miDamageDestroy
};
if (!dixRegisterPrivateKey(&damageScrPrivateKeyRec, PRIVATE_SCREEN, 0))
return FALSE;
if (dixLookupPrivate(&pScreen->devPrivates, damageScrPrivateKey))
return TRUE;
if (!dixRegisterPrivateKey(&damageGCPrivateKeyRec, PRIVATE_GC, sizeof(DamageGCPrivRec)))
return FALSE;
if (!dixRegisterPrivateKey(&damagePixPrivateKeyRec, PRIVATE_PIXMAP, 0))
return FALSE;
if (!dixRegisterPrivateKey(&damageWinPrivateKeyRec, PRIVATE_WINDOW, 0))
return FALSE;
pScrPriv = malloc(sizeof (DamageScrPrivRec));
if (!pScrPriv)
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);
if (ps) {
wrap (pScrPriv, ps, Glyphs, damageGlyphs);
wrap (pScrPriv, ps, Composite, damageComposite);
wrap (pScrPriv, ps, AddTraps, damageAddTraps);
}
pScrPriv->funcs = miFuncs;
dixSetPrivate(&pScreen->devPrivates, damageScrPrivateKey, pScrPriv);
return TRUE;
}
DamagePtr
DamageCreate (DamageReportFunc damageReport,
DamageDestroyFunc damageDestroy,
DamageReportLevel damageLevel,
Bool isInternal,
ScreenPtr pScreen,
void *closure)
{
damageScrPriv(pScreen);
DamagePtr pDamage;
pDamage = dixAllocateObjectWithPrivates(DamageRec, PRIVATE_DAMAGE);
if (!pDamage)
return 0;
pDamage->pNext = 0;
pDamage->pNextWin = 0;
RegionNull(&pDamage->damage);
RegionNull(&pDamage->pendingDamage);
pDamage->damageLevel = damageLevel;
pDamage->isInternal = isInternal;
pDamage->closure = closure;
pDamage->isWindow = FALSE;
pDamage->pDrawable = 0;
pDamage->reportAfter = FALSE;
pDamage->damageReport = damageReport;
pDamage->damageReportPostRendering = NULL;
pDamage->damageDestroy = damageDestroy;
pDamage->damageMarker = NULL;
pDamage->pScreen = pScreen;
(*pScrPriv->funcs.Create) (pDamage);
return pDamage;
}
void
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 ();
}
#endif
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 ();
}
#endif
pDamage->pNextWin = *pPrev;
*pPrev = pDamage;
pDamage->isWindow = TRUE;
}
else
pDamage->isWindow = FALSE;
pDamage->pDrawable = pDrawable;
damageInsertDamage (getDrawableDamageRef (pDrawable), pDamage);
(*pScrPriv->funcs.Register) (pDrawable, pDamage);
}
void
DamageDrawInternal (ScreenPtr pScreen, Bool enable)
{
damageScrPriv (pScreen);
pScrPriv->internalLevel += enable ? 1 : -1;
}
void
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 DAMAGE_VALIDATE_ENABLE
int found = 0;
#endif
while (*pPrev)
{
if (*pPrev == pDamage)
{
*pPrev = pDamage->pNextWin;
#if DAMAGE_VALIDATE_ENABLE
found = 1;
#endif
break;
}
pPrev = &(*pPrev)->pNextWin;
}
#if DAMAGE_VALIDATE_ENABLE
if (!found) {
ErrorF ("Damage not on window list\n");
OsAbort ();
}
#endif
}
pDamage->pDrawable = 0;
damageRemoveDamage (getDrawableDamageRef (pDrawable), pDamage);
}
void
DamageDestroy (DamagePtr pDamage)
{
ScreenPtr pScreen = pDamage->pScreen;
damageScrPriv(pScreen);
if (pDamage->damageDestroy)
(*pDamage->damageDestroy) (pDamage, pDamage->closure);
(*pScrPriv->funcs.Destroy) (pDamage);
RegionUninit(&pDamage->damage);
RegionUninit(&pDamage->pendingDamage);
dixFreeObjectWithPrivates(pDamage, PRIVATE_DAMAGE);
}
Bool
DamageSubtract (DamagePtr pDamage,
const RegionPtr pRegion)
{
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);
}
return RegionNotEmpty(&pDamage->damage);
}
void
DamageEmpty (DamagePtr pDamage)
{
RegionEmpty(&pDamage->damage);
}
RegionPtr
DamageRegion (DamagePtr pDamage)
{
return &pDamage->damage;
}
RegionPtr
DamagePendingRegion (DamagePtr pDamage)
{
return &pDamage->pendingDamage;
}
void
DamageRegionAppend (DrawablePtr pDrawable, RegionPtr pRegion)
{
damageRegionAppend (pDrawable, pRegion, FALSE, -1);
}
void
DamageRegionProcessPending (DrawablePtr 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)
{
if (pDamage->damageReportPostRendering)
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)
{
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);
}
void
DamageSetReportAfterOp (DamagePtr pDamage, Bool reportAfter)
{
pDamage->reportAfter = reportAfter;
}
void
DamageSetPostRenderingFunctions(DamagePtr pDamage, DamageReportFunc damageReportPostRendering,
DamageMarkerFunc damageMarker)
{
pDamage->damageReportPostRendering = damageReportPostRendering;
pDamage->damageMarker = damageMarker;
}
DamageScreenFuncsPtr
DamageGetScreenFuncs (ScreenPtr pScreen)
{
damageScrPriv(pScreen);
return &pScrPriv->funcs;
}
void
DamageReportDamage (DamagePtr pDamage, RegionPtr pDamageRegion)
{
BoxRec tmpBox;
RegionRec tmpRegion;
Bool was_empty;
switch (pDamage->damageLevel) {
case DamageReportRawRegion:
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;
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;
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;
case DamageReportNone:
RegionUnion(&pDamage->damage, &pDamage->damage,
pDamageRegion);
break;
}
}
Reference in New Issue View Git Blame Copy Permalink