Home | History | Annotate | Line # | Download | only in xaa 
      1 
      2 #ifdef HAVE_XORG_CONFIG_H
      3 #include <xorg-config.h>
      4 #endif
      5 
      6 #include <string.h>
      7 
      8 #include "misc.h"
      9 #include "xf86.h"
     10 #include "xf86_OSproc.h"
     11 
     12 #include <X11/X.h>
     13 #include "scrnintstr.h"
     14 #include "xf86str.h"
     15 #include "xaa.h"
     16 #include "xaalocal.h"
     17 #include "migc.h"
     18 #include "gcstruct.h"
     19 #include "pixmapstr.h"
     20 #include "xaawrap.h"
     21 
     22 static void XAAValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
     23 static void XAAChangeGC(GCPtr pGC, unsigned long mask);
     24 static void XAACopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
     25 static void XAADestroyGC(GCPtr pGC);
     26 static void XAAChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects);
     27 static void XAADestroyClip(GCPtr pGC);
     28 static void XAACopyClip(GCPtr pgcDst, GCPtr pgcSrc);
     29 
     30 GCFuncs XAAGCFuncs = {
     31     XAAValidateGC, XAAChangeGC, XAACopyGC, XAADestroyGC,
     32     XAAChangeClip, XAADestroyClip, XAACopyClip
     33 };
     34 
     35 extern GCOps XAAPixmapOps;
     36 
     37 Bool
     38 XAACreateGC(GCPtr pGC)
     39 {
     40     ScreenPtr    pScreen = pGC->pScreen;
     41     XAAGCPtr     pGCPriv = (XAAGCPtr)dixLookupPrivate(&pGC->devPrivates,
     42 						      XAAGetGCKey());
     43     Bool         ret;
     44 
     45     XAA_SCREEN_PROLOGUE(pScreen,CreateGC);
     46 
     47     if((ret = (*pScreen->CreateGC)(pGC))) {
     48 	pGCPriv->wrapOps = NULL;
     49 	pGCPriv->wrapFuncs = pGC->funcs;
     50 	pGCPriv->XAAOps = &XAAFallbackOps;
     51 	pGC->funcs = &XAAGCFuncs;
     52     }
     53 
     54     XAA_SCREEN_EPILOGUE(pScreen,CreateGC,XAACreateGC);
     55 
     56     return ret;
     57 }
     58 
     59 
     60 static void
     61 XAAValidateGC(
     62    GCPtr         pGC,
     63    unsigned long changes,
     64    DrawablePtr   pDraw
     65 ){
     66     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
     67     XAA_GC_FUNC_PROLOGUE(pGC);
     68 
     69     (*pGC->funcs->ValidateGC)(pGC, changes, pDraw);
     70 
     71     if((changes & GCPlaneMask) &&
     72        ((pGC->planemask & infoRec->FullPlanemasks[pGC->depth - 1]) ==
     73 	 infoRec->FullPlanemasks[pGC->depth - 1]))
     74     {
     75 	pGC->planemask = ~0;
     76     }
     77 
     78     if(pGC->depth != 32) {
     79 	/* 0xffffffff is reserved for transparency */
     80 	if(pGC->bgPixel == 0xffffffff)
     81 	    pGC->bgPixel = 0x7fffffff;
     82 	if(pGC->fgPixel == 0xffffffff)
     83 	    pGC->fgPixel = 0x7fffffff;
     84     }
     85 
     86     if((pDraw->type == DRAWABLE_PIXMAP) &&
     87        !IS_OFFSCREEN_PIXMAP(pDraw) &&
     88        !PIXMAP_IS_SCREEN(pDraw)) {
     89 	pGCPriv->flags = OPS_ARE_PIXMAP;
     90         pGCPriv->changes |= changes;
     91 
     92 	/* make sure we're not using videomemory pixmaps to render
     93 	   onto system memory drawables */
     94 
     95 	if((pGC->fillStyle == FillTiled) &&
     96 	    IS_OFFSCREEN_PIXMAP(pGC->tile.pixmap) &&
     97 	    !OFFSCREEN_PIXMAP_LOCKED(pGC->tile.pixmap)) {
     98 
     99 	    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
    100 	    FBAreaPtr area = pPriv->offscreenArea;
    101 
    102 	    XAARemoveAreaCallback(area); /* clobbers pPriv->offscreenArea */
    103 	    xf86FreeOffscreenArea(area);
    104 	}
    105     }
    106     else if(!infoRec->pScrn->vtSema && (pDraw->type == DRAWABLE_WINDOW)) {
    107 	pGCPriv->flags = 0;
    108         pGCPriv->changes |= changes;
    109     }
    110     else {
    111 	if(!(pGCPriv->flags & OPS_ARE_ACCEL)) {
    112 	    changes |= pGCPriv->changes;
    113 	    pGCPriv->changes = 0;
    114 	}
    115 	pGCPriv->flags = OPS_ARE_ACCEL;
    116 
    117 #if 1
    118 	/* Ugh.  If we can't use the blitter on offscreen pixmaps used
    119 	   as tiles, then we need to move them out as cfb can't handle
    120 	   tiles with non-zero origins */
    121 
    122 	if((pGC->fillStyle == FillTiled) &&
    123 	    IS_OFFSCREEN_PIXMAP(pGC->tile.pixmap) &&
    124 	    (DO_PIXMAP_COPY != (*infoRec->TiledFillChooser)(pGC))) {
    125 
    126 	    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
    127 	    FBAreaPtr area = pPriv->offscreenArea;
    128 
    129 	    XAARemoveAreaCallback(area); /* clobbers pPriv->offscreenArea */
    130 	    xf86FreeOffscreenArea(area);
    131 	}
    132 #endif
    133     }
    134 
    135     XAA_GC_FUNC_EPILOGUE(pGC);
    136 
    137     if(!(pGCPriv->flags & OPS_ARE_ACCEL)) return;
    138 
    139     if((changes & GCTile) && !pGC->tileIsPixel && pGC->tile.pixmap){
    140 	XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
    141 
    142 	if(pixPriv->flags & DIRTY) {
    143 	    pixPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
    144 	    pGC->tile.pixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
    145 	}
    146     }
    147     if((changes & GCStipple) && pGC->stipple){
    148 	XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
    149 
    150 	if(pixPriv->flags & DIRTY) {
    151 	    pixPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
    152 	    pGC->stipple->drawable.serialNumber = NEXT_SERIAL_NUMBER;
    153 	}
    154     }
    155 
    156     /* If our Ops are still the default ones we need to allocate new ones */
    157     if(pGC->ops == &XAAFallbackOps) {
    158 	if(!(pGCPriv->XAAOps = malloc(sizeof(GCOps)))) {
    159 	    pGCPriv->XAAOps = &XAAFallbackOps;
    160 	    return;
    161 	}
    162 	/* make a modifiable copy of the default ops */
    163 	memcpy(pGCPriv->XAAOps, &XAAFallbackOps, sizeof(GCOps));
    164 	pGC->ops = pGCPriv->XAAOps;
    165 	changes = ~0;
    166     }
    167 
    168     if(!changes) return;
    169 
    170     if((changes & GCDashList) && infoRec->ComputeDash)
    171 	infoRec->ComputeDash(pGC);
    172 
    173     if(changes & infoRec->FillSpansMask)
    174 	(*infoRec->ValidateFillSpans)(pGC, changes, pDraw);
    175 
    176     if(changes & infoRec->SetSpansMask)
    177 	(*infoRec->ValidateSetSpans)(pGC, changes, pDraw);
    178 
    179     if(changes & infoRec->PutImageMask)
    180 	(*infoRec->ValidatePutImage)(pGC, changes, pDraw);
    181 
    182     if(changes & infoRec->CopyAreaMask)
    183 	(*infoRec->ValidateCopyArea)(pGC, changes, pDraw);
    184 
    185     if(changes & infoRec->CopyPlaneMask)
    186 	(*infoRec->ValidateCopyPlane)(pGC, changes, pDraw);
    187 
    188     if(changes & infoRec->PolyPointMask)
    189 	(*infoRec->ValidatePolyPoint)(pGC, changes, pDraw);
    190 
    191     if(changes & infoRec->PolylinesMask)
    192 	(*infoRec->ValidatePolylines)(pGC, changes, pDraw);
    193 
    194     if(changes & infoRec->PolySegmentMask)
    195 	(*infoRec->ValidatePolySegment)(pGC, changes, pDraw);
    196 
    197     if(changes & infoRec->PolyRectangleMask)
    198 	(*infoRec->ValidatePolyRectangle)(pGC, changes, pDraw);
    199 
    200     if(changes & infoRec->PolyArcMask)
    201 	(*infoRec->ValidatePolyArc)(pGC, changes, pDraw);
    202 
    203     if(changes & infoRec->FillPolygonMask)
    204 	(*infoRec->ValidateFillPolygon)(pGC, changes, pDraw);
    205 
    206     if(changes & infoRec->PolyFillRectMask)
    207 	(*infoRec->ValidatePolyFillRect)(pGC, changes, pDraw);
    208 
    209     if(changes & infoRec->PolyFillArcMask)
    210 	(*infoRec->ValidatePolyFillArc)(pGC, changes, pDraw);
    211 
    212     if(changes & infoRec->PolyGlyphBltMask)
    213 	(*infoRec->ValidatePolyGlyphBlt)(pGC, changes, pDraw);
    214 
    215     if(changes & infoRec->ImageGlyphBltMask)
    216 	(*infoRec->ValidateImageGlyphBlt)(pGC, changes, pDraw);
    217 
    218     if(changes & infoRec->PolyText8Mask)
    219 	(*infoRec->ValidatePolyText8)(pGC, changes, pDraw);
    220 
    221     if(changes & infoRec->PolyText16Mask)
    222 	(*infoRec->ValidatePolyText16)(pGC, changes, pDraw);
    223 
    224     if(changes & infoRec->ImageText8Mask)
    225 	(*infoRec->ValidateImageText8)(pGC, changes, pDraw);
    226 
    227     if(changes & infoRec->ImageText16Mask)
    228 	(*infoRec->ValidateImageText16)(pGC, changes, pDraw);
    229 
    230     if(changes & infoRec->PushPixelsMask)
    231 	(*infoRec->ValidatePushPixels)(pGC, changes, pDraw);
    232 }
    233 
    234 
    235 static void
    236 XAADestroyGC(GCPtr pGC)
    237 {
    238     XAA_GC_FUNC_PROLOGUE (pGC);
    239 
    240     if(pGCPriv->XAAOps != &XAAFallbackOps)
    241 	free(pGCPriv->XAAOps);
    242 
    243     free(pGCPriv->DashPattern);
    244     pGCPriv->flags = 0;
    245 
    246     (*pGC->funcs->DestroyGC)(pGC);
    247     XAA_GC_FUNC_EPILOGUE (pGC);
    248 }
    249 
    250 static void
    251 XAAChangeGC (
    252     GCPtr	    pGC,
    253     unsigned long   mask
    254 )
    255 {
    256     XAA_GC_FUNC_PROLOGUE (pGC);
    257     (*pGC->funcs->ChangeGC) (pGC, mask);
    258     XAA_GC_FUNC_EPILOGUE (pGC);
    259 
    260    /* we have to assume that shared memory pixmaps are dirty
    261       because we can't wrap all operations on them */
    262 
    263     if((mask & GCTile) && !pGC->tileIsPixel &&
    264 	PIXMAP_IS_SHARED(pGC->tile.pixmap))
    265     {
    266 	XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
    267 	pPixPriv->flags |= DIRTY;
    268     }
    269 
    270     if((mask & GCStipple) && PIXMAP_IS_SHARED(pGC->stipple)){
    271 	XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
    272 	pPixPriv->flags |= DIRTY;
    273     }
    274 }
    275 
    276 static void
    277 XAACopyGC (
    278     GCPtr	    pGCSrc,
    279     unsigned long   mask,
    280     GCPtr	    pGCDst)
    281 {
    282     XAA_GC_FUNC_PROLOGUE (pGCDst);
    283     (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
    284     XAA_GC_FUNC_EPILOGUE (pGCDst);
    285 }
    286 static void
    287 XAAChangeClip (
    288     GCPtr   pGC,
    289     int		type,
    290     pointer	pvalue,
    291     int		nrects )
    292 {
    293     XAA_GC_FUNC_PROLOGUE (pGC);
    294     (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
    295     XAA_GC_FUNC_EPILOGUE (pGC);
    296 }
    297 
    298 static void
    299 XAACopyClip(GCPtr pgcDst, GCPtr pgcSrc)
    300 {
    301     XAA_GC_FUNC_PROLOGUE (pgcDst);
    302     (* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc);
    303     XAA_GC_FUNC_EPILOGUE (pgcDst);
    304 }
    305 
    306 static void
    307 XAADestroyClip(GCPtr pGC)
    308 {
    309     XAA_GC_FUNC_PROLOGUE (pGC);
    310     (* pGC->funcs->DestroyClip)(pGC);
    311     XAA_GC_FUNC_EPILOGUE (pGC);
    312 }
    313 
    314 /**** Pixmap Wrappers ****/
    315 
    316 
    317 
    318 static void
    319 XAAFillSpansPixmap(
    320     DrawablePtr pDraw,
    321     GC		*pGC,
    322     int		nInit,
    323     DDXPointPtr pptInit,
    324     int *pwidthInit,
    325     int fSorted
    326 ){
    327     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    328     (*pGC->ops->FillSpans)(pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
    329     XAA_PIXMAP_OP_EPILOGUE(pGC);
    330 }
    331 
    332 static void
    333 XAASetSpansPixmap(
    334     DrawablePtr		pDraw,
    335     GCPtr		pGC,
    336     char		*pcharsrc,
    337     register DDXPointPtr ppt,
    338     int			*pwidth,
    339     int			nspans,
    340     int			fSorted
    341 ){
    342     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    343     (*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted);
    344     XAA_PIXMAP_OP_EPILOGUE(pGC);
    345 }
    346 
    347 static void
    348 XAAPutImagePixmap(
    349     DrawablePtr pDraw,
    350     GCPtr	pGC,
    351     int		depth,
    352     int x, int y, int w, int h,
    353     int		leftPad,
    354     int		format,
    355     char 	*pImage
    356 ){
    357     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    358     (*pGC->ops->PutImage)(pDraw, pGC, depth, x, y, w, h,
    359 		leftPad, format, pImage);
    360     XAA_PIXMAP_OP_EPILOGUE(pGC);
    361 }
    362 
    363 static RegionPtr
    364 XAACopyAreaPixmap(
    365     DrawablePtr pSrc,
    366     DrawablePtr pDst,
    367     GC *pGC,
    368     int srcx, int srcy,
    369     int width, int height,
    370     int dstx, int dsty
    371 ){
    372     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
    373     RegionPtr ret;
    374 
    375     if(infoRec->pScrn->vtSema &&
    376 	((pSrc->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pSrc)))
    377     {
    378 	if(infoRec->ReadPixmap && (pGC->alu == GXcopy) &&
    379            (pSrc->bitsPerPixel == pDst->bitsPerPixel) &&
    380           ((pGC->planemask & infoRec->FullPlanemasks[pSrc->depth - 1])
    381               == infoRec->FullPlanemasks[pSrc->depth - 1]))
    382         {
    383             XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE((PixmapPtr)(pDst));
    384 	    pixPriv->flags |= DIRTY;
    385 
    386             return (XAABitBlt( pSrc, pDst, pGC,
    387                 srcx, srcy, width, height, dstx, dsty,
    388                 XAADoImageRead, 0L));
    389         } else
    390 	if(infoRec->NeedToSync) {
    391 	   (*infoRec->Sync)(infoRec->pScrn);
    392 	    infoRec->NeedToSync = FALSE;
    393 	}
    394     }
    395 
    396     {
    397 	XAA_PIXMAP_OP_PROLOGUE(pGC, pDst);
    398 	ret = (*pGC->ops->CopyArea)(pSrc, pDst,
    399             pGC, srcx, srcy, width, height, dstx, dsty);
    400 	XAA_PIXMAP_OP_EPILOGUE(pGC);
    401     }
    402     return ret;
    403 }
    404 
    405 static RegionPtr
    406 XAACopyPlanePixmap(
    407     DrawablePtr	pSrc,
    408     DrawablePtr	pDst,
    409     GCPtr pGC,
    410     int	srcx, int srcy,
    411     int	width, int height,
    412     int	dstx, int dsty,
    413     unsigned long bitPlane
    414 ){
    415     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
    416     RegionPtr ret;
    417 
    418     XAA_PIXMAP_OP_PROLOGUE(pGC, pDst);
    419 
    420     if(infoRec->pScrn->vtSema &&
    421 	((pSrc->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pSrc))){
    422 	if(infoRec->NeedToSync) {
    423 	   (*infoRec->Sync)(infoRec->pScrn);
    424 	    infoRec->NeedToSync = FALSE;
    425 	}
    426     }
    427 
    428     ret = (*pGC->ops->CopyPlane)(pSrc, pDst,
    429 	       pGC, srcx, srcy, width, height, dstx, dsty, bitPlane);
    430     XAA_PIXMAP_OP_EPILOGUE(pGC);
    431     return ret;
    432 }
    433 
    434 static void
    435 XAAPolyPointPixmap(
    436     DrawablePtr pDraw,
    437     GCPtr pGC,
    438     int mode,
    439     int npt,
    440     xPoint *pptInit
    441 ){
    442     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    443     (*pGC->ops->PolyPoint)(pDraw, pGC, mode, npt, pptInit);
    444     XAA_PIXMAP_OP_EPILOGUE(pGC);
    445 }
    446 
    447 
    448 static void
    449 XAAPolylinesPixmap(
    450     DrawablePtr pDraw,
    451     GCPtr	pGC,
    452     int		mode,
    453     int		npt,
    454     DDXPointPtr pptInit
    455 ){
    456     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    457     (*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);
    458     XAA_PIXMAP_OP_EPILOGUE(pGC);
    459 }
    460 
    461 static void
    462 XAAPolySegmentPixmap(
    463     DrawablePtr	pDraw,
    464     GCPtr	pGC,
    465     int		nseg,
    466     xSegment	*pSeg
    467 ){
    468     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    469     (*pGC->ops->PolySegment)(pDraw, pGC, nseg, pSeg);
    470     XAA_PIXMAP_OP_EPILOGUE(pGC);
    471 }
    472 
    473 static void
    474 XAAPolyRectanglePixmap(
    475     DrawablePtr  pDraw,
    476     GCPtr        pGC,
    477     int	         nRectsInit,
    478     xRectangle  *pRectsInit
    479 ){
    480     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    481     (*pGC->ops->PolyRectangle)(pDraw, pGC, nRectsInit, pRectsInit);
    482     XAA_PIXMAP_OP_EPILOGUE(pGC);
    483 }
    484 
    485 static void
    486 XAAPolyArcPixmap(
    487     DrawablePtr	pDraw,
    488     GCPtr	pGC,
    489     int		narcs,
    490     xArc	*parcs
    491 ){
    492     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    493     (*pGC->ops->PolyArc)(pDraw, pGC, narcs, parcs);
    494     XAA_PIXMAP_OP_EPILOGUE(pGC);
    495 }
    496 
    497 static void
    498 XAAFillPolygonPixmap(
    499     DrawablePtr	pDraw,
    500     GCPtr	pGC,
    501     int		shape,
    502     int		mode,
    503     int		count,
    504     DDXPointPtr	ptsIn
    505 ){
    506     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    507     (*pGC->ops->FillPolygon)(pDraw, pGC, shape, mode, count, ptsIn);
    508     XAA_PIXMAP_OP_EPILOGUE(pGC);
    509 }
    510 
    511 
    512 static void
    513 XAAPolyFillRectPixmap(
    514     DrawablePtr	pDraw,
    515     GCPtr	pGC,
    516     int		nrectFill,
    517     xRectangle	*prectInit
    518 ){
    519     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    520     (*pGC->ops->PolyFillRect)(pDraw, pGC, nrectFill, prectInit);
    521     XAA_PIXMAP_OP_EPILOGUE(pGC);
    522 }
    523 
    524 
    525 static void
    526 XAAPolyFillArcPixmap(
    527     DrawablePtr	pDraw,
    528     GCPtr	pGC,
    529     int		narcs,
    530     xArc	*parcs
    531 ){
    532     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    533     (*pGC->ops->PolyFillArc)(pDraw, pGC, narcs, parcs);
    534     XAA_PIXMAP_OP_EPILOGUE(pGC);
    535 }
    536 
    537 static int
    538 XAAPolyText8Pixmap(
    539     DrawablePtr pDraw,
    540     GCPtr	pGC,
    541     int		x,
    542     int 	y,
    543     int 	count,
    544     char	*chars
    545 ){
    546     int ret;
    547 
    548     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    549     ret = (*pGC->ops->PolyText8)(pDraw, pGC, x, y, count, chars);
    550     XAA_PIXMAP_OP_EPILOGUE(pGC);
    551     return ret;
    552 }
    553 
    554 static int
    555 XAAPolyText16Pixmap(
    556     DrawablePtr pDraw,
    557     GCPtr	pGC,
    558     int		x,
    559     int		y,
    560     int 	count,
    561     unsigned short *chars
    562 ){
    563     int ret;
    564 
    565     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    566     ret = (*pGC->ops->PolyText16)(pDraw, pGC, x, y, count, chars);
    567     XAA_PIXMAP_OP_EPILOGUE(pGC);
    568     return ret;
    569 }
    570 
    571 static void
    572 XAAImageText8Pixmap(
    573     DrawablePtr pDraw,
    574     GCPtr	pGC,
    575     int		x,
    576     int		y,
    577     int 	count,
    578     char	*chars
    579 ){
    580     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    581     (*pGC->ops->ImageText8)(pDraw, pGC, x, y, count, chars);
    582     XAA_PIXMAP_OP_EPILOGUE(pGC);
    583 }
    584 static void
    585 XAAImageText16Pixmap(
    586     DrawablePtr pDraw,
    587     GCPtr	pGC,
    588     int		x,
    589     int		y,
    590     int 	count,
    591     unsigned short *chars
    592 ){
    593     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    594     (*pGC->ops->ImageText16)(pDraw, pGC, x, y, count, chars);
    595     XAA_PIXMAP_OP_EPILOGUE(pGC);
    596 }
    597 
    598 
    599 static void
    600 XAAImageGlyphBltPixmap(
    601     DrawablePtr pDraw,
    602     GCPtr pGC,
    603     int xInit, int yInit,
    604     unsigned int nglyph,
    605     CharInfoPtr *ppci,
    606     pointer pglyphBase
    607 ){
    608     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    609     (*pGC->ops->ImageGlyphBlt)(pDraw, pGC, xInit, yInit, nglyph,
    610 					ppci, pglyphBase);
    611     XAA_PIXMAP_OP_EPILOGUE(pGC);
    612 }
    613 
    614 static void
    615 XAAPolyGlyphBltPixmap(
    616     DrawablePtr pDraw,
    617     GCPtr pGC,
    618     int xInit, int yInit,
    619     unsigned int nglyph,
    620     CharInfoPtr *ppci,
    621     pointer pglyphBase
    622 ){
    623     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    624     (*pGC->ops->PolyGlyphBlt)(pDraw, pGC, xInit, yInit, nglyph,
    625 				ppci, pglyphBase);
    626     XAA_PIXMAP_OP_EPILOGUE(pGC);
    627 }
    628 
    629 static void
    630 XAAPushPixelsPixmap(
    631     GCPtr	pGC,
    632     PixmapPtr	pBitMap,
    633     DrawablePtr pDraw,
    634     int	dx, int dy, int xOrg, int yOrg
    635 ){
    636     XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
    637     (*pGC->ops->PushPixels)(pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
    638     XAA_PIXMAP_OP_EPILOGUE(pGC);
    639 }
    640 
    641 GCOps XAAPixmapOps = {
    642     XAAFillSpansPixmap, XAASetSpansPixmap,
    643     XAAPutImagePixmap, XAACopyAreaPixmap,
    644     XAACopyPlanePixmap, XAAPolyPointPixmap,
    645     XAAPolylinesPixmap, XAAPolySegmentPixmap,
    646     XAAPolyRectanglePixmap, XAAPolyArcPixmap,
    647     XAAFillPolygonPixmap, XAAPolyFillRectPixmap,
    648     XAAPolyFillArcPixmap, XAAPolyText8Pixmap,
    649     XAAPolyText16Pixmap, XAAImageText8Pixmap,
    650     XAAImageText16Pixmap, XAAImageGlyphBltPixmap,
    651     XAAPolyGlyphBltPixmap, XAAPushPixelsPixmap,
    652 };
    653