xaaGC.c revision 706f2543 
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
22static void XAAValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
23static void XAAChangeGC(GCPtr pGC, unsigned long mask);
24static void XAACopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
25static void XAADestroyGC(GCPtr pGC);
26static void XAAChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects);
27static void XAADestroyClip(GCPtr pGC);
28static void XAACopyClip(GCPtr pgcDst, GCPtr pgcSrc);
29
30GCFuncs XAAGCFuncs = {
31    XAAValidateGC, XAAChangeGC, XAACopyGC, XAADestroyGC,
32    XAAChangeClip, XAADestroyClip, XAACopyClip
33};
34
35extern GCOps XAAPixmapOps;
36
37Bool
38XAACreateGC(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
60static void
61XAAValidateGC(
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
235static void
236XAADestroyGC(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
250static void
251XAAChangeGC (
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
276static void
277XAACopyGC (
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}
286static void
287XAAChangeClip (
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
298static void
299XAACopyClip(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
306static void
307XAADestroyClip(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
318static void
319XAAFillSpansPixmap(
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
332static void
333XAASetSpansPixmap(
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
347static void
348XAAPutImagePixmap(
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
363static RegionPtr
364XAACopyAreaPixmap(
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
405static RegionPtr
406XAACopyPlanePixmap(
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
434static void
435XAAPolyPointPixmap(
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
448static void
449XAAPolylinesPixmap(
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
461static void
462XAAPolySegmentPixmap(
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
473static void
474XAAPolyRectanglePixmap(
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
485static void
486XAAPolyArcPixmap(
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
497static void
498XAAFillPolygonPixmap(
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
512static void
513XAAPolyFillRectPixmap(
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
525static void
526XAAPolyFillArcPixmap(
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
537static int
538XAAPolyText8Pixmap(
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
554static int
555XAAPolyText16Pixmap(
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
571static void
572XAAImageText8Pixmap(
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}
584static void
585XAAImageText16Pixmap(
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
599static void
600XAAImageGlyphBltPixmap(
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
614static void
615XAAPolyGlyphBltPixmap(
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
629static void
630XAAPushPixelsPixmap(
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
641GCOps 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