自学教程：C++ GetPictureScreen函数代码示例

/** Fill a rectangle on the appropriate screen by combining the color *  with the dest picture in the area specified by the list of *  rectangles.  For a complete description see the protocol document of *  the RENDER library. */voiddmxCompositeRects(CARD8 op,                  PicturePtr pDst,                  xRenderColor * color, int nRect, xRectangle *rects){    ScreenPtr pScreen = pDst->pDrawable->pScreen;    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];    PictureScreenPtr ps = GetPictureScreen(pScreen);    dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pDst);    DMX_UNWRAP(CompositeRects, dmxScreen, ps);#if 0    if (ps->CompositeRects)        ps->CompositeRects(op, pDst, color, nRect, rects);#endif    /* CompositeRects on back-end server */    if (pPictPriv->pict) {        XRenderFillRectangles(dmxScreen->beDisplay,                              op,                              pPictPriv->pict,                              (XRenderColor *) color,                              (XRectangle *) rects, nRect);        dmxSync(dmxScreen, FALSE);    }    DMX_WRAP(CompositeRects, dmxCompositeRects, dmxScreen, ps);}

intmiChangePictureClip(PicturePtr pPicture, int type, void *value, int n){    ScreenPtr pScreen = pPicture->pDrawable->pScreen;    PictureScreenPtr ps = GetPictureScreen(pScreen);    RegionPtr clientClip;    switch (type) {    case CT_PIXMAP:        /* convert the pixmap to a region */        clientClip = BitmapToRegion(pScreen, (PixmapPtr) value);        if (!clientClip)            return BadAlloc;        (*pScreen->DestroyPixmap) ((PixmapPtr) value);        break;    case CT_REGION:        clientClip = value;        break;    case CT_NONE:        clientClip = 0;        break;    default:        clientClip = RegionFromRects(n, (xRectangle *) value, type);        if (!clientClip)            return BadAlloc;        free(value);        break;    }    (*ps->DestroyPictureClip) (pPicture);    pPicture->clientClip = clientClip;    pPicture->stateChanges |= CPClipMask;    return Success;}

/** Initialize the RENDER extension, allocate the picture privates and *  wrap mi function hooks.  If the shadow frame buffer is used, then *  call the appropriate fb initialization function. */BooldmxPictureInit(ScreenPtr pScreen, PictFormatPtr formats, int nformats){    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];    PictureScreenPtr ps;    if (!miPictureInit(pScreen, formats, nformats))        return FALSE;    if (!dixRegisterPrivateKey        (&dmxPictPrivateKeyRec, PRIVATE_PICTURE, sizeof(dmxPictPrivRec)))        return FALSE;    ps = GetPictureScreen(pScreen);    DMX_WRAP(CreatePicture, dmxCreatePicture, dmxScreen, ps);    DMX_WRAP(DestroyPicture, dmxDestroyPicture, dmxScreen, ps);    DMX_WRAP(ChangePictureClip, dmxChangePictureClip, dmxScreen, ps);    DMX_WRAP(DestroyPictureClip, dmxDestroyPictureClip, dmxScreen, ps);    DMX_WRAP(ChangePicture, dmxChangePicture, dmxScreen, ps);    DMX_WRAP(ValidatePicture, dmxValidatePicture, dmxScreen, ps);    DMX_WRAP(Composite, dmxComposite, dmxScreen, ps);    DMX_WRAP(Glyphs, dmxGlyphs, dmxScreen, ps);    DMX_WRAP(CompositeRects, dmxCompositeRects, dmxScreen, ps);    DMX_WRAP(Trapezoids, dmxTrapezoids, dmxScreen, ps);    DMX_WRAP(Triangles, dmxTriangles, dmxScreen, ps);    return TRUE;}

