/** 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. */
void
dmxCompositeRects(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);
}
int
miChangePictureClip(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. */
Bool
dmxPictureInit(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. */
void
dmxDestroyPictureClip(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 void
RootlessComposite(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);
}
void
rdpGlyphs(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"));
}
Bool
LayerFinishInit (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 Bool
PictureSetFilterAlias (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 int
PictureAddFilter (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 Bool
xprSetupScreen(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);
}
void
rdpComposite(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(®, &box, 0);
if (pDst->pCompositeClip != NULL)
{
rdpRegionIntersect(®, pDst->pCompositeClip, ®);
}
ps = GetPictureScreen(pScreen);
/* do original call */
rdpCompositeOrg(ps, dev, op, pSrc, pMask, pDst, xSrc, ySrc,
xMask, yMask, xDst, yDst, width, height);
rdpClientConAddAllReg(dev, ®, pDst->pDrawable);
rdpRegionUninit(®);
}
/** 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;
}
void
KdPictureInitAsync (ScreenPtr pScreen)
{
PictureScreenPtr ps;
ps = GetPictureScreen(pScreen);
ps->Composite = KdCheckComposite;
}
void
GlyphUninit (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);
}
void
PictureResetFilters (ScreenPtr pScreen)
{
PictureScreenPtr ps = GetPictureScreen(pScreen);
xfree (ps->filters);
xfree (ps->filterAliases);
PictureFreeFilterIds ();
}
int
SetPictureFilter (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 void
RootlessWrap(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
}
Bool
GlyphFinishInit (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;
}
void
miTrapezoids (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)
Bool
GlyphInit(ScreenPtr pScreen)
{
PictureScreenPtr ps = GetPictureScreen(pScreen);
ps->totalGlyphPrivateSize = 0;
ps->glyphPrivateSizes = 0;
ps->glyphPrivateLen = 0;
ps->glyphPrivateOffset = -1;
return TRUE;
}
static void
RootlessWrap(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 void
ShadowComposite(
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 */
void
miInitializeCompositeWrapper(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
}
void
miTriangles (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 void
VGAarbiterCompositeRects(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);
}
void
CompositeGlyphs(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 void
VGAarbiterGlyphs(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);
}
Bool
tridentDrawInit (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 void
VGAarbiterComposite(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);
}
void
rdpGlyphs(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);
}
