/** Create a graphics context on the back-end server associated /a pGC's
* screen. */
Bool
dmxCreateGC(GCPtr pGC)
{
ScreenPtr pScreen = pGC->pScreen;
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
Bool ret;
DMX_UNWRAP(CreateGC, dmxScreen, pScreen);
if ((ret = pScreen->CreateGC(pGC))) {
/* Save the old funcs */
pGCPriv->funcs = pGC->funcs;
pGCPriv->ops = NULL;
pGC->funcs = &dmxGCFuncs;
if (dmxScreen->beDisplay) {
dmxBECreateGC(pScreen, pGC);
}
else {
pGCPriv->gc = NULL;
}
/* Check for "magic special case"
* 1. see CreateGC in dix/gc.c for more info
* 2. see dmxChangeGC for more info
*/
pGCPriv->msc = (!pGC->tileIsPixel && !pGC->tile.pixmap);
}
DMX_WRAP(CreateGC, dmxCreateGC, dmxScreen, pScreen);
return ret;
}
/** 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);
}
/** 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);
}
/** 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;
}
/** Change the attributes of the pictures. If the picture has not yet
* been created due to lazy window creation, save the mask so that it
* can be used to appropriately initialize the picture's attributes
* when it is created later. */
void dmxChangePicture(PicturePtr pPicture, Mask mask)
{
ScreenPtr pScreen = pPicture->pDrawable->pScreen;
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
PictureScreenPtr ps = GetPictureScreen(pScreen);
dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture);
DMX_UNWRAP(ChangePicture, dmxScreen, ps);
#if 1
if (ps->ChangePicture)
ps->ChangePicture(pPicture, mask);
#endif
/* Picture attribute changes are handled in ValidatePicture */
pPictPriv->savedMask |= mask;
DMX_WRAP(ChangePicture, dmxChangePicture, dmxScreen, ps);
}
/** Destroy a picture. This function calls the wrapped function that
* frees the resources in the DMX server associated with this
* picture. */
void dmxDestroyPicture(PicturePtr pPicture)
{
ScreenPtr pScreen = pPicture->pDrawable->pScreen;
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
PictureScreenPtr ps = GetPictureScreen(pScreen);
DMX_UNWRAP(DestroyPicture, dmxScreen, ps);
/* Destroy picture on back-end server */
if (dmxBEFreePicture(pPicture))
dmxSync(dmxScreen, FALSE);
#if 1
if (ps->DestroyPicture)
ps->DestroyPicture(pPicture);
#endif
DMX_WRAP(DestroyPicture, dmxDestroyPicture, dmxScreen, ps);
}
/** Composite a picture on the appropriate screen by combining the
* specified rectangle of the transformed src and mask operands with
* the specified rectangle of the dst using op as the compositing
* operator. For a complete description see the protocol document of
* the RENDER library. */
void dmxComposite(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;
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
PictureScreenPtr ps = GetPictureScreen(pScreen);
dmxPictPrivPtr pSrcPriv = DMX_GET_PICT_PRIV(pSrc);
dmxPictPrivPtr pMaskPriv = NULL;
dmxPictPrivPtr pDstPriv = DMX_GET_PICT_PRIV(pDst);
if (pMask) pMaskPriv = DMX_GET_PICT_PRIV(pMask);
DMX_UNWRAP(Composite, dmxScreen, ps);
#if 0
if (ps->Composite)
ps->Composite(op, pSrc, pMask, pDst,
xSrc, ySrc, xMask, yMask, xDst, yDst,
width, height);
#endif
/* Composite on back-end server */
if (pSrcPriv->pict && pDstPriv->pict &&
((pMaskPriv && pMaskPriv->pict) || !pMaskPriv)) {
XRenderComposite(dmxScreen->beDisplay,
op,
pSrcPriv->pict,
pMaskPriv ? pMaskPriv->pict : None,
pDstPriv->pict,
xSrc, ySrc,
xMask, yMask,
xDst, yDst,
width, height);
dmxSync(dmxScreen, FALSE);
}
DMX_WRAP(Composite, dmxComposite, dmxScreen, ps);
}
/** Create a picture. This function handles the CreatePicture
* unwrapping/wrapping and calls dmxDoCreatePicture to actually create
* the picture on the appropriate screen. */
int dmxCreatePicture(PicturePtr pPicture)
{
ScreenPtr pScreen = pPicture->pDrawable->pScreen;
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
PictureScreenPtr ps = GetPictureScreen(pScreen);
dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture);
int ret = Success;
DMX_UNWRAP(CreatePicture, dmxScreen, ps);
#if 1
if (ps->CreatePicture)
ret = ps->CreatePicture(pPicture);
#endif
/* Create picture on back-end server */
pPictPriv->pict = dmxDoCreatePicture(pPicture);
pPictPriv->savedMask = 0;
DMX_WRAP(CreatePicture, dmxCreatePicture, dmxScreen, ps);
return ret;
}
/** Composite a triangle fan on the appropriate screen. For a complete
* description see the protocol document of the RENDER library. */
void dmxTriFan(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
PictFormatPtr maskFormat,
INT16 xSrc, INT16 ySrc,
int npoint, xPointFixed *points)
{
ScreenPtr pScreen = pDst->pDrawable->pScreen;
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
PictureScreenPtr ps = GetPictureScreen(pScreen);
dmxPictPrivPtr pSrcPriv = DMX_GET_PICT_PRIV(pSrc);
dmxPictPrivPtr pDstPriv = DMX_GET_PICT_PRIV(pDst);
DMX_UNWRAP(TriFan, dmxScreen, ps);
#if 0
if (ps->TriFan)
ps->TriFan(op, pSrc, pDst, maskFormat, xSrc, ySrc, npoint, *points);
#endif
/* Draw trapezoids on back-end server */
if (pDstPriv->pict) {
XRenderPictFormat *pFormat;
pFormat = dmxFindFormat(dmxScreen, maskFormat);
if (!pFormat) {
/* FIXME: Error! */
}
XRenderCompositeTriFan(dmxScreen->beDisplay,
op,
pSrcPriv->pict,
pDstPriv->pict,
pFormat,
xSrc, ySrc,
(XPointFixed *)points,
npoint);
dmxSync(dmxScreen, FALSE);
}
DMX_WRAP(TriFan, dmxTriFan, dmxScreen, ps);
}
/** 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;
/* The shadow framebuffer only relies on FB to be initialized */
if (dmxShadowFB)
return fbPictureInit(pScreen, formats, nformats);
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;
}
/** Validate the picture's attributes before rendering to it. Update
* any picture attributes that have been changed by one of the higher
* layers. */
void
dmxValidatePicture(PicturePtr pPicture, Mask mask)
{
ScreenPtr pScreen = pPicture->pDrawable->pScreen;
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
PictureScreenPtr ps = GetPictureScreen(pScreen);
dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture);
DMX_UNWRAP(ValidatePicture, dmxScreen, ps);
/* Change picture attributes on back-end server */
if (pPictPriv->pict) {
XRenderPictureAttributes attribs;
if (mask & CPRepeat) {
attribs.repeat = pPicture->repeatType;
}
if (mask & CPAlphaMap) {
if (pPicture->alphaMap) {
dmxPictPrivPtr pAlphaPriv;
pAlphaPriv = DMX_GET_PICT_PRIV(pPicture->alphaMap);
if (pAlphaPriv->pict) {
attribs.alpha_map = pAlphaPriv->pict;
}
else {
/* FIXME: alpha picture drawable has not been created?? */
return; /* or should this be: attribs.alpha_map = None; */
}
}
else {
attribs.alpha_map = None;
}
}
if (mask & CPAlphaXOrigin)
attribs.alpha_x_origin = pPicture->alphaOrigin.x;
if (mask & CPAlphaYOrigin)
attribs.alpha_y_origin = pPicture->alphaOrigin.y;
if (mask & CPClipXOrigin)
attribs.clip_x_origin = pPicture->clipOrigin.x;
if (mask & CPClipYOrigin)
attribs.clip_y_origin = pPicture->clipOrigin.y;
if (mask & CPClipMask)
mask &= ~CPClipMask; /* Handled in ChangePictureClip */
if (mask & CPGraphicsExposure)
attribs.graphics_exposures = pPicture->graphicsExposures;
if (mask & CPSubwindowMode)
attribs.subwindow_mode = pPicture->subWindowMode;
if (mask & CPPolyEdge)
attribs.poly_edge = pPicture->polyEdge;
if (mask & CPPolyMode)
attribs.poly_mode = pPicture->polyMode;
if (mask & CPComponentAlpha)
attribs.component_alpha = pPicture->componentAlpha;
XRenderChangePicture(dmxScreen->beDisplay, pPictPriv->pict,
mask, &attribs);
dmxSync(dmxScreen, FALSE);
}
else {
pPictPriv->savedMask |= mask;
}
#if 1
if (ps->ValidatePicture)
ps->ValidatePicture(pPicture, mask);
#endif
DMX_WRAP(ValidatePicture, dmxValidatePicture, dmxScreen, ps);
}