/** Destroy the picture's list of clip rectangles. */voiddmxDestroyPictureClip(PicturePtr pPicture){    ScreenPtr pScreen = pPicture->pDrawable->pScreen;    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];    PictureScreenPtr ps = GetPictureScreen(pScreen);    dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture);    DMX_UNWRAP(DestroyPictureClip, dmxScreen, ps);#if 1    if (ps->DestroyPictureClip)        ps->DestroyPictureClip(pPicture);#endif    /* Destroy picture clip rects on back-end server */    if (pPictPriv->pict) {        XRenderSetPictureClipRectangles(dmxScreen->beDisplay,                                        pPictPriv->pict, 0, 0, NULL, 0);        dmxSync(dmxScreen, FALSE);    }    else {        /* FIXME: Handle destroying clip region when offscreen */    }    DMX_WRAP(DestroyPictureClip, dmxDestroyPictureClip, dmxScreen, ps);}

static voidRootlessComposite(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);    WindowPtr dstWin;    dstWin  = (pDst->pDrawable->type  == DRAWABLE_WINDOW) ?        (WindowPtr)pDst->pDrawable  :  NULL;    // SCREEN_UNWRAP(ps, Composite);    ps->Composite = SCREENREC(pScreen)->Composite;    ps->Composite(op, pSrc, pMask, pDst,                  xSrc, ySrc, xMask, yMask,                  xDst, yDst, width, height);    if (dstWin  && IsFramedWindow(dstWin)) {        RootlessDamageRect(dstWin, xDst, yDst, width, height);    }    ps->Composite = RootlessComposite;    // SCREEN_WRAP(ps, Composite);}

voidrdpGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,          PictFormatPtr maskFormat,          INT16 xSrc, INT16 ySrc, int nlists, GlyphListPtr lists,          GlyphPtr* glyphs){  PictureScreenPtr ps;  int index;  LLOGLN(10, ("rdpGlyphs:"));  LLOGLN(10, ("rdpGlyphs: nlists %d len %d", nlists, lists->len));  rdpup_set_hints(1, 1);  for (index = 0; index < lists->len; index++)  {    LLOGLN(10, ("  index %d size %d refcnt %d width %d height %d",           index, (int)(glyphs[index]->size), (int)(glyphs[index]->refcnt),           glyphs[index]->info.width, glyphs[index]->info.height));  }  ps = GetPictureScreen(g_pScreen);  ps->Glyphs = g_rdpScreen.Glyphs;  ps->Glyphs(op, pSrc, pDst, maskFormat, xSrc, ySrc,             nlists, lists, glyphs);  ps->Glyphs = rdpGlyphs;  rdpup_set_hints(0, 1);  LLOGLN(10, ("rdpGlyphs: out"));}

