Examples with LoopBasedPipe sun.java2d.pipe.LoopBasedPipe used on opensource projects

Example 1 with LoopBasedPipe

use of sun.java2d.pipe.LoopBasedPipe in project jdk8u_jdk by JetBrains.

the class SurfaceData method validatePipe.

public void validatePipe(SunGraphics2D sg2d) {
    sg2d.imagepipe = imagepipe;
    if (sg2d.compositeState == SunGraphics2D.COMP_XOR) {
        if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
            sg2d.drawpipe = paintViaShape;
            sg2d.fillpipe = paintViaShape;
            sg2d.shapepipe = paintShape;
            // REMIND: Ideally custom paint mode would use glyph
            // rendering as opposed to outline rendering but the
            // glyph paint rendering pipeline uses MaskBlit which
            // is not defined for XOR.  This means that text drawn
            // in XOR mode with a Color object is different than
            // text drawn in XOR mode with a Paint object.
            sg2d.textpipe = outlineTextRenderer;
        } else {
            PixelToShapeConverter converter;
            if (canRenderParallelograms(sg2d)) {
                converter = colorViaPgram;
                // Note that we use the transforming pipe here because it
                // will examine the shape and possibly perform an optimized
                // operation if it can be simplified.  The simplifications
                // will be valid for all STROKE and TRANSFORM types.
                sg2d.shapepipe = colorViaPgram;
            } else {
                converter = colorViaShape;
                sg2d.shapepipe = colorPrimitives;
            }
            if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
                sg2d.drawpipe = converter;
                sg2d.fillpipe = converter;
                // REMIND: We should not be changing text strategies
                // between outline and glyph rendering based upon the
                // presence of a complex clip as that could cause a
                // mismatch when drawing the same text both clipped
                // and unclipped on two separate rendering passes.
                // Unfortunately, all of the clipped glyph rendering
                // pipelines rely on the use of the MaskBlit operation
                // which is not defined for XOR.
                sg2d.textpipe = outlineTextRenderer;
            } else {
                if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
                    sg2d.drawpipe = converter;
                    sg2d.fillpipe = converter;
                } else {
                    if (sg2d.strokeState != SunGraphics2D.STROKE_THIN) {
                        sg2d.drawpipe = converter;
                    } else {
                        sg2d.drawpipe = colorPrimitives;
                    }
                    sg2d.fillpipe = colorPrimitives;
                }
                sg2d.textpipe = solidTextRenderer;
            }
        // assert(sg2d.surfaceData == this);
        }
    } else if (sg2d.compositeState == SunGraphics2D.COMP_CUSTOM) {
        if (sg2d.antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) {
            if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
                sg2d.drawpipe = AAClipCompViaShape;
                sg2d.fillpipe = AAClipCompViaShape;
                sg2d.shapepipe = AAClipCompViaShape;
                sg2d.textpipe = clipCompText;
            } else {
                sg2d.drawpipe = AACompViaShape;
                sg2d.fillpipe = AACompViaShape;
                sg2d.shapepipe = AACompViaShape;
                sg2d.textpipe = compText;
            }
        } else {
            sg2d.drawpipe = compViaShape;
            sg2d.fillpipe = compViaShape;
            sg2d.shapepipe = compShape;
            if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
                sg2d.textpipe = clipCompText;
            } else {
                sg2d.textpipe = compText;
            }
        }
    } else if (sg2d.antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) {
        sg2d.alphafill = getMaskFill(sg2d);
        // assert(sg2d.surfaceData == this);
        if (sg2d.alphafill != null) {
            if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
                sg2d.drawpipe = AAClipColorViaShape;
                sg2d.fillpipe = AAClipColorViaShape;
                sg2d.shapepipe = AAClipColorViaShape;
                sg2d.textpipe = clipColorText;
            } else {
                PixelToParallelogramConverter converter = (sg2d.alphafill.canDoParallelograms() ? AAColorViaPgram : AAColorViaShape);
                sg2d.drawpipe = converter;
                sg2d.fillpipe = converter;
                sg2d.shapepipe = converter;
                if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR || sg2d.compositeState > SunGraphics2D.COMP_ISCOPY) {
                    sg2d.textpipe = colorText;
                } else {
                    sg2d.textpipe = getTextPipe(sg2d, true);
                }
            }
        } else {
            if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
                sg2d.drawpipe = AAClipPaintViaShape;
                sg2d.fillpipe = AAClipPaintViaShape;
                sg2d.shapepipe = AAClipPaintViaShape;
                sg2d.textpipe = clipPaintText;
            } else {
                sg2d.drawpipe = AAPaintViaShape;
                sg2d.fillpipe = AAPaintViaShape;
                sg2d.shapepipe = AAPaintViaShape;
                sg2d.textpipe = paintText;
            }
        }
    } else if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR || sg2d.compositeState > SunGraphics2D.COMP_ISCOPY || sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
        sg2d.drawpipe = paintViaShape;
        sg2d.fillpipe = paintViaShape;
        sg2d.shapepipe = paintShape;
        sg2d.alphafill = getMaskFill(sg2d);
        // assert(sg2d.surfaceData == this);
        if (sg2d.alphafill != null) {
            if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
                sg2d.textpipe = clipColorText;
            } else {
                sg2d.textpipe = colorText;
            }
        } else {
            if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
                sg2d.textpipe = clipPaintText;
            } else {
                sg2d.textpipe = paintText;
            }
        }
    } else {
        PixelToShapeConverter converter;
        if (canRenderParallelograms(sg2d)) {
            converter = colorViaPgram;
            // Note that we use the transforming pipe here because it
            // will examine the shape and possibly perform an optimized
            // operation if it can be simplified.  The simplifications
            // will be valid for all STROKE and TRANSFORM types.
            sg2d.shapepipe = colorViaPgram;
        } else {
            converter = colorViaShape;
            sg2d.shapepipe = colorPrimitives;
        }
        if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
            sg2d.drawpipe = converter;
            sg2d.fillpipe = converter;
        } else {
            if (sg2d.strokeState != SunGraphics2D.STROKE_THIN) {
                sg2d.drawpipe = converter;
            } else {
                sg2d.drawpipe = colorPrimitives;
            }
            sg2d.fillpipe = colorPrimitives;
        }
        sg2d.textpipe = getTextPipe(sg2d, false);
    // assert(sg2d.surfaceData == this);
    }
    // check for loops
    if (sg2d.textpipe instanceof LoopBasedPipe || sg2d.shapepipe instanceof LoopBasedPipe || sg2d.fillpipe instanceof LoopBasedPipe || sg2d.drawpipe instanceof LoopBasedPipe || sg2d.imagepipe instanceof LoopBasedPipe) {
        sg2d.loops = getRenderLoops(sg2d);
    }
}