コード例 #1
0
ファイル: xaaGCmisc.c プロジェクト: csulmone/X11
void
XAAValidatePolyGlyphBlt(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
{
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
    Bool BigFont = FALSE;

    pGC->ops->PolyText8 = XAAFallbackOps.PolyText8;
    pGC->ops->PolyText16 = XAAFallbackOps.PolyText16;
    pGC->ops->PolyGlyphBlt = XAAFallbackOps.PolyGlyphBlt;

    if (!pGC->font)
        return;
    if (pGC->fillStyle != FillSolid)
        return;

    if ((FONTMAXBOUNDS(pGC->font, rightSideBearing) -
         FONTMINBOUNDS(pGC->font, leftSideBearing) > 32))
        BigFont = TRUE;

    /* no funny business */
    if ((FONTMINBOUNDS(pGC->font, characterWidth) <= 0) ||
        ((FONTASCENT(pGC->font) + FONTDESCENT(pGC->font)) <= 0))
        return;

    /* Check for TE Fonts */
    if (!TERMINALFONT(pGC->font) || BigFont) {
        if (infoRec->PolyGlyphBltNonTE &&
            CHECK_PLANEMASK(pGC, infoRec->PolyGlyphBltNonTEFlags) &&
            CHECK_ROP(pGC, infoRec->PolyGlyphBltNonTEFlags) &&
            CHECK_ROPSRC(pGC, infoRec->PolyGlyphBltNonTEFlags) &&
            CHECK_FG(pGC, infoRec->PolyGlyphBltNonTEFlags) &&
            (!(infoRec->PolyGlyphBltNonTEFlags & TRANSPARENCY_GXCOPY_ONLY) ||
             (pGC->alu == GXcopy))
            ) {
            pGC->ops->PolyText8 = infoRec->PolyText8NonTE;
            pGC->ops->PolyText16 = infoRec->PolyText16NonTE;
            pGC->ops->PolyGlyphBlt = infoRec->PolyGlyphBltNonTE;
        }
    }
    else {
        if (infoRec->PolyGlyphBltTE &&
            CHECK_PLANEMASK(pGC, infoRec->PolyGlyphBltTEFlags) &&
            CHECK_ROP(pGC, infoRec->PolyGlyphBltTEFlags) &&
            CHECK_ROPSRC(pGC, infoRec->PolyGlyphBltNonTEFlags) &&
            CHECK_FG(pGC, infoRec->PolyGlyphBltTEFlags) &&
            (!(infoRec->PolyGlyphBltTEFlags & TRANSPARENCY_GXCOPY_ONLY) ||
             (pGC->alu == GXcopy))
            ) {
            pGC->ops->PolyText8 = infoRec->PolyText8TE;
            pGC->ops->PolyText16 = infoRec->PolyText16TE;
            pGC->ops->PolyGlyphBlt = infoRec->PolyGlyphBltTE;
        }
    }
}
コード例 #2
0
ファイル: xaaGCmisc.c プロジェクト: csulmone/X11
void
XAAValidateCopyArea(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
{
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

    if (infoRec->CopyArea &&
        CHECK_PLANEMASK(pGC, infoRec->CopyAreaFlags) &&
        CHECK_ROP(pGC, infoRec->CopyAreaFlags) &&
        CHECK_ROPSRC(pGC, infoRec->CopyAreaFlags)
        )
        pGC->ops->CopyArea = infoRec->CopyArea;
    else
        pGC->ops->CopyArea = XAAFallbackOps.CopyArea;
}
コード例 #3
0
ファイル: xaaGCmisc.c プロジェクト: csulmone/X11
void
XAAValidatePutImage(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
{
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

    if (infoRec->PutImage &&
        CHECK_PLANEMASK(pGC, infoRec->PutImageFlags) &&
        CHECK_ROP(pGC, infoRec->PutImageFlags) &&
        CHECK_ROPSRC(pGC, infoRec->PutImageFlags) &&
        CHECK_COLORS(pGC, infoRec->PutImageFlags)
        )
        pGC->ops->PutImage = infoRec->PutImage;
    else
        pGC->ops->PutImage = XAAFallbackOps.PutImage;
}
コード例 #4
0
ファイル: xaaGCmisc.c プロジェクト: csulmone/X11
void
XAAValidatePushPixels(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
{
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

    if (infoRec->PushPixelsSolid &&
        (pGC->fillStyle == FillSolid) &&
        CHECK_PLANEMASK(pGC, infoRec->PushPixelsFlags) &&
        CHECK_ROP(pGC, infoRec->PushPixelsFlags) &&
        CHECK_ROPSRC(pGC, infoRec->PushPixelsFlags) &&
        CHECK_FG(pGC, infoRec->PushPixelsFlags) &&
        (!(infoRec->PushPixelsFlags & TRANSPARENCY_GXCOPY_ONLY) ||
         (pGC->alu == GXcopy))
        )
        pGC->ops->PushPixels = infoRec->PushPixelsSolid;
    else
        pGC->ops->PushPixels = XAAFallbackOps.PushPixels;

}
コード例 #5
0
ファイル: xaaGCmisc.c プロジェクト: csulmone/X11
void
XAAValidateFillSpans(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
{
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

    if (pGC->fillStyle != FillTiled)
        changes &= ~GCTile;
    if ((pGC->fillStyle == FillTiled) || (pGC->fillStyle == FillSolid))
        changes &= ~GCStipple;
    if (!changes)
        return;

    pGC->ops->FillSpans = XAAFallbackOps.FillSpans;
    pGC->ops->PolyFillRect = XAAFallbackOps.PolyFillRect;
    pGC->ops->FillPolygon = XAAFallbackOps.FillPolygon;
    pGC->ops->PolyFillArc = XAAFallbackOps.PolyFillArc;

    switch (pGC->fillStyle) {
    case FillSolid:
        if (infoRec->FillSpansSolid &&
            CHECK_PLANEMASK(pGC, infoRec->FillSpansSolidFlags) &&
            CHECK_ROP(pGC, infoRec->FillSpansSolidFlags) &&
            CHECK_ROPSRC(pGC, infoRec->FillSpansSolidFlags) &&
            CHECK_FG(pGC, infoRec->FillSpansSolidFlags)
            ) {
            pGC->ops->FillSpans = infoRec->FillSpansSolid;
            pGC->ops->PolyFillRect = infoRec->PolyFillRectSolid;
            pGC->ops->FillPolygon = infoRec->FillPolygonSolid;
            pGC->ops->PolyFillArc = infoRec->PolyFillArcSolid;
        }
        break;
        /* The [Stippled/OpaqueStippled/Tiled]FillChooser 
           functions do the validating */
    case FillStippled:
        if (infoRec->FillSpansStippled) {
            pGC->ops->FillSpans = infoRec->FillSpansStippled;
            pGC->ops->PolyFillRect = infoRec->PolyFillRectStippled;
            if (infoRec->FillPolygonStippled)
                pGC->ops->FillPolygon = infoRec->FillPolygonStippled;
            else
                pGC->ops->FillPolygon = miFillPolygon;
            pGC->ops->PolyFillArc = miPolyFillArc;
        }
        break;
    case FillOpaqueStippled:
        if (infoRec->FillSpansOpaqueStippled) {
            pGC->ops->FillSpans = infoRec->FillSpansOpaqueStippled;
            pGC->ops->PolyFillRect = infoRec->PolyFillRectOpaqueStippled;
            if (infoRec->FillPolygonOpaqueStippled)
                pGC->ops->FillPolygon = infoRec->FillPolygonOpaqueStippled;
            else
                pGC->ops->FillPolygon = miFillPolygon;
            pGC->ops->PolyFillArc = miPolyFillArc;
        }
        break;
    case FillTiled:
        if (infoRec->FillSpansTiled) {
            pGC->ops->FillSpans = infoRec->FillSpansTiled;
            pGC->ops->PolyFillRect = infoRec->PolyFillRectTiled;
            if (infoRec->FillPolygonTiled)
                pGC->ops->FillPolygon = infoRec->FillPolygonTiled;
            else
                pGC->ops->FillPolygon = miFillPolygon;
            pGC->ops->PolyFillArc = miPolyFillArc;
        }
        break;
    default:
        return;
    }
}
コード例 #6
0
ファイル: xaaGCmisc.c プロジェクト: csulmone/X11
void
XAAValidatePolylines(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
{
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
    XAAGCPtr pGCPriv = (XAAGCPtr) dixLookupPrivate(&pGC->devPrivates,
                                                   XAAGetGCKey());

    if (pGC->lineStyle == LineSolid)
        changes &= ~GCDashList;
    if (!changes)
        return;

    pGC->ops->PolySegment = XAAFallbackOps.PolySegment;
    pGC->ops->Polylines = XAAFallbackOps.Polylines;
    pGC->ops->PolyRectangle = XAAFallbackOps.PolyRectangle;
    pGC->ops->PolyArc = XAAFallbackOps.PolyArc;

    if ((pGC->ops->FillSpans != XAAFallbackOps.FillSpans) &&
        (pGC->lineWidth > 0)) {

        pGC->ops->PolyArc = miPolyArc;
        pGC->ops->PolySegment = miPolySegment;
        pGC->ops->PolyRectangle = miPolyRectangle;
        if (pGC->lineStyle == LineSolid)
            pGC->ops->Polylines = miWideLine;
        else
            pGC->ops->Polylines = miWideDash;
    }

    if ((pGC->lineWidth == 0) && (pGC->fillStyle == FillSolid)) {

        if (pGC->lineStyle == LineSolid) {

            if (infoRec->PolyRectangleThinSolid &&
                CHECK_PLANEMASK(pGC, infoRec->PolyRectangleThinSolidFlags) &&
                CHECK_ROP(pGC, infoRec->PolyRectangleThinSolidFlags) &&
                CHECK_ROPSRC(pGC, infoRec->PolyRectangleThinSolidFlags) &&
                CHECK_FG(pGC, infoRec->PolyRectangleThinSolidFlags)) {

                pGC->ops->PolyRectangle = infoRec->PolyRectangleThinSolid;
            }

            if (infoRec->PolySegmentThinSolid &&
                CHECK_PLANEMASK(pGC, infoRec->PolySegmentThinSolidFlags) &&
                CHECK_ROP(pGC, infoRec->PolySegmentThinSolidFlags) &&
                CHECK_ROPSRC(pGC, infoRec->PolySegmentThinSolidFlags) &&
                CHECK_FG(pGC, infoRec->PolySegmentThinSolidFlags)) {

                pGC->ops->PolySegment = infoRec->PolySegmentThinSolid;
            }

            if (infoRec->PolylinesThinSolid &&
                CHECK_PLANEMASK(pGC, infoRec->PolylinesThinSolidFlags) &&
                CHECK_ROP(pGC, infoRec->PolylinesThinSolidFlags) &&
                CHECK_ROPSRC(pGC, infoRec->PolylinesThinSolidFlags) &&
                CHECK_FG(pGC, infoRec->PolylinesThinSolidFlags)) {

                pGC->ops->Polylines = infoRec->PolylinesThinSolid;
            }
        }
        else if ((pGC->lineStyle == LineOnOffDash) && pGCPriv->DashPattern) {

            if (infoRec->PolySegmentThinDashed &&
                !(infoRec->PolySegmentThinDashedFlags & NO_TRANSPARENCY) &&
                ((pGC->alu == GXcopy) || !(infoRec->PolySegmentThinDashedFlags &
                                           TRANSPARENCY_GXCOPY_ONLY)) &&
                CHECK_PLANEMASK(pGC, infoRec->PolySegmentThinDashedFlags) &&
                CHECK_ROP(pGC, infoRec->PolySegmentThinDashedFlags) &&
                CHECK_ROPSRC(pGC, infoRec->PolySegmentThinDashedFlags) &&
                CHECK_FG(pGC, infoRec->PolySegmentThinDashedFlags)) {

                pGC->ops->PolySegment = infoRec->PolySegmentThinDashed;
            }

            if (infoRec->PolylinesThinDashed &&
                !(infoRec->PolylinesThinDashedFlags & NO_TRANSPARENCY) &&
                ((pGC->alu == GXcopy) || !(infoRec->PolylinesThinDashedFlags &
                                           TRANSPARENCY_GXCOPY_ONLY)) &&
                CHECK_PLANEMASK(pGC, infoRec->PolylinesThinDashedFlags) &&
                CHECK_ROP(pGC, infoRec->PolylinesThinDashedFlags) &&
                CHECK_ROPSRC(pGC, infoRec->PolylinesThinDashedFlags) &&
                CHECK_FG(pGC, infoRec->PolylinesThinDashedFlags)) {

                pGC->ops->Polylines = infoRec->PolylinesThinDashed;
            }

            if (pGC->ops->Polylines != XAAFallbackOps.Polylines)
                pGC->ops->PolyRectangle = miPolyRectangle;

        }
        else if (pGCPriv->DashPattern && (pGC->depth != 32)) {
            /* LineDoubleDash */
            if (infoRec->PolySegmentThinDashed &&
                !(infoRec->PolySegmentThinDashedFlags & TRANSPARENCY_ONLY) &&
                CHECK_PLANEMASK(pGC, infoRec->PolySegmentThinDashedFlags) &&
                CHECK_ROP(pGC, infoRec->PolySegmentThinDashedFlags) &&
                CHECK_ROPSRC(pGC, infoRec->PolySegmentThinDashedFlags) &&
                CHECK_COLORS(pGC, infoRec->PolySegmentThinDashedFlags)) {

                pGC->ops->PolySegment = infoRec->PolySegmentThinDashed;
            }

            if (infoRec->PolylinesThinDashed &&
                !(infoRec->PolylinesThinDashedFlags & TRANSPARENCY_ONLY) &&
                CHECK_PLANEMASK(pGC, infoRec->PolylinesThinDashedFlags) &&
                CHECK_ROP(pGC, infoRec->PolylinesThinDashedFlags) &&
                CHECK_ROPSRC(pGC, infoRec->PolylinesThinDashedFlags) &&
                CHECK_COLORS(pGC, infoRec->PolylinesThinDashedFlags)) {

                pGC->ops->Polylines = infoRec->PolylinesThinDashed;
            }

            if (pGC->ops->Polylines != XAAFallbackOps.Polylines)
                pGC->ops->PolyRectangle = miPolyRectangle;

        }
    }

    if (infoRec->PolylinesWideSolid &&
        (pGC->lineWidth > 0) &&
        (pGC->fillStyle == FillSolid) &&
        (pGC->lineStyle == LineSolid) &&
        CHECK_PLANEMASK(pGC, infoRec->PolylinesWideSolidFlags) &&
        CHECK_ROP(pGC, infoRec->PolylinesWideSolidFlags) &&
        CHECK_ROPSRC(pGC, infoRec->PolylinesWideSolidFlags) &&
        CHECK_FG(pGC, infoRec->PolylinesWideSolidFlags)) {

        pGC->ops->Polylines = infoRec->PolylinesWideSolid;
    }
}
コード例 #7
0
ファイル: xaaFillRect.c プロジェクト: csulmone/X11
void
XAAPolyFillRect(DrawablePtr pDraw, GCPtr pGC, int nrectFill,    /* number of rectangles to fill */
                xRectangle *prectInit   /* Pointer to first rectangle to fill */
    )
{
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
    int xorg = pDraw->x;
    int yorg = pDraw->y;
    int type = 0;
    ClipAndRenderRectsFunc function;

    if ((nrectFill <= 0) || !pGC->planemask)
        return;

    if (!RegionNumRects(pGC->pCompositeClip))
        return;

    switch (pGC->fillStyle) {
    case FillSolid:
        type = DO_SOLID;
        break;
    case FillStippled:
        type = (*infoRec->StippledFillChooser) (pGC);
        break;
    case FillOpaqueStippled:
        if ((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSolidRects &&
            CHECK_PLANEMASK(pGC, infoRec->FillSolidRectsFlags) &&
            CHECK_ROP(pGC, infoRec->FillSolidRectsFlags) &&
            CHECK_ROPSRC(pGC, infoRec->FillSolidRectsFlags) &&
            CHECK_FG(pGC, infoRec->FillSolidRectsFlags))
            type = DO_SOLID;
        else
            type = (*infoRec->OpaqueStippledFillChooser) (pGC);
        break;
    case FillTiled:
        type = (*infoRec->TiledFillChooser) (pGC);
        break;
    }

    switch (type) {
    case DO_SOLID:
        function = XAARenderSolidRects;
        break;
    case DO_COLOR_8x8:
        function = XAARenderColor8x8Rects;
        break;
    case DO_MONO_8x8:
        function = XAARenderMono8x8Rects;
        break;
    case DO_CACHE_BLT:
        function = XAARenderCacheBltRects;
        break;
    case DO_COLOR_EXPAND:
        function = XAARenderColorExpandRects;
        break;
    case DO_CACHE_EXPAND:
        function = XAARenderCacheExpandRects;
        break;
    case DO_IMAGE_WRITE:
        function = XAARenderImageWriteRects;
        break;
    case DO_PIXMAP_COPY:
        function = XAARenderPixmapCopyRects;
        break;
    default:
        (*XAAFallbackOps.PolyFillRect) (pDraw, pGC, nrectFill, prectInit);
        return;
    }

    if (xorg | yorg) {
        int n = nrectFill;
        xRectangle *prect = prectInit;

        while (n--) {
            prect->x += xorg;
            prect->y += yorg;
            prect++;
        }
    }

    XAAClipAndRenderRects(pGC, function, nrectFill, prectInit, xorg, yorg);
}
コード例 #8
0
ファイル: xaaSpans.c プロジェクト: L3oV1nc3/VMGL
void
XAAFillSpans(
    DrawablePtr pDraw,
    GC		*pGC,
    int		nInit,		/* number of spans to fill */
    DDXPointPtr pptInit,	/* pointer to list of start points */
    int *pwidthInit,		/* pointer to list of n widths */
    int fSorted 
){
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
    int type = 0;
    ClipAndRenderSpansFunc function;
    Bool fastClip = FALSE;

    if((nInit <= 0) || !pGC->planemask)
        return;

    if(!REGION_NUM_RECTS(pGC->pCompositeClip))
	return;

    switch(pGC->fillStyle) {
    case FillSolid:
	type = DO_SOLID;
	break;
    case FillStippled:
	type = (*infoRec->StippledFillChooser)(pGC);
	break;
    case FillOpaqueStippled:
	if((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSpansSolid &&
                CHECK_PLANEMASK(pGC,infoRec->FillSpansSolidFlags) &&
                CHECK_ROP(pGC,infoRec->FillSpansSolidFlags) &&
                CHECK_ROPSRC(pGC,infoRec->FillSpansSolidFlags) &&
                CHECK_FG(pGC,infoRec->FillSpansSolidFlags))
	    type = DO_SOLID;
	else
	    type = (*infoRec->OpaqueStippledFillChooser)(pGC);
	break;
    case FillTiled:
	type = (*infoRec->TiledFillChooser)(pGC);
	break;
    }

    switch(type) {
    case DO_SOLID:
	function = XAARenderSolidSpans;	
	if(infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL) 
		fastClip = TRUE; 
	break;	
    case DO_COLOR_8x8:
	function = XAARenderColor8x8Spans;	
	if(infoRec->ClippingFlags & HARDWARE_CLIP_COLOR_8x8_FILL) 
		fastClip = TRUE; 
	break;	
    case DO_MONO_8x8:
	function = XAARenderMono8x8Spans;	
	if(infoRec->ClippingFlags & HARDWARE_CLIP_MONO_8x8_FILL) 
		fastClip = TRUE; 
	break;	
    case DO_CACHE_BLT:
	function = XAARenderCacheBltSpans;	
	if(infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)
		fastClip = TRUE; 
	break;	
    case DO_COLOR_EXPAND:
	function = XAARenderColorExpandSpans;	
	break;	
    case DO_CACHE_EXPAND:
	function = XAARenderCacheExpandSpans;	
	if(infoRec->ClippingFlags & 
			HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND) 
		fastClip = TRUE; 
	break;	
    case DO_PIXMAP_COPY:
	function = XAARenderPixmapCopySpans;	
	if(infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)
		fastClip = TRUE; 
	break;	
    case DO_IMAGE_WRITE:
    default:
	(*XAAFallbackOps.FillSpans)(pDraw, pGC, nInit, pptInit,
				pwidthInit, fSorted);
	return;
    }


    if((nInit < 10) || (REGION_NUM_RECTS(pGC->pCompositeClip) != 1))
	fastClip = FALSE;

    if(fastClip) {
	infoRec->ClipBox = &pGC->pCompositeClip->extents;
	(*function)(pGC, nInit, pptInit, pwidthInit, fSorted, 
					pDraw->x, pDraw->y);
	infoRec->ClipBox = NULL;
    } else
	XAAClipAndRenderSpans(pGC, pptInit, pwidthInit, nInit, fSorted,
					function, pDraw->x, pDraw->y);
}