BoolLayerFinishInit (ScreenPtr pScreen){#ifdef RENDER    PictureScreenPtr	ps = GetPictureScreen (pScreen);#endif        pScreen->CloseScreen = layerCloseScreen;    pScreen->CreateWindow = layerCreateWindow;    pScreen->DestroyWindow = layerDestroyWindow;    pScreen->ChangeWindowAttributes = layerChangeWindowAttributes;    pScreen->PaintWindowBackground = layerPaintWindowBackground;    pScreen->PaintWindowBorder = layerPaintWindowBorder;    pScreen->CopyWindow = layerCopyWindow;    pScreen->CreatePixmap = layerCreatePixmap;    pScreen->DestroyPixmap = layerDestroyPixmap;    pScreen->CreateGC = layerCreateGC;#ifdef RENDER    if (ps)    {	ps->Composite = layerComposite;	ps->Glyphs = layerGlyphs;	ps->CompositeRects = layerCompositeRects;    }#endif        return TRUE;}

_X_EXPORT BoolPictureSetFilterAlias (ScreenPtr pScreen, char *filter, char *alias){    PictureScreenPtr    ps = GetPictureScreen(pScreen);    int			filter_id = PictureGetFilterId (filter, -1, FALSE);    int			alias_id = PictureGetFilterId (alias, -1, TRUE);    int			i;    if (filter_id < 0 || alias_id < 0)	return FALSE;    for (i = 0; i < ps->nfilterAliases; i++)	if (ps->filterAliases[i].alias_id == alias_id)	    break;    if (i == ps->nfilterAliases)    {	PictFilterAliasPtr  aliases;	if (ps->filterAliases)	    aliases = xrealloc (ps->filterAliases,				(ps->nfilterAliases + 1) *				sizeof (PictFilterAliasRec));	else	    aliases = xalloc (sizeof (PictFilterAliasRec));	if (!aliases)	    return FALSE;	ps->filterAliases = aliases;	ps->filterAliases[i].alias = PictureGetFilterName (alias_id);	ps->filterAliases[i].alias_id = alias_id;	ps->nfilterAliases++;    }    ps->filterAliases[i].filter_id = filter_id;    return TRUE;}

_X_EXPORT intPictureAddFilter (ScreenPtr			    pScreen,		  char				    *filter,		  PictFilterValidateParamsProcPtr   ValidateParams){    PictureScreenPtr    ps = GetPictureScreen(pScreen);    int			id = PictureGetFilterId (filter, -1,  TRUE);    int			i;    PictFilterPtr	filters;    if (id < 0)	return -1;    /*     * It's an error to attempt to reregister a filter     */    for (i = 0; i < ps->nfilters; i++)	if (ps->filters[i].id == id)	    return -1;    if (ps->filters)	filters = xrealloc (ps->filters, (ps->nfilters + 1) * sizeof (PictFilterRec));    else	filters = xalloc (sizeof (PictFilterRec));    if (!filters)	return -1;    ps->filters = filters;    i = ps->nfilters++;    ps->filters[i].name = PictureGetFilterName (id);    ps->filters[i].id = id;    ps->filters[i].ValidateParams = ValidateParams;    return id;}

/* * xprSetupScreen *  Setup the screen for rootless access. */static BoolxprSetupScreen(int index, ScreenPtr pScreen){    // Add alpha protecting replacements for fb screen functions    pScreen->PaintWindowBackground = SafeAlphaPaintWindow;    pScreen->PaintWindowBorder = SafeAlphaPaintWindow;#ifdef RENDER    {        PictureScreenPtr ps = GetPictureScreen(pScreen);        ps->Composite = SafeAlphaComposite;    }#endif /* RENDER */    // Initialize accelerated rootless drawing    // Note that this must be done before DamageSetup().    RootlessAccelInit(pScreen);#ifdef DAMAGE    // The Damage extension needs to wrap underneath the    // generic rootless layer, so do it now.    if (!DamageSetup(pScreen))        return FALSE;#endif    // Initialize generic rootless code    if (!xprInit(pScreen))        return FALSE;    return DRIFinishScreenInit(pScreen);}

voidrdpComposite(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;    rdpPtr dev;    PictureScreenPtr ps;    BoxRec box;    RegionRec reg;    LLOGLN(10, ("rdpComposite:"));    pScreen = pDst->pDrawable->pScreen;    dev = rdpGetDevFromScreen(pScreen);    dev->counts.rdpCompositeCallCount++;    box.x1 = xDst + pDst->pDrawable->x;    box.y1 = yDst + pDst->pDrawable->y;    box.x2 = box.x1 + width;    box.y2 = box.y1 + height;    rdpRegionInit(&reg, &box, 0);    if (pDst->pCompositeClip != NULL)    {        rdpRegionIntersect(&reg, pDst->pCompositeClip, &reg);    }    ps = GetPictureScreen(pScreen);    /* do original call */    rdpCompositeOrg(ps, dev, op, pSrc, pMask, pDst, xSrc, ySrc,                    xMask, yMask, xDst, yDst, width, height);    rdpClientConAddAllReg(dev, &reg, pDst->pDrawable);    rdpRegionUninit(&reg);}

/** Change the picture's list of clip rectangles. */int dmxChangePictureClip(PicturePtr pPicture, int clipType,			 pointer value, int n){    ScreenPtr         pScreen   = pPicture->pDrawable->pScreen;    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];    PictureScreenPtr  ps        = GetPictureScreen(pScreen);    dmxPictPrivPtr    pPictPriv = DMX_GET_PICT_PRIV(pPicture);    DMX_UNWRAP(ChangePictureClip, dmxScreen, ps);#if 1    if (ps->ChangePictureClip)	ps->ChangePictureClip(pPicture, clipType, value, n);#endif    /* Change picture clip rects on back-end server */    if (pPictPriv->pict) {	/* The clip has already been changed into a region by the mi	 * routine called above.	 */	if (pPicture->clientClip) {	    RegionPtr   pClip = pPicture->clientClip;	    BoxPtr      pBox  = REGION_RECTS(pClip);	    int         nBox  = REGION_NUM_RECTS(pClip);	    XRectangle *pRects;	    XRectangle *pRect;	    int         nRects;	    nRects = nBox;	    pRects = pRect = xalloc(nRects * sizeof(*pRect));	    while (nBox--) {		pRect->x      = pBox->x1;		pRect->y      = pBox->y1;		pRect->width  = pBox->x2 - pBox->x1;		pRect->height = pBox->y2 - pBox->y1;		pBox++;		pRect++;	    }	    XRenderSetPictureClipRectangles(dmxScreen->beDisplay,					    pPictPriv->pict,					    0, 0,					    pRects,					    nRects);	    xfree(pRects);	} else {	    XRenderSetPictureClipRectangles(dmxScreen->beDisplay,					    pPictPriv->pict,					    0, 0, NULL, 0);	}	dmxSync(dmxScreen, FALSE);    } else {	/* FIXME: Handle saving clip region when offscreen */    }    DMX_WRAP(ChangePictureClip, dmxChangePictureClip, dmxScreen, ps);        return Success;}

voidKdPictureInitAsync (ScreenPtr pScreen){    PictureScreenPtr    ps;    ps = GetPictureScreen(pScreen);    ps->Composite = KdCheckComposite;}

voidGlyphUninit (ScreenPtr pScreen){    PictureScreenPtr ps = GetPictureScreen (pScreen);    GlyphPtr	     glyph;    int		     fdepth, i;    globalTotalGlyphPrivateSize -= ps->totalGlyphPrivateSize;    for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++)    {	if (!globalGlyphs[fdepth].hashSet)	    continue;		for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++)	{	    glyph = globalGlyphs[fdepth].table[i].glyph;	    if (glyph && glyph != DeletedGlyph)	    {		(*ps->UnrealizeGlyph) (pScreen, glyph);				if (globalTotalGlyphPrivateSize)		{		    if (!ReallocGlobalGlyphPrivate (glyph))			return;		}		else		{		    if (glyph->devPrivates)			xfree (glyph->devPrivates);		    glyph->devPrivates = NULL;		}	    }	}    }    if (globalTotalGlyphPrivateSize)	SetGlyphScreenPrivateOffsets ();    for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++)    {	if (!globalGlyphs[fdepth].hashSet)	    continue;		for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++)	{	    glyph = globalGlyphs[fdepth].table[i].glyph;    	    if (glyph && glyph != DeletedGlyph)	    {		if (globalTotalGlyphPrivateSize)		    SetGlyphPrivatePointers (glyph);	    }	}    }    if (ps->glyphPrivateSizes)	xfree (ps->glyphPrivateSizes);}

