Java SunHints.INTVAL_TEXT_ANTIALIAS_ON属性代码示例

protected void drawGlyphList(SunGraphics2D sg2d, GlyphList gl,
                             int aaHint) {
    switch (aaHint) {
     case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
         sg2d.loops.drawGlyphListLoop.
             DrawGlyphList(sg2d, sg2d.surfaceData, gl);
         return;
     case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
         sg2d.loops.drawGlyphListAALoop.
             DrawGlyphListAA(sg2d, sg2d.surfaceData, gl);
         return;
    case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB:
    case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB:
        sg2d.loops.drawGlyphListLCDLoop.
            DrawGlyphListLCD(sg2d,sg2d.surfaceData, gl);
        return;
    }
}
 

public void drawGlyphVector(SunGraphics2D sg2d, GlyphVector g,
                            float x, float y)
{
    FontRenderContext frc = g.getFontRenderContext();
    FontInfo info = sg2d.getGVFontInfo(g.getFont(), frc);
    switch (info.aaHint) {
    case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
        super.drawGlyphVector(sg2d, g, x, y);
        return;
    case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
         sg2d.surfaceData.aaTextRenderer.drawGlyphVector(sg2d, g, x, y);
        return;
    case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB:
    case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB:
         sg2d.surfaceData.lcdTextRenderer.drawGlyphVector(sg2d, g, x, y);
        return;
    default:
    }
}
 

public void drawGlyphVector(SunGraphics2D sg2d, GlyphVector g,
                            float x, float y)
{
    FontRenderContext frc = g.getFontRenderContext();
    FontInfo info = sg2d.getGVFontInfo(g.getFont(), frc);
    switch (info.aaHint) {
    case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
        super.drawGlyphVector(sg2d, g, x, y);
        return;
    case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
         SurfaceData.aaTextRenderer.drawGlyphVector(sg2d, g, x, y);
        return;
    case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB:
    case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB:
         SurfaceData.lcdTextRenderer.drawGlyphVector(sg2d, g, x, y);
        return;
    default:
    }
}
 

private void drawGlyphListSegment(SunGraphics2D sg2d, GlyphList gl, int fromglyph, int toGlyph,
                                  int aaHint, boolean isColor) {
    if (fromglyph >= toGlyph) return;
    if (isColor) {
        sg2d.loops.drawGlyphListColorLoop.
                DrawGlyphListColor(sg2d, sg2d.surfaceData, gl, fromglyph, toGlyph);
    } else {
        switch (aaHint) {
            case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
                sg2d.loops.drawGlyphListLoop.
                        DrawGlyphList(sg2d, sg2d.surfaceData, gl, fromglyph, toGlyph);
                return;
            case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
                sg2d.loops.drawGlyphListAALoop.
                        DrawGlyphListAA(sg2d, sg2d.surfaceData, gl, fromglyph, toGlyph);
                return;
            case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB:
            case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB:
                sg2d.loops.drawGlyphListLCDLoop.
                        DrawGlyphListLCD(sg2d, sg2d.surfaceData, gl, fromglyph, toGlyph);
                return;
        }
    }
}
 

public void setFont(Font font) {
    /* replacing the reference equality test font != this.font with
     * !font.equals(this.font) did not yield any measurable difference
     * in testing, but there may be yet to be identified cases where it
     * is beneficial.
     */
    if (font != null && font!=this.font/*!font.equals(this.font)*/) {
        /* In the GASP AA case the textpipe depends on the glyph size
         * as determined by graphics and font transforms as well as the
         * font size, and information in the font. But we may invalidate
         * the pipe only to find that it made no difference.
         * Deferring pipe invalidation to checkFontInfo won't work because
         * when called we may already be rendering to the wrong pipe.
         * So, if the font is transformed, or the graphics has more than
         * a simple scale, we'll take that as enough of a hint to
         * revalidate everything. But if they aren't we will
         * use the font's point size to query the gasp table and see if
         * what it says matches what's currently being used, in which
         * case there's no need to invalidate the textpipe.
         * This should be sufficient for all typical uses cases.
         */
        if (textAntialiasHint == SunHints.INTVAL_TEXT_ANTIALIAS_GASP &&
            textpipe != invalidpipe &&
            (transformState > TRANSFORM_ANY_TRANSLATE ||
             font.isTransformed() ||
             fontInfo == null || // Precaution, if true shouldn't get here
             (fontInfo.aaHint == SunHints.INTVAL_TEXT_ANTIALIAS_ON) !=
                 FontUtilities.getFont2D(font).
                     useAAForPtSize(font.getSize()))) {
            textpipe = invalidpipe;
        }
        this.font = font;
        this.fontMetrics = null;
        this.validFontInfo = false;
    }
}
 

/**
* Get the rendering context of the font
* within this Graphics2D context.
*/
public FontRenderContext getFontRenderContext() {
    if (cachedFRC == null) {
        int aahint = textAntialiasHint;
        if (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT &&
            antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) {
            aahint = SunHints.INTVAL_TEXT_ANTIALIAS_ON;
        }
        // Translation components should be excluded from the FRC transform
        AffineTransform tx = null;
        if (transformState >= TRANSFORM_TRANSLATESCALE) {
            if (transform.getTranslateX() == 0 &&
                transform.getTranslateY() == 0) {
                tx = transform;
            } else {
                tx = new AffineTransform(transform.getScaleX(),
                                         transform.getShearY(),
                                         transform.getShearX(),
                                         transform.getScaleY(),
                                         0, 0);
            }
        }
        cachedFRC = new FontRenderContext(tx,
         SunHints.Value.get(SunHints.INTKEY_TEXT_ANTIALIASING, aahint),
         SunHints.Value.get(SunHints.INTKEY_FRACTIONALMETRICS,
                            fractionalMetricsHint));
    }
    return cachedFRC;
}
 

