static RegionPtr
XAACopyPlanePixmap(
DrawablePtr pSrc,
DrawablePtr pDst,
GCPtr pGC,
int srcx, int srcy,
int width, int height,
int dstx, int dsty,
unsigned long bitPlane
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
RegionPtr ret;
XAA_PIXMAP_OP_PROLOGUE(pGC, pDst);
if(infoRec->pScrn->vtSema &&
((pSrc->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pSrc))){
if(infoRec->NeedToSync) {
(*infoRec->Sync)(infoRec->pScrn);
infoRec->NeedToSync = FALSE;
}
}
ret = (*pGC->ops->CopyPlane)(pSrc, pDst,
pGC, srcx, srcy, width, height, dstx, dsty, bitPlane);
XAA_PIXMAP_OP_EPILOGUE(pGC);
return ret;
}
static void
XAAGetImage (
DrawablePtr pDraw,
int sx, int sy, int w, int h,
unsigned int format,
unsigned long planemask,
char *pdstLine
)
{
ScreenPtr pScreen = pDraw->pScreen;
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
ScrnInfoPtr pScrn = infoRec->pScrn;
if(pScrn->vtSema &&
((pDraw->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pDraw)))
{
if(infoRec->ReadPixmap && (format == ZPixmap) &&
((planemask & infoRec->FullPlanemasks[pDraw->depth - 1]) ==
infoRec->FullPlanemasks[pDraw->depth - 1]) &&
(pDraw->bitsPerPixel == BitsPerPixel(pDraw->depth)))
{
(*infoRec->ReadPixmap)(pScrn,
sx + pDraw->x, sy + pDraw->y, w, h,
(unsigned char *)pdstLine,
PixmapBytePad(w, pDraw->depth),
pDraw->bitsPerPixel, pDraw->depth);
return;
}
SYNC_CHECK(pDraw);
}
XAA_SCREEN_PROLOGUE (pScreen, GetImage);
(*pScreen->GetImage) (pDraw, sx, sy, w, h, format, planemask, pdstLine);
XAA_SCREEN_EPILOGUE (pScreen, GetImage, XAAGetImage);
}
static RegionPtr
XAACopyAreaFallback(
DrawablePtr pSrc,
DrawablePtr pDst,
GC *pGC,
int srcx, int srcy,
int width, int height,
int dstx, int dsty )
{
RegionPtr ret;
XAA_GC_OP_PROLOGUE(pGC);
if((pSrc->type == DRAWABLE_WINDOW) || (pDst->type == DRAWABLE_WINDOW) ||
IS_OFFSCREEN_PIXMAP(pSrc) || IS_OFFSCREEN_PIXMAP(pDst)) {
SYNC_CHECK(pGC);
}
ret = (*pGC->ops->CopyArea)(pSrc, pDst,
pGC, srcx, srcy, width, height, dstx, dsty);
XAA_GC_OP_EPILOGUE(pGC);
return ret;
}
static void
XAAGetSpans(DrawablePtr pDraw,
int wMax, DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart)
{
ScreenPtr pScreen = pDraw->pScreen;
XAA_SCREEN_PROLOGUE(pScreen, GetSpans);
if (xf86Screens[pScreen->myNum]->vtSema &&
((pDraw->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pDraw))) {
SYNC_CHECK(pDraw);
}
(*pScreen->GetSpans) (pDraw, wMax, ppt, pwidth, nspans, pdstStart);
XAA_SCREEN_EPILOGUE(pScreen, GetSpans, XAAGetSpans);
}
static void
XAASaveAreas (
PixmapPtr pPixmap,
RegionPtr prgnSave,
int xorg,
int yorg,
WindowPtr pWin
){
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
if(IS_OFFSCREEN_PIXMAP(pPixmap)) {
BoxPtr pbox = REGION_RECTS(prgnSave);
int nboxes = REGION_NUM_RECTS(prgnSave);
(*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, GXcopy, ~0, -1);
while(nboxes--) {
(*infoRec->SubsequentScreenToScreenCopy)(pScrn,
pbox->x1 + xorg, pbox->y1 + yorg,
pPixmap->drawable.x + pbox->x1,
pPixmap->drawable.y + pbox->y1,
pbox->x2 - pbox->x1, pbox->y2 - pbox->y1);
pbox++;
}
SET_SYNC_FLAG(infoRec);
return;
}
if(xf86Screens[pScreen->myNum]->vtSema && infoRec->ReadPixmap &&
(pWin->drawable.bitsPerPixel == pPixmap->drawable.bitsPerPixel)) {
BoxPtr pbox = REGION_RECTS(prgnSave);
int nboxes = REGION_NUM_RECTS(prgnSave);
int Bpp = pPixmap->drawable.bitsPerPixel >> 3;
unsigned char *dstp = (unsigned char*)pPixmap->devPrivate.ptr;
while(nboxes--) {
(*infoRec->ReadPixmap)(infoRec->pScrn,
pbox->x1 + xorg, pbox->y1 + yorg,
pbox->x2 - pbox->x1, pbox->y2 - pbox->y1,
dstp + (pPixmap->devKind * pbox->y1) + (pbox->x1 * Bpp),
pPixmap->devKind,
pPixmap->drawable.bitsPerPixel, pPixmap->drawable.depth);
pbox++;
}
return;
}
static RegionPtr
XAACopyAreaPixmap(
DrawablePtr pSrc,
DrawablePtr pDst,
GC *pGC,
int srcx, int srcy,
int width, int height,
int dstx, int dsty
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
RegionPtr ret;
if(infoRec->pScrn->vtSema &&
((pSrc->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pSrc)))
{
if(infoRec->ReadPixmap && (pGC->alu == GXcopy) &&
(pSrc->bitsPerPixel == pDst->bitsPerPixel) &&
((pGC->planemask & infoRec->FullPlanemasks[pSrc->depth - 1])
== infoRec->FullPlanemasks[pSrc->depth - 1]))
{
XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE((PixmapPtr)(pDst));
pixPriv->flags |= DIRTY;
return (XAABitBlt( pSrc, pDst, pGC,
srcx, srcy, width, height, dstx, dsty,
XAADoImageRead, 0L));
} else
if(infoRec->NeedToSync) {
(*infoRec->Sync)(infoRec->pScrn);
infoRec->NeedToSync = FALSE;
}
}
{
XAA_PIXMAP_OP_PROLOGUE(pGC, pDst);
ret = (*pGC->ops->CopyArea)(pSrc, pDst,
pGC, srcx, srcy, width, height, dstx, dsty);
XAA_PIXMAP_OP_EPILOGUE(pGC);
}
return ret;
}
static void
XAAPaintWindow8_32(
WindowPtr pWin,
RegionPtr prgn,
int what
){
ScreenPtr pScreen = pWin->drawable.pScreen;
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_DRAWABLE((&pWin->drawable));
int nBox = REGION_NUM_RECTS(prgn);
BoxPtr pBox = REGION_RECTS(prgn);
PixmapPtr pPix = NULL;
int depth = pWin->drawable.depth;
int fg = 0, pm;
if(!infoRec->pScrn->vtSema) goto BAILOUT;
switch (what) {
case PW_BACKGROUND:
switch(pWin->backgroundState) {
case None: return;
case ParentRelative:
do { pWin = pWin->parent; }
while(pWin->backgroundState == ParentRelative);
(*pWin->drawable.pScreen->PaintWindowBackground)(pWin, prgn, what);
return;
case BackgroundPixel:
fg = pWin->background.pixel;
break;
case BackgroundPixmap:
pPix = pWin->background.pixmap;
break;
}
break;
case PW_BORDER:
if (pWin->borderIsPixel)
fg = pWin->border.pixel;
else /* pixmap */
pPix = pWin->border.pixmap;
break;
default: return;
}
if(depth == 8) {
pm = 0xff000000;
fg <<= 24;
} else
pm = 0x00ffffff;
if(!pPix) {
if(infoRec->FillSolidRects &&
!(infoRec->FillSolidRectsFlags & NO_PLANEMASK) &&
(!(infoRec->FillSolidRectsFlags & RGB_EQUAL) ||
(depth == 8) || CHECK_RGB_EQUAL(fg)))
{
(*infoRec->FillSolidRects)(infoRec->pScrn, fg, GXcopy,
pm, nBox, pBox);
return;
}
} else { /* pixmap */
XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
WindowPtr pBgWin = pWin;
int xorg, yorg;
if (what == PW_BORDER) {
for (pBgWin = pWin;
pBgWin->backgroundState == ParentRelative;
pBgWin = pBgWin->parent);
}
xorg = pBgWin->drawable.x;
yorg = pBgWin->drawable.y;
#ifdef PANORAMIX
if(!noPanoramiXExtension) {
int index = pScreen->myNum;
if(WindowTable[index] == pBgWin) {
xorg -= panoramiXdataPtr[index].x;
yorg -= panoramiXdataPtr[index].y;
}
}
#endif
if(IS_OFFSCREEN_PIXMAP(pPix) && infoRec->FillCacheBltRects) {
XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);
pCache->x = pPriv->offscreenArea->box.x1;
pCache->y = pPriv->offscreenArea->box.y1;
pCache->w = pCache->orig_w =
pPriv->offscreenArea->box.x2 - pCache->x;
pCache->h = pCache->orig_h =
pPriv->offscreenArea->box.y2 - pCache->y;
pCache->trans_color = -1;
(*infoRec->FillCacheBltRects)(infoRec->pScrn, GXcopy, pm,
nBox, pBox, xorg, yorg, pCache);
return;
}
if(pPriv->flags & DIRTY) {
pPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
pPix->drawable.serialNumber = NEXT_SERIAL_NUMBER;
}
if(!(pPriv->flags & REDUCIBILITY_CHECKED) &&
(infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {
XAACheckTileReducibility(pPix, infoRec->CanDoMono8x8);
}
if(pPriv->flags & REDUCIBLE_TO_8x8) {
if((pPriv->flags & REDUCIBLE_TO_2_COLOR) &&
infoRec->CanDoMono8x8 && infoRec->FillMono8x8PatternRects &&
!(infoRec->FillMono8x8PatternRectsFlags & NO_PLANEMASK) &&
!(infoRec->FillMono8x8PatternRectsFlags & TRANSPARENCY_ONLY) &&
(!(infoRec->FillMono8x8PatternRectsFlags & RGB_EQUAL) ||
(CHECK_RGB_EQUAL(pPriv->fg) && CHECK_RGB_EQUAL(pPriv->bg))))
{
(*infoRec->FillMono8x8PatternRects)(infoRec->pScrn,
pPriv->fg, pPriv->bg, GXcopy, pm, nBox, pBox,
pPriv->pattern0, pPriv->pattern1, xorg, yorg);
return;
}
if(infoRec->CanDoColor8x8 && infoRec->FillColor8x8PatternRects &&
!(infoRec->FillColor8x8PatternRectsFlags & NO_PLANEMASK))
{
XAACacheInfoPtr pCache = (*infoRec->CacheColor8x8Pattern)(
infoRec->pScrn, pPix, -1, -1);
(*infoRec->FillColor8x8PatternRects) (infoRec->pScrn,
GXcopy, pm, nBox, pBox, xorg, yorg, pCache);
return;
}
}
if(infoRec->UsingPixmapCache && infoRec->FillCacheBltRects &&
!(infoRec->FillCacheBltRectsFlags & NO_PLANEMASK) &&
(pPix->drawable.height <= infoRec->MaxCacheableTileHeight) &&
(pPix->drawable.width <= infoRec->MaxCacheableTileWidth))
{
XAACacheInfoPtr pCache =
(*infoRec->CacheTile)(infoRec->pScrn, pPix);
(*infoRec->FillCacheBltRects)(infoRec->pScrn, GXcopy, pm,
nBox, pBox, xorg, yorg, pCache);
return;
}
if(infoRec->FillImageWriteRects &&
!(infoRec->FillImageWriteRectsFlags & NO_PLANEMASK))
{
(*infoRec->FillImageWriteRects) (infoRec->pScrn, GXcopy,
pm, nBox, pBox, xorg, yorg, pPix);
return;
}
}
if(infoRec->NeedToSync) {
(*infoRec->Sync)(infoRec->pScrn);
infoRec->NeedToSync = FALSE;
}
BAILOUT:
if(what == PW_BACKGROUND) {
XAA_SCREEN_PROLOGUE (pScreen, PaintWindowBackground);
(*pScreen->PaintWindowBackground) (pWin, prgn, what);
XAA_SCREEN_EPILOGUE(pScreen, PaintWindowBackground, XAAPaintWindow8_32);
} else {
XAA_SCREEN_PROLOGUE (pScreen, PaintWindowBorder);
(*pScreen->PaintWindowBorder) (pWin, prgn, what);
XAA_SCREEN_EPILOGUE(pScreen, PaintWindowBorder, XAAPaintWindow8_32);
}
}
void
XAAPaintWindow(
WindowPtr pWin,
RegionPtr prgn,
int what
)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_DRAWABLE((&pWin->drawable));
int nBox = REGION_NUM_RECTS(prgn);
BoxPtr pBox = REGION_RECTS(prgn);
int fg = -1;
PixmapPtr pPix = NULL;
if(!infoRec->pScrn->vtSema) goto BAILOUT;
switch (what) {
case PW_BACKGROUND:
switch(pWin->backgroundState) {
case None: return;
case ParentRelative:
do { pWin = pWin->parent; }
while(pWin->backgroundState == ParentRelative);
(*pWin->drawable.pScreen->PaintWindowBackground)(pWin, prgn, what);
return;
case BackgroundPixel:
fg = pWin->background.pixel;
break;
case BackgroundPixmap:
pPix = pWin->background.pixmap;
break;
}
break;
case PW_BORDER:
if (pWin->borderIsPixel)
fg = pWin->border.pixel;
else /* pixmap */
pPix = pWin->border.pixmap;
break;
default: return;
}
if(!pPix) {
if(infoRec->FillSolidRects &&
(!(infoRec->FillSolidRectsFlags & RGB_EQUAL) ||
(CHECK_RGB_EQUAL(fg))) ) {
(*infoRec->FillSolidRects)(infoRec->pScrn, fg, GXcopy, ~0,
nBox, pBox);
return;
}
} else { /* pixmap */
XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
WindowPtr pBgWin = pWin;
Bool NoCache = FALSE;
int xorg, yorg;
/* Hack so we can use this with the dual framebuffer layers
which only support the pixmap cache in the primary bpp */
if(pPix->drawable.bitsPerPixel != infoRec->pScrn->bitsPerPixel)
NoCache = TRUE;
if (what == PW_BORDER) {
for (pBgWin = pWin;
pBgWin->backgroundState == ParentRelative;
pBgWin = pBgWin->parent);
}
xorg = pBgWin->drawable.x;
yorg = pBgWin->drawable.y;
if(IS_OFFSCREEN_PIXMAP(pPix) && infoRec->FillCacheBltRects) {
XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);
pCache->x = pPriv->offscreenArea->box.x1;
pCache->y = pPriv->offscreenArea->box.y1;
pCache->w = pCache->orig_w =
pPriv->offscreenArea->box.x2 - pCache->x;
pCache->h = pCache->orig_h =
pPriv->offscreenArea->box.y2 - pCache->y;
pCache->trans_color = -1;
(*infoRec->FillCacheBltRects)(infoRec->pScrn, GXcopy, ~0,
nBox, pBox, xorg, yorg, pCache);
return;
}
if(pPriv->flags & DIRTY) {
pPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
pPix->drawable.serialNumber = NEXT_SERIAL_NUMBER;
}
if(!(pPriv->flags & REDUCIBILITY_CHECKED) &&
(infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {
XAACheckTileReducibility(pPix, infoRec->CanDoMono8x8);
}
if(pPriv->flags & REDUCIBLE_TO_8x8) {
if((pPriv->flags & REDUCIBLE_TO_2_COLOR) &&
infoRec->CanDoMono8x8 && infoRec->FillMono8x8PatternRects &&
!(infoRec->FillMono8x8PatternRectsFlags & TRANSPARENCY_ONLY) &&
(!(infoRec->FillMono8x8PatternRectsFlags & RGB_EQUAL) ||
(CHECK_RGB_EQUAL(pPriv->fg) && CHECK_RGB_EQUAL(pPriv->bg)))) {
(*infoRec->FillMono8x8PatternRects)(infoRec->pScrn,
pPriv->fg, pPriv->bg, GXcopy, ~0, nBox, pBox,
pPriv->pattern0, pPriv->pattern1, xorg, yorg);
return;
}
if(infoRec->CanDoColor8x8 && !NoCache &&
infoRec->FillColor8x8PatternRects) {
XAACacheInfoPtr pCache = (*infoRec->CacheColor8x8Pattern)(
infoRec->pScrn, pPix, -1, -1);
(*infoRec->FillColor8x8PatternRects) ( infoRec->pScrn,
GXcopy, ~0, nBox, pBox, xorg, yorg, pCache);
return;
}
}
/* The window size check is to reduce pixmap cache thrashing
when there are lots of little windows with pixmap backgrounds
like are sometimes used for buttons, etc... */
if(infoRec->UsingPixmapCache &&
infoRec->FillCacheBltRects && !NoCache &&
((what == PW_BORDER) ||
(pPix->drawable.height != pWin->drawable.height) ||
(pPix->drawable.width != pWin->drawable.width)) &&
(pPix->drawable.height <= infoRec->MaxCacheableTileHeight) &&
(pPix->drawable.width <= infoRec->MaxCacheableTileWidth)) {
XAACacheInfoPtr pCache =
(*infoRec->CacheTile)(infoRec->pScrn, pPix);
(*infoRec->FillCacheBltRects)(infoRec->pScrn, GXcopy, ~0,
nBox, pBox, xorg, yorg, pCache);
return;
}
if(infoRec->FillImageWriteRects &&
!(infoRec->FillImageWriteRectsFlags & NO_GXCOPY)) {
(*infoRec->FillImageWriteRects) (infoRec->pScrn, GXcopy,
~0, nBox, pBox, xorg, yorg, pPix);
return;
}
}
if(infoRec->NeedToSync) {
(*infoRec->Sync)(infoRec->pScrn);
infoRec->NeedToSync = FALSE;
}
BAILOUT:
if(what == PW_BACKGROUND) {
XAA_SCREEN_PROLOGUE (pScreen, PaintWindowBackground);
(*pScreen->PaintWindowBackground) (pWin, prgn, what);
XAA_SCREEN_EPILOGUE(pScreen, PaintWindowBackground, XAAPaintWindow);
} else {
XAA_SCREEN_PROLOGUE (pScreen, PaintWindowBorder);
(*pScreen->PaintWindowBorder) (pWin, prgn, what);
XAA_SCREEN_EPILOGUE(pScreen, PaintWindowBorder, XAAPaintWindow);
}
}
static void
XAAValidateGC(
GCPtr pGC,
unsigned long changes,
DrawablePtr pDraw
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
XAA_GC_FUNC_PROLOGUE(pGC);
(*pGC->funcs->ValidateGC)(pGC, changes, pDraw);
if((changes & GCPlaneMask) &&
((pGC->planemask & infoRec->FullPlanemasks[pGC->depth - 1]) ==
infoRec->FullPlanemasks[pGC->depth - 1]))
{
pGC->planemask = ~0;
}
if(pGC->depth != 32) {
/* 0xffffffff is reserved for transparency */
if(pGC->bgPixel == 0xffffffff)
pGC->bgPixel = 0x7fffffff;
if(pGC->fgPixel == 0xffffffff)
pGC->fgPixel = 0x7fffffff;
}
if((pDraw->type == DRAWABLE_PIXMAP) && !IS_OFFSCREEN_PIXMAP(pDraw)){
pGCPriv->flags = OPS_ARE_PIXMAP;
pGCPriv->changes |= changes;
/* make sure we're not using videomemory pixmaps to render
onto system memory drawables */
if((pGC->fillStyle == FillTiled) &&
IS_OFFSCREEN_PIXMAP(pGC->tile.pixmap) &&
!OFFSCREEN_PIXMAP_LOCKED(pGC->tile.pixmap)) {
XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
FBAreaPtr area = pPriv->offscreenArea;
XAARemoveAreaCallback(area); /* clobbers pPriv->offscreenArea */
xf86FreeOffscreenArea(area);
}
}
else if(!infoRec->pScrn->vtSema && (pDraw->type == DRAWABLE_WINDOW)) {
pGCPriv->flags = 0;
pGCPriv->changes |= changes;
}
else {
if(!(pGCPriv->flags & OPS_ARE_ACCEL)) {
changes |= pGCPriv->changes;
pGCPriv->changes = 0;
}
pGCPriv->flags = OPS_ARE_ACCEL;
#if 1
/* Ugh. If we can't use the blitter on offscreen pixmaps used
as tiles, then we need to move them out as cfb can't handle
tiles with non-zero origins */
if((pGC->fillStyle == FillTiled) &&
IS_OFFSCREEN_PIXMAP(pGC->tile.pixmap) &&
(DO_PIXMAP_COPY != (*infoRec->TiledFillChooser)(pGC))) {
XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
FBAreaPtr area = pPriv->offscreenArea;
XAARemoveAreaCallback(area); /* clobbers pPriv->offscreenArea */
xf86FreeOffscreenArea(area);
}
#endif
}
XAA_GC_FUNC_EPILOGUE(pGC);
if(!(pGCPriv->flags & OPS_ARE_ACCEL)) return;
if((changes & GCTile) && !pGC->tileIsPixel && pGC->tile.pixmap){
XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
if(pixPriv->flags & DIRTY) {
pixPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
pGC->tile.pixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
}
}
if((changes & GCStipple) && pGC->stipple){
XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
if(pixPriv->flags & DIRTY) {
pixPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
pGC->stipple->drawable.serialNumber = NEXT_SERIAL_NUMBER;
}
}
/* If our Ops are still the default ones we need to allocate new ones */
if(pGC->ops == &XAAFallbackOps) {
if(!(pGCPriv->XAAOps = xalloc(sizeof(GCOps)))) {
pGCPriv->XAAOps = &XAAFallbackOps;
return;
}
/* make a modifiable copy of the default ops */
memcpy(pGCPriv->XAAOps, &XAAFallbackOps, sizeof(GCOps));
pGC->ops = pGCPriv->XAAOps;
changes = ~0;
}
if(!changes) return;
if((changes & GCDashList) && infoRec->ComputeDash)
infoRec->ComputeDash(pGC);
if(changes & infoRec->FillSpansMask)
(*infoRec->ValidateFillSpans)(pGC, changes, pDraw);
if(changes & infoRec->SetSpansMask)
(*infoRec->ValidateSetSpans)(pGC, changes, pDraw);
if(changes & infoRec->PutImageMask)
(*infoRec->ValidatePutImage)(pGC, changes, pDraw);
if(changes & infoRec->CopyAreaMask)
(*infoRec->ValidateCopyArea)(pGC, changes, pDraw);
if(changes & infoRec->CopyPlaneMask)
(*infoRec->ValidateCopyPlane)(pGC, changes, pDraw);
if(changes & infoRec->PolyPointMask)
(*infoRec->ValidatePolyPoint)(pGC, changes, pDraw);
if(changes & infoRec->PolylinesMask)
(*infoRec->ValidatePolylines)(pGC, changes, pDraw);
if(changes & infoRec->PolySegmentMask)
(*infoRec->ValidatePolySegment)(pGC, changes, pDraw);
if(changes & infoRec->PolyRectangleMask)
(*infoRec->ValidatePolyRectangle)(pGC, changes, pDraw);
if(changes & infoRec->PolyArcMask)
(*infoRec->ValidatePolyArc)(pGC, changes, pDraw);
if(changes & infoRec->FillPolygonMask)
(*infoRec->ValidateFillPolygon)(pGC, changes, pDraw);
if(changes & infoRec->PolyFillRectMask)
(*infoRec->ValidatePolyFillRect)(pGC, changes, pDraw);
if(changes & infoRec->PolyFillArcMask)
(*infoRec->ValidatePolyFillArc)(pGC, changes, pDraw);
if(changes & infoRec->PolyGlyphBltMask)
(*infoRec->ValidatePolyGlyphBlt)(pGC, changes, pDraw);
if(changes & infoRec->ImageGlyphBltMask)
(*infoRec->ValidateImageGlyphBlt)(pGC, changes, pDraw);
if(changes & infoRec->PolyText8Mask)
(*infoRec->ValidatePolyText8)(pGC, changes, pDraw);
if(changes & infoRec->PolyText16Mask)
(*infoRec->ValidatePolyText16)(pGC, changes, pDraw);
if(changes & infoRec->ImageText8Mask)
(*infoRec->ValidateImageText8)(pGC, changes, pDraw);
if(changes & infoRec->ImageText16Mask)
(*infoRec->ValidateImageText16)(pGC, changes, pDraw);
if(changes & infoRec->PushPixelsMask)
(*infoRec->ValidatePushPixels)(pGC, changes, pDraw);
}