voidPictureResetFilters (ScreenPtr pScreen){    PictureScreenPtr    ps = GetPictureScreen(pScreen);    xfree (ps->filters);    xfree (ps->filterAliases);    PictureFreeFilterIds ();}

intSetPictureFilter (PicturePtr pPicture, char *name, int len, xFixed *params, int nparams){    PictFilterPtr	pFilter;    xFixed		*new_params;    int			i, s, result;    pFilter = PictureFindFilter (screenInfo.screens[0], name, len);    if (pPicture->pDrawable == NULL) {	/* For source pictures, the picture isn't tied to a screen.  So, ensure	 * that all screens can handle a filter we set for the picture.	 */	for (s = 0; s < screenInfo.numScreens; s++) {	    if (PictureFindFilter (screenInfo.screens[s], name, len)->id !=		pFilter->id)	    {		return BadMatch;	    }	}    }    if (!pFilter)	return BadName;    if (pFilter->ValidateParams)    {	if (!(*pFilter->ValidateParams) (pPicture, pFilter->id, params, nparams))	    return BadMatch;    }    else if (nparams)	return BadMatch;    if (nparams != pPicture->filter_nparams)    {	new_params = xalloc (nparams * sizeof (xFixed));	if (!new_params)	    return BadAlloc;	xfree (pPicture->filter_params);	pPicture->filter_params = new_params;	pPicture->filter_nparams = nparams;    }    for (i = 0; i < nparams; i++)	pPicture->filter_params[i] = params[i];    pPicture->filter = pFilter->id;    if (pPicture->pDrawable) {	ScreenPtr pScreen = pPicture->pDrawable->pScreen;	PictureScreenPtr ps = GetPictureScreen(pScreen);	result = (*ps->ChangePictureFilter) (pPicture, pPicture->filter,					     params, nparams);	return result;    }    return Success;}

