Пример #1
0
static void
cwTriangles(CARD8 op,
            PicturePtr pSrcPicture,
            PicturePtr pDstPicture,
            PictFormatPtr maskFormat,
            INT16 xSrc, INT16 ySrc, int ntri, xTriangle * tris)
{
    ScreenPtr pScreen = pDstPicture->pDrawable->pScreen;

    cwPsDecl(pScreen);
    cwSrcPictureDecl;
    cwDstPictureDecl;
    int i;

    cwPsUnwrap(Triangles);
    if (dst_picture_x_off || dst_picture_y_off) {
        for (i = 0; i < ntri; i++) {
            tris[i].p1.x += dst_picture_x_off << 16;
            tris[i].p1.y += dst_picture_y_off << 16;
            tris[i].p2.x += dst_picture_x_off << 16;
            tris[i].p2.y += dst_picture_y_off << 16;
            tris[i].p3.x += dst_picture_x_off << 16;
            tris[i].p3.y += dst_picture_y_off << 16;
        }
    }
    (*ps->Triangles) (op, pBackingSrcPicture, pBackingDstPicture, maskFormat,
                      xSrc + src_picture_x_off, ySrc + src_picture_y_off,
                      ntri, tris);
    cwPsWrap(Triangles, cwTriangles);
}
Пример #2
0
void
cwFiniRender (ScreenPtr pScreen)
{
    cwPsDecl (pScreen);

    cwPsUnwrap(DestroyPicture);
    cwPsUnwrap(ChangePicture);
    cwPsUnwrap(ValidatePicture);
    cwPsUnwrap(Composite);
    cwPsUnwrap(Glyphs);
    cwPsUnwrap(CompositeRects);
    cwPsUnwrap(Trapezoids);
    cwPsUnwrap(Triangles);
    cwPsUnwrap(TriStrip);
    cwPsUnwrap(TriFan);
}
Пример #3
0
static void
cwTrapezoids(CARD8 op,
             PicturePtr pSrcPicture,
             PicturePtr pDstPicture,
             PictFormatPtr maskFormat,
             INT16 xSrc, INT16 ySrc, int ntrap, xTrapezoid * traps)
{
    ScreenPtr pScreen = pDstPicture->pDrawable->pScreen;

    cwPsDecl(pScreen);
    cwSrcPictureDecl;
    cwDstPictureDecl;
    int i;

    cwPsUnwrap(Trapezoids);
    if (dst_picture_x_off || dst_picture_y_off) {
        for (i = 0; i < ntrap; i++) {
            traps[i].top += dst_picture_y_off << 16;
            traps[i].bottom += dst_picture_y_off << 16;
            traps[i].left.p1.x += dst_picture_x_off << 16;
            traps[i].left.p1.y += dst_picture_y_off << 16;
            traps[i].left.p2.x += dst_picture_x_off << 16;
            traps[i].left.p2.y += dst_picture_y_off << 16;
            traps[i].right.p1.x += dst_picture_x_off << 16;
            traps[i].right.p1.y += dst_picture_y_off << 16;
            traps[i].right.p2.x += dst_picture_x_off << 16;
            traps[i].right.p2.y += dst_picture_y_off << 16;
        }
    }
    (*ps->Trapezoids) (op, pBackingSrcPicture, pBackingDstPicture, maskFormat,
                       xSrc + src_picture_x_off, ySrc + src_picture_y_off,
                       ntrap, traps);
    cwPsWrap(Trapezoids, cwTrapezoids);
}
Пример #4
0
static void
cwComposite(CARD8 op,
            PicturePtr pSrcPicture,
            PicturePtr pMskPicture,
            PicturePtr pDstPicture,
            INT16 xSrc,
            INT16 ySrc,
            INT16 xMsk,
            INT16 yMsk, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
{
    ScreenPtr pScreen = pDstPicture->pDrawable->pScreen;

    cwPsDecl(pScreen);
    cwSrcPictureDecl;
    cwMskPictureDecl;
    cwDstPictureDecl;

    cwPsUnwrap(Composite);
    (*ps->Composite) (op, pBackingSrcPicture, pBackingMskPicture,
                      pBackingDstPicture, xSrc + src_picture_x_off,
                      ySrc + src_picture_y_off, xMsk + msk_picture_x_off,
                      yMsk + msk_picture_y_off, xDst + dst_picture_x_off,
                      yDst + dst_picture_y_off, width, height);
    cwPsWrap(Composite, cwComposite);
}
Пример #5
0
static void
cwTriFan (CARD8		 op,
	  PicturePtr	 pSrcPicture,
	  PicturePtr	 pDstPicture,
	  PictFormatPtr  maskFormat,
	  INT16		 xSrc,
	  INT16		 ySrc,
	  int		 npoint,
	  xPointFixed   *points)
{
    ScreenPtr	pScreen = pDstPicture->pDrawable->pScreen;
    cwPsDecl(pScreen);
    cwSrcPictureDecl;
    cwDstPictureDecl;
    int i;

    cwPsUnwrap(TriFan);
    if (dst_picture_x_off || dst_picture_y_off) {
	for (i = 0; i < npoint; i++)
	{
	    points[i].x += dst_picture_x_off << 16;
	    points[i].y += dst_picture_y_off << 16;
	}
    }
    (*ps->TriFan) (op, pBackingSrcPicture, pBackingDstPicture, maskFormat,
		   xSrc + src_picture_x_off, ySrc + src_picture_y_off,
		   npoint, points);
    cwPsWrap(TriFan, cwTriFan);
}
Пример #6
0
static void
cwGlyphs (CARD8      op,
	  PicturePtr pSrcPicture,
	  PicturePtr pDstPicture,
	  PictFormatPtr  maskFormat,
	  INT16      xSrc,
	  INT16      ySrc,
	  int	nlists,
	  GlyphListPtr   lists,
	  GlyphPtr	*glyphs)
{
    ScreenPtr	pScreen = pDstPicture->pDrawable->pScreen;
    cwPsDecl(pScreen);
    cwSrcPictureDecl;
    cwDstPictureDecl;
    
    cwPsUnwrap(Glyphs);
    if (nlists)
    {
	lists->xOff += dst_picture_x_off;
	lists->yOff += dst_picture_y_off;
    }
    (*ps->Glyphs) (op, pBackingSrcPicture, pBackingDstPicture, maskFormat,
		   xSrc + src_picture_x_off, ySrc + src_picture_y_off,
		   nlists, lists, glyphs);
    cwPsWrap(Glyphs, cwGlyphs);
}
Пример #7
0
static void
cwDestroyPicture (PicturePtr pPicture)
{
    ScreenPtr		pScreen = pPicture->pDrawable->pScreen;
    cwPsDecl(pScreen);
    
    cwPsUnwrap(DestroyPicture);
    cwDestroyPicturePrivate (pPicture);
    (*ps->DestroyPicture) (pPicture);
    cwPsWrap(DestroyPicture, cwDestroyPicture);
}
Пример #8
0
static void
cwChangePicture (PicturePtr pPicture, Mask mask)
{
    ScreenPtr		pScreen = pPicture->pDrawable->pScreen;
    cwPsDecl(pScreen);
    cwPicturePtr	pPicturePrivate = getCwPicture(pPicture);
    
    cwPsUnwrap(ChangePicture);
    (*ps->ChangePicture) (pPicture, mask);
    if (pPicturePrivate)
	pPicturePrivate->stateChanges |= mask;
    cwPsWrap(ChangePicture, cwChangePicture);
}
Пример #9
0
static void
cwCompositeRects(CARD8 op,
                 PicturePtr pDstPicture,
                 xRenderColor * color, int nRect, xRectangle *rects)
{
    ScreenPtr pScreen = pDstPicture->pDrawable->pScreen;

    cwPsDecl(pScreen);
    cwDstPictureDecl;
    int i;

    cwPsUnwrap(CompositeRects);
    for (i = 0; i < nRect; i++) {
        rects[i].x += dst_picture_x_off;
        rects[i].y += dst_picture_y_off;
    }
    (*ps->CompositeRects) (op, pBackingDstPicture, color, nRect, rects);
    cwPsWrap(CompositeRects, cwCompositeRects);
}
Пример #10
0
static void
cwValidatePicture(PicturePtr pPicture, Mask mask)
{
    DrawablePtr pDrawable = pPicture->pDrawable;
    ScreenPtr pScreen = pDrawable->pScreen;

    cwPsDecl(pScreen);
    cwPicturePrivate;

    cwPsUnwrap(ValidatePicture);

    /*
     * Must call ValidatePicture to ensure pPicture->pCompositeClip is valid
     */
    (*ps->ValidatePicture) (pPicture, mask);

    if (!cwDrawableIsRedirWindow(pDrawable)) {
        if (pPicturePrivate)
            cwDestroyPicturePrivate(pPicture);
    }
    else {
        PicturePtr pBackingPicture;
        DrawablePtr pBackingDrawable;
        int x_off, y_off;

        pBackingDrawable = cwGetBackingDrawable(pDrawable, &x_off, &y_off);

        if (pPicturePrivate &&
            pPicturePrivate->pBackingPicture->pDrawable != pBackingDrawable) {
            cwDestroyPicturePrivate(pPicture);
            pPicturePrivate = 0;
        }

        if (!pPicturePrivate) {
            pPicturePrivate = cwCreatePicturePrivate(pPicture);
            if (!pPicturePrivate) {
                cwPsWrap(ValidatePicture, cwValidatePicture);
                return;
            }
        }

        pBackingPicture = pPicturePrivate->pBackingPicture;

        /*
         * Always copy transform and filters because there's no
         * indication of when they've changed
         */
        SetPictureTransform(pBackingPicture, pPicture->transform);

        if (pBackingPicture->filter != pPicture->filter ||
            pPicture->filter_nparams > 0) {
            char *filter = PictureGetFilterName(pPicture->filter);

            SetPictureFilter(pBackingPicture,
                             filter, strlen(filter),
                             pPicture->filter_params, pPicture->filter_nparams);
        }

        pPicturePrivate->stateChanges |= mask;

        if (pPicturePrivate->serialNumber != pDrawable->serialNumber ||
            (pPicturePrivate->
             stateChanges & (CPClipXOrigin | CPClipYOrigin | CPClipMask))) {
            SetPictureClipRegion(pBackingPicture, x_off - pDrawable->x,
                                 y_off - pDrawable->y,
                                 pPicture->pCompositeClip);

            pPicturePrivate->serialNumber = pDrawable->serialNumber;
            pPicturePrivate->stateChanges &=
                ~(CPClipXOrigin | CPClipYOrigin | CPClipMask);
        }

        CopyPicture(pPicture, pPicturePrivate->stateChanges, pBackingPicture);

        ValidatePicture(pBackingPicture);
    }
    cwPsWrap(ValidatePicture, cwValidatePicture);
}