private TextPipe getTextPipe(SunGraphics2D sg2d, boolean aaHintIsOn) {

        /* Try to avoid calling getFontInfo() unless its needed to
         * resolve one of the new AA types.
         */
        switch (sg2d.textAntialiasHint) {
        case SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT:
            if (aaHintIsOn) {
                return aaTextRenderer;
            } else {
                return solidTextRenderer;
            }
        case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
            return solidTextRenderer;

        case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
            return aaTextRenderer;

        default:
            switch (sg2d.getFontInfo().aaHint) {

            case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB:
            case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB:
                return lcdTextRenderer;

            case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
                return aaTextRenderer;

            case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
                return solidTextRenderer;

                 /* This should not be reached as the FontInfo will
                 * always explicitly set its hint value. So whilst
                 * this could be collapsed to returning say just
                 * solidTextRenderer, or even removed, its left
                 * here in case DEFAULT is ever passed in.
                 */
            default:
                if (aaHintIsOn) {
                    return aaTextRenderer;
                } else {
                    return solidTextRenderer;
                }
            }
        }
    }
 

public void validatePipe(SunGraphics2D sg2d) {
    if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON &&
        sg2d.paintState <= sg2d.PAINT_ALPHACOLOR &&
        (sg2d.compositeState <= sg2d.COMP_ISCOPY ||
         sg2d.compositeState == sg2d.COMP_XOR))
    {
        if (sg2d.clipState == sg2d.CLIP_SHAPE) {
            // Do this to init textpipe correctly; we will override the
            // other non-text pipes below
            // REMIND: we should clean this up eventually instead of
            // having this work duplicated.
            super.validatePipe(sg2d);
        } else {
            switch (sg2d.textAntialiasHint) {

            case SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT:
                /* equate DEFAULT to OFF which it is for us */
            case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
                sg2d.textpipe = solidTextRenderer;
                break;

            case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
                sg2d.textpipe = aaTextRenderer;
                break;

            default:
                switch (sg2d.getFontInfo().aaHint) {

                case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB:
                case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB:
                    sg2d.textpipe = lcdTextRenderer;
                    break;

                case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
                    sg2d.textpipe = aaTextRenderer;
                    break;

                default:
                    sg2d.textpipe = solidTextRenderer;
                }
            }
        }
        sg2d.imagepipe = imagepipe;
        if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {
            sg2d.drawpipe = gdiTxPipe;
            sg2d.fillpipe = gdiTxPipe;
        } else if (sg2d.strokeState != sg2d.STROKE_THIN){
            sg2d.drawpipe = gdiTxPipe;
            sg2d.fillpipe = gdiPipe;
        } else {
            sg2d.drawpipe = gdiPipe;
            sg2d.fillpipe = gdiPipe;
        }
        sg2d.shapepipe = gdiPipe;
        // This is needed for AA text.
        // Note that even a SolidTextRenderer can dispatch AA text
        // if a GlyphVector overrides the AA setting.
        // We use getRenderLoops() rather than setting solidloops
        // directly so that we get the appropriate loops in XOR mode.
        if (sg2d.loops == null) {
            // assert(some pipe will always be a LoopBasedPipe)
            sg2d.loops = getRenderLoops(sg2d);
        }
    } else {
        super.validatePipe(sg2d);
    }
}
 

public void validatePipe(SunGraphics2D sg2d) {
    if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON &&
        sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR &&
        (sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY ||
         sg2d.compositeState == SunGraphics2D.COMP_XOR))
    {
        if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
            // Do this to init textpipe correctly; we will override the
            // other non-text pipes below
            // REMIND: we should clean this up eventually instead of
            // having this work duplicated.
            super.validatePipe(sg2d);
        } else {
            switch (sg2d.textAntialiasHint) {

            case SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT:
                /* equate DEFAULT to OFF which it is for us */
            case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
                sg2d.textpipe = solidTextRenderer;
                break;

            case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
                sg2d.textpipe = aaTextRenderer;
                break;

            default:
                switch (sg2d.getFontInfo().aaHint) {

                case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB:
                case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB:
                    sg2d.textpipe = lcdTextRenderer;
                    break;

                case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
                    sg2d.textpipe = aaTextRenderer;
                    break;

                default:
                    sg2d.textpipe = solidTextRenderer;
                }
            }
        }
        sg2d.imagepipe = imagepipe;
        if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
            sg2d.drawpipe = gdiTxPipe;
            sg2d.fillpipe = gdiTxPipe;
        } else if (sg2d.strokeState != SunGraphics2D.STROKE_THIN){
            sg2d.drawpipe = gdiTxPipe;
            sg2d.fillpipe = gdiPipe;
        } else {
            sg2d.drawpipe = gdiPipe;
            sg2d.fillpipe = gdiPipe;
        }
        sg2d.shapepipe = gdiPipe;
        // This is needed for AA text.
        // Note that even a SolidTextRenderer can dispatch AA text
        // if a GlyphVector overrides the AA setting.
        // We use getRenderLoops() rather than setting solidloops
        // directly so that we get the appropriate loops in XOR mode.
        if (sg2d.loops == null) {
            // assert(some pipe will always be a LoopBasedPipe)
            sg2d.loops = getRenderLoops(sg2d);
        }
    } else {
        super.validatePipe(sg2d);
    }
}