static voidRootlessWrap(ScreenPtr pScreen){    RootlessScreenRec *s = (RootlessScreenRec*)            pScreen->devPrivates[rootlessScreenPrivateIndex].ptr;#define WRAP(a) /    if (pScreen->a) { /        s->a = pScreen->a; /    } else { /        RL_DEBUG_MSG("null screen fn " #a "/n"); /        s->a = NULL; /    } /    pScreen->a = Rootless##a    WRAP(CloseScreen);    WRAP(CreateGC);    WRAP(PaintWindowBackground);    WRAP(PaintWindowBorder);    WRAP(CopyWindow);    WRAP(GetImage);    WRAP(CreateWindow);    WRAP(DestroyWindow);    WRAP(RealizeWindow);    WRAP(UnrealizeWindow);    WRAP(MoveWindow);    WRAP(PositionWindow);    WRAP(ResizeWindow);    WRAP(RestackWindow);    WRAP(ChangeBorderWidth);    WRAP(MarkOverlappedWindows);    WRAP(ValidateTree);    WRAP(ChangeWindowAttributes);#ifdef SHAPE    WRAP(SetShape);#endif#ifdef RENDER    {        // Composite and Glyphs don't use normal screen wrapping        PictureScreenPtr ps = GetPictureScreen(pScreen);        s->Composite = ps->Composite;        ps->Composite = RootlessComposite;        s->Glyphs = ps->Glyphs;        ps->Glyphs = RootlessGlyphs;    }#endif    // WRAP(ClearToBackground); fixme put this back? useful for shaped wins?    // WRAP(RestoreAreas); fixme put this back?#undef WRAP}

BoolGlyphFinishInit (ScreenPtr pScreen){    PictureScreenPtr ps = GetPictureScreen (pScreen);    if (ps->totalGlyphPrivateSize)    {	GlyphPtr glyph;	int	 fdepth, i;		globalTotalGlyphPrivateSize += ps->totalGlyphPrivateSize;		for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++)	{	    if (!globalGlyphs[fdepth].hashSet)		continue;			    for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++)	    {		glyph = globalGlyphs[fdepth].table[i].glyph;		if (glyph && glyph != DeletedGlyph)		{		    if (!ReallocGlobalGlyphPrivate (glyph))			return FALSE;		}	    }	}	SetGlyphScreenPrivateOffsets ();	for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++)	{	    if (!globalGlyphs[fdepth].hashSet)		continue;			    for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++)	    {		glyph = globalGlyphs[fdepth].table[i].glyph;		if (glyph && glyph != DeletedGlyph)		{		    SetGlyphPrivatePointers (glyph);					    if (!(*ps->RealizeGlyph) (pScreen, glyph))			return FALSE;		}	    }	}    }    else	ps->glyphPrivateOffset = 0;        return TRUE;}

voidmiTrapezoids (CARD8	    op,	      PicturePtr    pSrc,	      PicturePtr    pDst,	      PictFormatPtr maskFormat,	      INT16	    xSrc,	      INT16	    ySrc,	      int	    ntrap,	      xTrapezoid    *traps){    ScreenPtr		pScreen = pDst->pDrawable->pScreen;    PictureScreenPtr    ps = GetPictureScreen(pScreen);    /*     * Check for solid alpha add     */    if (op == PictOpAdd && miIsSolidAlpha (pSrc))    {	for (; ntrap; ntrap--, traps++)	    (*ps->RasterizeTrapezoid) (pDst, traps, 0, 0);    }     else if (maskFormat)    {	PicturePtr	pPicture;	BoxRec		bounds;	INT16		xDst, yDst;	INT16		xRel, yRel;		xDst = traps[0].left.p1.x >> 16;	yDst = traps[0].left.p1.y >> 16;	miTrapezoidBounds (ntrap, traps, &bounds);	if (bounds.y1 >= bounds.y2 || bounds.x1 >= bounds.x2)	    return;	pPicture = miCreateAlphaPicture (pScreen, pDst, maskFormat,					 bounds.x2 - bounds.x1,					 bounds.y2 - bounds.y1);	if (!pPicture)	    return;	for (; ntrap; ntrap--, traps++)	    (*ps->RasterizeTrapezoid) (pPicture, traps, 				       -bounds.x1, -bounds.y1);	xRel = bounds.x1 + xSrc - xDst;	yRel = bounds.y1 + ySrc - yDst;	CompositePicture (op, pSrc, pPicture, pDst,			  xRel, yRel, 0, 0, bounds.x1, bounds.y1,			  bounds.x2 - bounds.x1,			  bounds.y2 - bounds.y1);	FreePicture (pPicture, 0);    }    else    {	if (pDst->polyEdge == PolyEdgeSharp)

BoolGlyphInit(ScreenPtr pScreen){    PictureScreenPtr ps = GetPictureScreen(pScreen);    ps->totalGlyphPrivateSize = 0;    ps->glyphPrivateSizes = 0;    ps->glyphPrivateLen = 0;    ps->glyphPrivateOffset = -1;    return TRUE;}

static voidRootlessWrap(ScreenPtr pScreen){    RootlessScreenRec *s = SCREENREC(pScreen);#define WRAP(a) /    if (pScreen->a) { /        s->a = pScreen->a; /    } else { /        RL_DEBUG_MSG("null screen fn " #a "/n"); /        s->a = NULL; /    } /    pScreen->a = Rootless##a    WRAP(CreateScreenResources);    WRAP(CloseScreen);    WRAP(CreateGC);    WRAP(CopyWindow);    WRAP(GetImage);    WRAP(SourceValidate);    WRAP(CreateWindow);    WRAP(DestroyWindow);    WRAP(RealizeWindow);    WRAP(UnrealizeWindow);    WRAP(MoveWindow);    WRAP(PositionWindow);    WRAP(ResizeWindow);    WRAP(RestackWindow);    WRAP(ReparentWindow);    WRAP(ChangeBorderWidth);    WRAP(MarkOverlappedWindows);    WRAP(ValidateTree);    WRAP(ChangeWindowAttributes);    WRAP(InstallColormap);    WRAP(UninstallColormap);    WRAP(StoreColors);    WRAP(SetShape);    {        // Composite and Glyphs don't use normal screen wrapping        PictureScreenPtr ps = GetPictureScreen(pScreen);        s->Composite = ps->Composite;        ps->Composite = RootlessComposite;        s->Glyphs = ps->Glyphs;        ps->Glyphs = RootlessGlyphs;    }    // WRAP(ClearToBackground); fixme put this back? useful for shaped wins?#undef WRAP}

static voidShadowComposite(    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;    ShadowScreenPtr pPriv = GET_SCREEN_PRIVATE(pScreen);    PictureScreenPtr ps = GetPictureScreen(pScreen);    BoxRec box;    BoxPtr extents;    Bool boxNotEmpty = FALSE;    if (pPriv->vtSema	&& pDst->pDrawable->type == DRAWABLE_WINDOW) {	box.x1 = pDst->pDrawable->x + xDst;	box.y1 = pDst->pDrawable->y + yDst;	box.x2 = box.x1 + width;	box.y2 = box.y1 + height;	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;		if (BOX_NOT_EMPTY(box)) {	    if (pPriv->preRefresh)		(*pPriv->preRefresh)(pPriv->pScrn, 1, &box);	    boxNotEmpty = TRUE;	}    }        ps->Composite = pPriv->Composite;    (*ps->Composite)(op, pSrc, pMask, pDst, xSrc, ySrc,		     xMask, yMask, xDst, yDst, width, height);    ps->Composite = ShadowComposite;    if (pPriv->postRefresh && boxNotEmpty) {        (*pPriv->postRefresh)(pPriv->pScrn, 1, &box);    }}

/* Screen initialization/teardown */voidmiInitializeCompositeWrapper(ScreenPtr pScreen){    cwScreenPtr pScreenPriv;    if (cwDisabled[pScreen->myNum])	return;    if (cwGeneration != serverGeneration)    {	cwScreenIndex = AllocateScreenPrivateIndex();	if (cwScreenIndex < 0)	    return;	cwGCIndex = AllocateGCPrivateIndex();	cwWindowIndex = AllocateWindowPrivateIndex();#ifdef RENDER	cwPictureIndex = AllocatePicturePrivateIndex();#endif	cwGeneration = serverGeneration;    }    if (!AllocateGCPrivate(pScreen, cwGCIndex, sizeof(cwGCRec)))	return;    if (!AllocateWindowPrivate(pScreen, cwWindowIndex, 0))	return;#ifdef RENDER    if (!AllocatePicturePrivate(pScreen, cwPictureIndex, 0))	return;#endif    pScreenPriv = (cwScreenPtr)xalloc(sizeof(cwScreenRec));    if (!pScreenPriv)	return;    pScreen->devPrivates[cwScreenIndex].ptr = (pointer)pScreenPriv;        SCREEN_EPILOGUE(pScreen, CloseScreen, cwCloseScreen);    SCREEN_EPILOGUE(pScreen, GetImage, cwGetImage);    SCREEN_EPILOGUE(pScreen, GetSpans, cwGetSpans);    SCREEN_EPILOGUE(pScreen, CreateGC, cwCreateGC);    SCREEN_EPILOGUE(pScreen, PaintWindowBackground, cwPaintWindowBackground);    SCREEN_EPILOGUE(pScreen, PaintWindowBorder, cwPaintWindowBorder);    SCREEN_EPILOGUE(pScreen, CopyWindow, cwCopyWindow);    SCREEN_EPILOGUE(pScreen, SetWindowPixmap, cwSetWindowPixmap);    SCREEN_EPILOGUE(pScreen, GetWindowPixmap, cwGetWindowPixmap);#ifdef RENDER    if (GetPictureScreen (pScreen))	cwInitializeRender(pScreen);#endif}

voidmiTriangles (CARD8	    op,	     PicturePtr	    pSrc,	     PicturePtr	    pDst,	     PictFormatPtr  maskFormat,	     INT16	    xSrc,	     INT16	    ySrc,	     int	    ntri,	     xTriangle	    *tris){    ScreenPtr		pScreen = pDst->pDrawable->pScreen;    PictureScreenPtr    ps = GetPictureScreen(pScreen);        /*     * Check for solid alpha add     */    if (op == PictOpAdd && miIsSolidAlpha (pSrc))    {	(*ps->AddTriangles) (pDst, 0, 0, ntri, tris);    }    else if (maskFormat)    {	BoxRec		bounds;	PicturePtr	pPicture;	INT16		xDst, yDst;	INT16		xRel, yRel;		xDst = tris[0].p1.x >> 16;	yDst = tris[0].p1.y >> 16;	miTriangleBounds (ntri, tris, &bounds);	if (bounds.x2 <= bounds.x1 || bounds.y2 <= bounds.y1)	    return;	pPicture = miCreateAlphaPicture (pScreen, pDst, maskFormat,					 bounds.x2 - bounds.x1,					 bounds.y2 - bounds.y1);	if (!pPicture)	    return;	(*ps->AddTriangles) (pPicture, -bounds.x1, -bounds.y1, ntri, tris);		xRel = bounds.x1 + xSrc - xDst;	yRel = bounds.y1 + ySrc - yDst;	CompositePicture (op, pSrc, pPicture, pDst,			  xRel, yRel, 0, 0, bounds.x1, bounds.y1,			  bounds.x2 - bounds.x1, bounds.y2 - bounds.y1);	FreePicture (pPicture, 0);    }    else    {	if (pDst->polyEdge == PolyEdgeSharp)

static voidVGAarbiterCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor * color,                         int nRect, xRectangle *rects){    ScreenPtr pScreen = pDst->pDrawable->pScreen;    PictureScreenPtr ps = GetPictureScreen(pScreen);    PICTURE_PROLOGUE(CompositeRects);    VGAGet(pScreen);    (*ps->CompositeRects) (op, pDst, color, nRect, rects);    VGAPut();    PICTURE_EPILOGUE(CompositeRects, VGAarbiterCompositeRects);}

voidCompositeGlyphs(CARD8 op,                PicturePtr pSrc,                PicturePtr pDst,                PictFormatPtr maskFormat,                INT16 xSrc,                INT16 ySrc, int nlist, GlyphListPtr lists, GlyphPtr * glyphs){    PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen);    ValidatePicture(pSrc);    ValidatePicture(pDst);    (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, lists,                   glyphs);}

static voidVGAarbiterGlyphs(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);    PICTURE_PROLOGUE(Glyphs);    VGAGet(pScreen);    (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);    VGAPut();    PICTURE_EPILOGUE(Glyphs, VGAarbiterGlyphs);}

BooltridentDrawInit (ScreenPtr pScreen){    SetupTrident(pScreen);    tridentScreenInfo(pScreenPriv);    PictureScreenPtr    ps = GetPictureScreen(pScreen);        if (!kaaDrawInit (pScreen, &tridentKaa))	return FALSE;    if (ps && tridents->off_screen)	ps->Composite = tridentComposite;        return TRUE;}

static voidVGAarbiterComposite(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);    PICTURE_PROLOGUE(Composite);    VGAGet(pScreen);    (*ps->Composite) (op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst,                      yDst, width, height);    VGAPut();    PICTURE_EPILOGUE(Composite, VGAarbiterComposite);}

voidrdpGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,          PictFormatPtr maskFormat,          INT16 xSrc, INT16 ySrc, int nlists, GlyphListPtr lists,          GlyphPtr *glyphs){    ScreenPtr pScreen;    rdpPtr dev;    PictureScreenPtr ps;    LLOGLN(10, ("rdpGlyphs:"));    pScreen = pDst->pDrawable->pScreen;    dev = rdpGetDevFromScreen(pScreen);    ps = GetPictureScreen(pScreen);    rdpGlyphsOrg(ps, dev, op, pSrc, pDst, maskFormat, xSrc, ySrc,                 nlists, lists, glyphs);}