Java 类java.awt.font.FontRenderContext 实例源码

public static void updateIcons(JTree tree) {
    Font defaultFont = UIManager.getFont("Tree.font");
    Font currentFont = tree.getFont();

    double newScale = (double)
            currentFont.getSize2D() / defaultFont.getSize2D();

    DefaultTreeCellRenderer renderer =
            (DefaultTreeCellRenderer) tree.getCellRenderer();
    renderer.setOpenIcon(
            scale(UIManager.getIcon("Tree.openIcon"), newScale, tree));
    renderer.setClosedIcon(
            scale(UIManager.getIcon("Tree.closedIcon"), newScale, tree));
    renderer.setLeafIcon(
            scale(UIManager.getIcon("Tree.leafIcon"), newScale, tree));

    Collection<Integer> iconSizes = Arrays.asList(
            renderer.getOpenIcon().getIconHeight(),
            renderer.getClosedIcon().getIconHeight(),
            renderer.getLeafIcon().getIconHeight());

    // Convert points to pixels
    Point2D p = new Point2D.Float(0, currentFont.getSize2D());
    FontRenderContext context =
            tree.getFontMetrics(currentFont).getFontRenderContext();
    context.getTransform().transform(p, p);
    int fontSizeInPixels = (int) Math.ceil(p.getY());

    tree.setRowHeight(
            Math.max(fontSizeInPixels, Collections.max(iconSizes) + 2));
}

public static void main(String[] args)
{
    Font defaultFont = new Font(null);
    FontRenderContext defaultFrc = new FontRenderContext(new AffineTransform(),
                                                         true, true);
    GlyphVector gv = defaultFont.createGlyphVector(defaultFrc, "test");

    //this causes the bounds to be cached
    //which is necessary to trigger the bug
    gv.getGlyphLogicalBounds(0);

    //this correctly gets the position of the overall advance
    Point2D glyphPosition = gv.getGlyphPosition(gv.getNumGlyphs());

    // this sets the position of the overall advance,
    // but also incorrectly tries to clear the bounds cache
    // of a specific glyph indexed by the glyphIndex parameter
    // even if the glyphIndex represents the overall advance
    // (i.e. if glyphIndex == getNumGlyphs())
    gv.setGlyphPosition(gv.getNumGlyphs(), glyphPosition);
}

public void paintComponent(Graphics g) {
     super.paintComponent(g);
     Graphics2D g2 = (Graphics2D)g;
     FontRenderContext frc = new FontRenderContext(null, true, true);
     Font f = helvFont.deriveFont(Font.PLAIN, 40);
     System.out.println("font = " +f.getFontName());
     GlyphVector gv = f.createGlyphVector(frc, codes);
     g.setFont(f);
     g.setColor(Color.white);
     g.fillRect(0,0,400,400);
     g.setColor(Color.black);
     g2.drawGlyphVector(gv, 5,200);
     g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                         RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
     g2.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
                         RenderingHints.VALUE_FRACTIONALMETRICS_ON);
     g2.drawString(str, 5, 250);
}

static void test(int sz) {
     Font reg = new Font(name, Font.PLAIN, sz);
     Font bold = new Font(name, Font.BOLD, sz);
     //System.out.println("reg="+reg);
     //System.out.println("bold="+bold);
     FontRenderContext frc = new FontRenderContext(null, false, false);
     if (reg.getFontName(Locale.ENGLISH).equals(name) &&
         bold.getFontName(Locale.ENGLISH).equals(name)) {
         Rectangle2D rb = reg.getStringBounds(" ", frc);
         Rectangle2D bb = bold.getStringBounds(" ", frc);
         if (bb.getWidth() > rb.getWidth() + 1.01f) {
             System.err.println("reg="+reg+" bds = " + rb);
             System.err.println("bold="+bold+" bds = " + bb);
             throw new RuntimeException("Advance difference too great.");
         }
     } else {
         System.out.println("Skipping test because fonts aren't as expected");
     }
}

/**
 * !!! not used currently, but might be by getPixelbounds?
 */
public void pixellate(FontRenderContext renderFRC, Point2D loc, Point pxResult) {
    if (renderFRC == null) {
        renderFRC = frc;
    }

    // it is a total pain that you have to copy the transform.

    AffineTransform at = renderFRC.getTransform();
    at.transform(loc, loc);
    pxResult.x = (int)loc.getX(); // but must not behave oddly around zero
    pxResult.y = (int)loc.getY();
    loc.setLocation(pxResult.x, pxResult.y);
    try {
        at.inverseTransform(loc, loc);
    }
    catch (NoninvertibleTransformException e) {
        throw new IllegalArgumentException("must be able to invert frc transform");
    }
}

public void drawGlyphVector(SunGraphics2D sg2d, GlyphVector gv,
                            float x, float y)
{
    FontRenderContext frc = gv.getFontRenderContext();
    FontInfo info = sg2d.getGVFontInfo(gv.getFont(), frc);
    if (info.pixelHeight > OutlineTextRenderer.THRESHHOLD) {
        SurfaceData.outlineTextRenderer.drawGlyphVector(sg2d, gv, x, y);
        return;
    }
    if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
        double origin[] = {x, y};
        sg2d.transform.transform(origin, 0, origin, 0, 1);
        x = (float) origin[0];
        y = (float) origin[1];
    } else {
        x += sg2d.transX; // don't use the glyph info origin, already in gv.
        y += sg2d.transY;
    }

    GlyphList gl = GlyphList.getInstance();
    gl.setFromGlyphVector(info, gv, x, y);
    drawGlyphList(sg2d, gl, info.aaHint);
    gl.dispose();
}

static void measureText() {
    Font font = new Font(FONT, Font.PLAIN, 36);
    if (!font.getFamily(Locale.ENGLISH).equals(FONT)) {
        return;
    }
    FontRenderContext frc = new FontRenderContext(null, false, false);
    TextLayout tl1 = new TextLayout(STR1, font, frc);
    TextLayout tl2 = new TextLayout(STR2, font, frc);
    Rectangle r1 = tl1.getPixelBounds(frc, 0f, 0f);
    Rectangle r2 = tl2.getPixelBounds(frc, 0f, 0f);
    if (r1.height > r2.height) {
        System.out.println(font);
        System.out.println(r1);
        System.out.println(r2);
        throw new RuntimeException("BAD BOUNDS");
    }
}

BufferedImage drawText(boolean doGV) {
    int w = 400;
    int h = 50;
    BufferedImage bi = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
    Graphics2D g = bi.createGraphics();
    g.setColor(Color.white);
    g.fillRect(0,0,w,h);
    g.setColor(Color.black);
    Font f = helvFont.deriveFont(Font.PLAIN, 40);
    g.setFont(f);
    int x = 5;
    int y = h - 10;
    if (doGV) {
        FontRenderContext frc = new FontRenderContext(null, true, true);
        GlyphVector gv = f.createGlyphVector(frc, codes);
        g.drawGlyphVector(gv, 5, y);
   } else {
       g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                          RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
       g.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
                          RenderingHints.VALUE_FRACTIONALMETRICS_ON);
       g.drawString(str, x, y);
   }
   return bi;
}

static void test(int sz) {
     Font reg = new Font(name, Font.PLAIN, sz);
     Font bold = new Font(name, Font.BOLD, sz);
     //System.out.println("reg="+reg);
     //System.out.println("bold="+bold);
     FontRenderContext frc = new FontRenderContext(null, false, false);
     if (reg.getFontName(Locale.ENGLISH).equals(name) &&
         bold.getFontName(Locale.ENGLISH).equals(name)) {
         Rectangle2D rb = reg.getStringBounds(" ", frc);
         Rectangle2D bb = bold.getStringBounds(" ", frc);
         if (bb.getWidth() > rb.getWidth() + 1.01f) {
             System.err.println("reg="+reg+" bds = " + rb);
             System.err.println("bold="+bold+" bds = " + bb);
             throw new RuntimeException("Advance difference too great.");
         }
     } else {
         System.out.println("Skipping test because fonts aren't as expected");
     }
}

protected int getLineNumberWidth() {
    int newWidth = 0;
    EditorUI eui = editorUI;
    if (eui != null) {
        /*
        Insets insets = eui.getLineNumberMargin();
        if (insets != null) {
            newWidth += insets.left + insets.right;
        }
         */
        JTextComponent tc = eui.getComponent();
        if (font != null && tc != null) {
            Graphics g;
            FontRenderContext frc;
            FontMetrics fm;
            if ((g = tc.getGraphics()) != null && (g instanceof Graphics2D) &&
                (frc = ((Graphics2D)g).getFontRenderContext()) != null)
            {
                newWidth += new TextLayout(String.valueOf(highestLineNumber), font, frc).getAdvance();
            } else if ((fm = getFontMetrics(font)) != null) {
                // Use FontMetrics.stringWidth() as best approximation
                newWidth += fm.stringWidth(String.valueOf(highestLineNumber));
            }
        }
    }

    return newWidth;
}

public static void main(String[] args) {
    Font font = new Font("Tahoma", Font.PLAIN, 12);
    String text = "\ude00";
    FontRenderContext frc = new FontRenderContext(null, false, false);
    TextLayout layout = new TextLayout(text, font, frc);
    layout.getCaretShapes(0);
}

private float getItalicAngle(FontRenderContext frc) {
    Object aa, fm;
    if (frc == null) {
        aa = RenderingHints.VALUE_TEXT_ANTIALIAS_OFF;
        fm = RenderingHints.VALUE_FRACTIONALMETRICS_OFF;
    } else {
        aa = frc.getAntiAliasingHint();
        fm = frc.getFractionalMetricsHint();
    }
    return getFont2D().getItalicAngle(this, identityTx, aa, fm);
}

/**
 * Initialize a factory to produce glyph arrays.
 * @param frc the FontRenderContext to use for the arrays to be produced.
 * @param text the text of the paragraph.
 * @param bidi the bidi information for the paragraph text, or null if the
 * entire text is left-to-right text.
 */
public TextLabelFactory(FontRenderContext frc,
                        char[] text,
                        Bidi bidi,
                        int flags) {
  this.frc = frc;
  this.text = text.clone();
  this.bidi = bidi;
  this.flags = flags;
  this.lineBidi = bidi;
  this.lineStart = 0;
  this.lineLimit = text.length;
}

@Override
protected void paintComponent(Graphics g) {
    atualizar();
    Graphics2D g2 = (Graphics2D) g;
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    g2.setFont(FONT);
    FontRenderContext frc = g2.getFontRenderContext();
    TextLayout textLayout = new TextLayout(Integer.toString(value), FONT, frc);
    g2.setPaint(textColor);
    Shape outline = textLayout.getOutline(AffineTransform.getTranslateInstance(value < 10 ? 20 : type == SHIELD ? 10 : 14, 30));
    g2.fill(outline);
    g2.setPaint(BLACK);
    g2.draw(outline);
}

private void myDrawChars(Graphics g, /* OLD char buf[], */ Line l,
        int start, int howmany, int xoff, int baseline) {

    if (xferBuf.length < l.length()) {
        xferBuf = new char[l.length()];
    }
    // OLD final char buf[] = l.XcharArray();
    l.getChars(xferBuf);

    // Use rendering hints (antialiasing etc.)
    Map<?,?> hints = renderingHints;
    if ((hints != null) && (g instanceof Graphics2D)) {
        ((Graphics2D) g).setRenderingHints(hints);
    }
    if (metrics.isMultiCell()) {
        // slow way
        // This looks expensive but it is in fact a whole lot faster
        // than issuing a g.drawChars() _per_ character

        Graphics2D g2 = (Graphics2D) g;
        FontRenderContext frc = g2.getFontRenderContext();
        // Gaaah, why doesn't createGlyphVector() take a (char[],offset,len)
        // triple?
        char[] tmp = new char[howmany];
        System.arraycopy(xferBuf, start, tmp, 0, howmany);
        GlyphVector gv = getFont().createGlyphVector(frc, tmp);
        massage_glyphs(gv, start, howmany, l);
        g2.drawGlyphVector(gv, xoff, baseline);
    } else {
        // fast way
        g.drawChars(xferBuf, start, howmany, xoff, baseline);
    }
}

/**
 * Returns the bounds for the character with the maximum
 * bounds as defined in the specified {@code FontRenderContext}.
 * <p>Note: The returned bounds is in baseline-relative coordinates
 * (see {@link java.awt.Font class notes}).
 * @param frc the specified {@code FontRenderContext}
 * @return a {@code Rectangle2D} that is the bounding box
 * for the character with the maximum bounds.
 */
public Rectangle2D getMaxCharBounds(FontRenderContext frc) {
    float [] metrics = new float[4];

    getFont2D().getFontMetrics(this, frc, metrics);

    return new Rectangle2D.Float(0, -metrics[0],
                            metrics[3],
                            metrics[0] + metrics[1] + metrics[2]);
}

public static void writeImage(File fontFile, File outputFile, String value) throws Exception {
    BufferedImage image = new BufferedImage(200, 200, BufferedImage.TYPE_INT_RGB);
    Graphics2D g = image.createGraphics();
    g.setColor(Color.WHITE);
    g.fillRect(0, 0, image.getWidth(), image.getHeight());
    g.setColor(Color.BLACK);

    Font font = Font.createFont(Font.TRUETYPE_FONT, fontFile);
    font = font.deriveFont(Font.PLAIN, 72f);
    FontRenderContext frc = new FontRenderContext(null, false, false);
    GlyphVector gv = font.createGlyphVector(frc, value);
    g.drawGlyphVector(gv, 10, 80);
    g.fill(gv.getOutline(10, 180));
    ImageIO.write(image, "png", outputFile);
}

/**
 * Returns Cell's real size (this method considers Icon and name size)
 *
 * @param graph <code>JGraph</code> object to retrieve font dimension informations
 * @return cell's real size
 *
 * Bertoli Marco  4-giu-2005
 */
public Dimension getSize(JGraph graph) {
    Dimension cellDimension = (Dimension) imageDimension.clone();
    // Gets the graph font
    Font font = graph.getFont();
    // Gets the graphical context
    Graphics2D g2D = (Graphics2D) graph.getGraphics();
    // Gets the bounds of the cell name
    FontRenderContext frc = g2D.getFontRenderContext();
    Rectangle r = font.getStringBounds(getUserObject().toString(), frc).getBounds();
    // Sets the cell dimension
    cellDimension.height += r.height + 5;
    cellDimension.width = Math.max(cellDimension.width, r.width + 10);
    return cellDimension;
}

public void runTest(Object ctx, int numReps) {
    TCContext tcctx = (TCContext)ctx;
    final Font font = tcctx.font;
    final CharacterIterator ci = tcctx.ci;
    final FontRenderContext frc = tcctx.frc;
    GlyphVector gv;
    do {
        gv = font.createGlyphVector(frc, ci);
    } while (--numReps >= 0);
}

/**
 * Returns the logical bounds of the specified array of characters
 * in the specified {@code FontRenderContext}.  The logical
 * bounds contains the origin, ascent, advance, and height, which
 * includes the leading.  The logical bounds does not always enclose
 * all the text.  For example, in some languages and in some fonts,
 * accent marks can be positioned above the ascent or below the
 * descent.  To obtain a visual bounding box, which encloses all the
 * text, use the {@link TextLayout#getBounds() getBounds} method of
 * {@code TextLayout}.
 * <p>Note: The returned bounds is in baseline-relative coordinates
 * (see {@link java.awt.Font class notes}).
 * @param chars an array of characters
 * @param beginIndex the initial offset in the array of
 * characters
 * @param limit the end offset in the array of characters
 * @param frc the specified {@code FontRenderContext}
 * @return a {@code Rectangle2D} that is the bounding box of the
 * specified array of characters in the specified
 * {@code FontRenderContext}.
 * @throws IndexOutOfBoundsException if {@code beginIndex} is
 *         less than zero, or {@code limit} is greater than the
 *         length of {@code chars}, or {@code beginIndex}
 *         is greater than {@code limit}.
 * @see FontRenderContext
 * @see Font#createGlyphVector
 * @since 1.2
 */
public Rectangle2D getStringBounds(char [] chars,
                                int beginIndex, int limit,
                                   FontRenderContext frc) {
    if (beginIndex < 0) {
        throw new IndexOutOfBoundsException("beginIndex: " + beginIndex);
    }
    if (limit > chars.length) {
        throw new IndexOutOfBoundsException("limit: " + limit);
    }
    if (beginIndex > limit) {
        throw new IndexOutOfBoundsException("range length: " +
                                            (limit - beginIndex));
    }

    // this code should be in textlayout
    // quick check for simple text, assume GV ok to use if simple

    boolean simple = values == null ||
        (values.getKerning() == 0 && values.getLigatures() == 0 &&
          values.getBaselineTransform() == null);
    if (simple) {
        simple = ! FontUtilities.isComplexText(chars, beginIndex, limit);
    }

    if (simple) {
        GlyphVector gv = new StandardGlyphVector(this, chars, beginIndex,
                                                 limit - beginIndex, frc);
        return gv.getLogicalBounds();
    } else {
        // need char array constructor on textlayout
        String str = new String(chars, beginIndex, limit - beginIndex);
        TextLayout tl = new TextLayout(str, this, frc);
        return new Rectangle2D.Float(0, -tl.getAscent(), tl.getAdvance(),
                                     tl.getAscent() + tl.getDescent() +
                                     tl.getLeading());
    }
}

protected BufferedImage createImage(Color bgColor) {
    BufferedImage bufferedImage = new BufferedImage(END_X, END_Y,
            BufferedImage.TYPE_INT_RGB);
    // create graphics and graphics2d
    final Graphics graphics = bufferedImage.getGraphics();
    final Graphics2D g2d = (Graphics2D) graphics;

    // set the background color
    g2d.setBackground(bgColor == null ? Color.gray : bgColor);
    g2d.clearRect(START_X, START_Y, END_X, END_Y);
    // create a pattern for the background
    createPattern(g2d);
    // set the fonts and font rendering hints
    Font font = new Font("Helvetica", Font.ITALIC, 30);
    g2d.setFont(font);
    FontRenderContext frc = g2d.getFontRenderContext();
    g2d.translate(10, 24);
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
    g2d.setStroke(new BasicStroke(3));

    // sets the foreground color
    g2d.setPaint(Color.DARK_GRAY);
    GlyphVector gv = font.createGlyphVector(frc, message);
    int numGlyphs = gv.getNumGlyphs();
    for (int ii = 0; ii < numGlyphs; ii++) {
        AffineTransform at;
        Point2D p = gv.getGlyphPosition(ii);
        at = AffineTransform.getTranslateInstance(p.getX(), p.getY());
        at.rotate(Math.PI / 8);
        Shape shape = gv.getGlyphOutline(ii);
        Shape sss = at.createTransformedShape(shape);
        g2d.fill(sss);
    }
    return blurImage(bufferedImage);
}

/**
 * Returns the logical bounds of the specified array of characters
 * in the specified <code>FontRenderContext</code>.  The logical
 * bounds contains the origin, ascent, advance, and height, which
 * includes the leading.  The logical bounds does not always enclose
 * all the text.  For example, in some languages and in some fonts,
 * accent marks can be positioned above the ascent or below the
 * descent.  To obtain a visual bounding box, which encloses all the
 * text, use the {@link TextLayout#getBounds() getBounds} method of
 * <code>TextLayout</code>.
 * <p>Note: The returned bounds is in baseline-relative coordinates
 * (see {@link java.awt.Font class notes}).
 * @param chars an array of characters
 * @param beginIndex the initial offset in the array of
 * characters
 * @param limit the end offset in the array of characters
 * @param frc the specified <code>FontRenderContext</code>
 * @return a <code>Rectangle2D</code> that is the bounding box of the
 * specified array of characters in the specified
 * <code>FontRenderContext</code>.
 * @throws IndexOutOfBoundsException if <code>beginIndex</code> is
 *         less than zero, or <code>limit</code> is greater than the
 *         length of <code>chars</code>, or <code>beginIndex</code>
 *         is greater than <code>limit</code>.
 * @see FontRenderContext
 * @see Font#createGlyphVector
 * @since 1.2
 */
public Rectangle2D getStringBounds(char [] chars,
                                int beginIndex, int limit,
                                   FontRenderContext frc) {
    if (beginIndex < 0) {
        throw new IndexOutOfBoundsException("beginIndex: " + beginIndex);
    }
    if (limit > chars.length) {
        throw new IndexOutOfBoundsException("limit: " + limit);
    }
    if (beginIndex > limit) {
        throw new IndexOutOfBoundsException("range length: " +
                                            (limit - beginIndex));
    }

    // this code should be in textlayout
    // quick check for simple text, assume GV ok to use if simple

    boolean simple = values == null ||
        (values.getKerning() == 0 && values.getLigatures() == 0 &&
          values.getBaselineTransform() == null);
    if (simple) {
        simple = ! FontUtilities.isComplexText(chars, beginIndex, limit);
    }

    if (simple) {
        GlyphVector gv = new StandardGlyphVector(this, chars, beginIndex,
                                                 limit - beginIndex, frc);
        return gv.getLogicalBounds();
    } else {
        // need char array constructor on textlayout
        String str = new String(chars, beginIndex, limit - beginIndex);
        TextLayout tl = new TextLayout(str, this, frc);
        return new Rectangle2D.Float(0, -tl.getAscent(), tl.getAdvance(),
                                     tl.getAscent() + tl.getDescent() +
                                     tl.getLeading());
    }
}

public Rectangle2D getBounds2D(String str, double x, double y,
        double dx, double dy, double scale) {

    if (isScaleInvariant()) {
        if (scale <= 0.d) {
            return new java.awt.geom.Rectangle2D.Double(x, y, 0, 0);
        } else {
            dx /= scale;
            dy /= scale;
        }
    } else {
        scale = 1;
    }

    // see http://forum.java.sun.com/thread.jspa?forumID=5&threadID=619854
    // for an example of how to measure text size
    FontRenderContext frc = new FontRenderContext(null, true, false);
    GlyphVector gv = font.createGlyphVector(frc, str);
    Rectangle2D visualBounds = gv.getVisualBounds();

    double voffset = visualBounds.getHeight() + visualBounds.getY();
    Rectangle2D bounds = new Rectangle2D.Double(x + dx,
            y - voffset + dy,
            visualBounds.getWidth() * this.fontScale / scale,
            visualBounds.getHeight() * this.fontScale / scale);
    return bounds;
}

protected void paintComponent(Graphics g) {  
            super.paintComponent(g);  
            Graphics2D g2 = (Graphics2D) g;  
            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,  
                    RenderingHints.VALUE_ANTIALIAS_ON);  
            int h = getHeight();  
            int width = getWidth();
            Polygon arrow = new Polygon();
//          Polygon leftArrow = new Polygon();

//                g2.drawImage(closed, PAD, 0, h, h, this); 
            g2.setFont(font);  
            FontRenderContext frc = g2.getFontRenderContext();  
            LineMetrics lm = font.getLineMetrics(title, frc);  
            float height = lm.getAscent() + lm.getDescent();  
            float x = OFFSET;  
            float y = (h + height) / 2 - lm.getDescent();  
            g2.drawString(title, x, y);
            int th = ((int)height)-2;
            if (selected) {
                arrow.addPoint(width - 3*th/2 + 1, h/2 - th/4);
                arrow.addPoint(width - th/2 - 1, h/2 - th/4);
                arrow.addPoint(width - th, h/2 + th/4 );
                g2.fillPolygon(arrow);
            }
//                g2.drawImage(open, PAD, 0, h, h, this); 
            else { 
                arrow.addPoint(width - 3*th/4, h/2 - (th-2)/2);
                arrow.addPoint(width - 3*th/4, h/2 + (th-2)/2);
                arrow.addPoint(width - 5*th/4, h /2);
                g2.fillPolygon(arrow);
            }
        }

public PhysicalStrike(Font font, FontFamily family, FontStyle style, FontRenderContext frc){
    this.font = font;
    this.family = family;
    this.style = style;
    this.frc = frc;
    this.size2D = font.getNetFont().get_Size();
    this.factor = size2D / family.GetEmHeight(style);
}

public static void main(String a[]) {
    /* prepare blank image */
    BufferedImage bi = new BufferedImage(50, 50, BufferedImage.TYPE_INT_RGB);
    Graphics2D g2 = (Graphics2D) bi.getGraphics();
    g2.setColor(Color.WHITE);
    g2.fillRect(0, 0, 50, 50);

    /* draw outline somethere in the middle of the image */
    FontRenderContext frc = new FontRenderContext(null, false, false);
    g2.setColor(Color.RED);
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    GlyphVector gv = g2.getFont().createGlyphVector(frc, "test");
    g2.fill(gv.getOutline(20, 20));

    /* Check if anything was drawn.
     * If y direction is not correct then image is still blank and
     * test will fail.
     */
    int bgcolor = Color.WHITE.getRGB();
    for (int i=0; i<bi.getWidth(); i++) {
        for(int j=0; j<bi.getHeight(); j++) {
           if (bi.getRGB(i, j) != bgcolor) {
               System.out.println("Test passed.");
               return;
           }
        }
    }
    throw new RuntimeException("Outline was not detected");
}

/**
 * Constructs a <code>LineBreakMeasurer</code> for the specified text.
 *
 * @param text the text for which this <code>LineBreakMeasurer</code>
 *     produces <code>TextLayout</code> objects; the text must contain
 *     at least one character; if the text available through
 *     <code>iter</code> changes, further calls to this
 *     <code>LineBreakMeasurer</code> instance are undefined (except,
 *     in some cases, when <code>insertChar</code> or
 *     <code>deleteChar</code> are invoked afterward - see below)
 * @param breakIter the {@link BreakIterator} which defines line
 *     breaks
 * @param frc contains information about a graphics device which is
 *       needed to measure the text correctly;
 *       text measurements can vary slightly depending on the
 *       device resolution, and attributes such as antialiasing; this
 *       parameter does not specify a translation between the
 *       <code>LineBreakMeasurer</code> and user space
 * @throws IllegalArgumentException if the text has less than one character
 * @see LineBreakMeasurer#insertChar
 * @see LineBreakMeasurer#deleteChar
 */
public LineBreakMeasurer(AttributedCharacterIterator text,
                         BreakIterator breakIter,
                         FontRenderContext frc) {
    if (text.getEndIndex() - text.getBeginIndex() < 1) {
        throw new IllegalArgumentException("Text must contain at least one character.");
    }

    this.breakIter = breakIter;
    this.measurer = new TextMeasurer(text, frc);
    this.limit = text.getEndIndex();
    this.pos = this.start = text.getBeginIndex();

    charIter = new CharArrayIterator(measurer.getChars(), this.start);
    this.breakIter.setText(charIter);
}

public void runTest(Object ctx, int numReps) {
    TCContext tcctx = (TCContext)ctx;
    final Font font = tcctx.font;
    final CharacterIterator ci = tcctx.ci;
    final FontRenderContext frc = tcctx.frc;
    GlyphVector gv;
    do {
        gv = font.createGlyphVector(frc, ci);
    } while (--numReps >= 0);
}

/**
 * Estimates the maximum tick label height.
 * 
 * @param g2  the graphics device.
 * 
 * @return The maximum height.
 */
protected double estimateMaximumTickLabelHeight(Graphics2D g2) {

    RectangleInsets tickLabelInsets = getTickLabelInsets();
    double result = tickLabelInsets.getTop() + tickLabelInsets.getBottom();

    Font tickLabelFont = getTickLabelFont();
    FontRenderContext frc = g2.getFontRenderContext();
    result += tickLabelFont.getLineMetrics("123", frc).getHeight();
    return result;

}

/**
 * Returns an <mxRectangle> with the size (width and height in pixels) of the given string.
 * 
 * @param text String whose size should be returned.
 * @param font Font to be used for the computation.
 */
public static mxRectangle getSizeForString(String text, Font font, double scale) {
  FontRenderContext frc = new FontRenderContext(null, false, false);
  font = font.deriveFont((float) (font.getSize2D() * scale));
  FontMetrics metrics = null;

  if (fontGraphics != null) {
    metrics = fontGraphics.getFontMetrics(font);
  }

  double lineHeight = mxConstants.LINESPACING;

  if (metrics != null) {
    lineHeight += metrics.getHeight();
  } else {
    lineHeight += font.getSize2D() * 1.27;
  }

  String[] lines = text.split("\n");

  Rectangle2D boundingBox = null;

  if (lines.length == 0) {
    boundingBox = font.getStringBounds("", frc);
  } else {
    for (int i = 0; i < lines.length; i++) {
      Rectangle2D bounds = font.getStringBounds(lines[i], frc);

      if (boundingBox == null) {
        boundingBox = bounds;
      } else {
        boundingBox.setFrame(0, 0, Math.max(boundingBox.getWidth(), bounds.getWidth()),
            boundingBox.getHeight() + lineHeight);
      }
    }
  }

  return new mxRectangle(boundingBox);
}

private float getItalicAngle(FontRenderContext frc) {
    Object aa, fm;
    if (frc == null) {
        aa = RenderingHints.VALUE_TEXT_ANTIALIAS_OFF;
        fm = RenderingHints.VALUE_FRACTIONALMETRICS_OFF;
    } else {
        aa = frc.getAntiAliasingHint();
        fm = frc.getFractionalMetricsHint();
    }
    return getFont2D().getItalicAngle(this, identityTx, aa, fm);
}

private void computeDimensions(Graphics g, Font font, FontMetrics fm) {
    String s = text;
    FontRenderContext frc = ((Graphics2D) g).getFontRenderContext();
    width = fm.stringWidth(s);
    ascent = fm.getAscent();
    descent = fm.getDescent();
    int[] xs = new int[s.length()];
    int[] ys = new int[s.length()];
    for (int i = 0; i < xs.length; i++) {
        xs[i] = fm.stringWidth(s.substring(0, i + 1));
        TextLayout lay = new TextLayout(s.substring(i, i + 1), font, frc);
        Rectangle2D rect = lay.getBounds();
        int asc = (int) Math.ceil(-rect.getMinY());
        int desc = (int) Math.ceil(rect.getMaxY());
        if (asc < 0)
            asc = 0;
        if (asc > 0xFFFF)
            asc = 0xFFFF;
        if (desc < 0)
            desc = 0;
        if (desc > 0xFFFF)
            desc = 0xFFFF;
        ys[i] = (asc << 16) | desc;
    }
    charX = xs;
    charY = ys;
    dimsKnown = true;
}

/**
 * The length of the metrics array must be >= 4.  This method will
 * store the following elements in that array before returning:
 *    metrics[0]: ascent
 *    metrics[1]: descent
 *    metrics[2]: leading
 *    metrics[3]: max advance
 */
public void getFontMetrics(Font font, FontRenderContext frc,
                           float metrics[]) {
    StrikeMetrics strikeMetrics = getStrike(font, frc).getFontMetrics();
    metrics[0] = strikeMetrics.getAscent();
    metrics[1] = strikeMetrics.getDescent();
    metrics[2] = strikeMetrics.getLeading();
    metrics[3] = strikeMetrics.getMaxAdvance();
}

/**
 * Constructs a {@code LineBreakMeasurer} for the specified text.
 *
 * @param text the text for which this {@code LineBreakMeasurer}
 *     produces {@code TextLayout} objects; the text must contain
 *     at least one character; if the text available through
 *     {@code iter} changes, further calls to this
 *     {@code LineBreakMeasurer} instance are undefined (except,
 *     in some cases, when {@code insertChar} or
 *     {@code deleteChar} are invoked afterward - see below)
 * @param breakIter the {@link BreakIterator} which defines line
 *     breaks
 * @param frc contains information about a graphics device which is
 *       needed to measure the text correctly;
 *       text measurements can vary slightly depending on the
 *       device resolution, and attributes such as antialiasing; this
 *       parameter does not specify a translation between the
 *       {@code LineBreakMeasurer} and user space
 * @throws IllegalArgumentException if the text has less than one character
 * @see LineBreakMeasurer#insertChar
 * @see LineBreakMeasurer#deleteChar
 */
public LineBreakMeasurer(AttributedCharacterIterator text,
                         BreakIterator breakIter,
                         FontRenderContext frc) {
    if (text.getEndIndex() - text.getBeginIndex() < 1) {
        throw new IllegalArgumentException("Text must contain at least one character.");
    }

    this.breakIter = breakIter;
    this.measurer = new TextMeasurer(text, frc);
    this.limit = text.getEndIndex();
    this.pos = this.start = text.getBeginIndex();

    charIter = new CharArrayIterator(measurer.getChars(), this.start);
    this.breakIter.setText(charIter);
}

private static void testFontRenderingContext(Object aaHint) {

        JLabel label = new JLabel("Test");
        label.putClientProperty(KEY_TEXT_ANTIALIASING, aaHint);
        FontRenderContext frc = label.getFontMetrics(
                label.getFont()).getFontRenderContext();

        if (!aaHint.equals(frc.getAntiAliasingHint())) {
            throw new RuntimeException("Wrong aa hint in FontRenderContext");
        }
    }

public void runTest(Object ctx, int numReps) {
    TCContext tcctx = (TCContext)ctx;
    final Font font = tcctx.font;
    final int[] glyphs = tcctx.glyphs;
    final FontRenderContext frc = tcctx.frc;
    GlyphVector gv;
    do {
        gv = font.createGlyphVector(frc, glyphs);
    } while (--numReps >= 0);
}

private FontDesignMetrics(Font font, FontRenderContext frc) {
  super(font);
  this.font = font;
  this.frc = frc;

  this.isAntiAliased = frc.isAntiAliased();
  this.usesFractionalMetrics = frc.usesFractionalMetrics();

  frcTx = frc.getTransform();

  matrix = new double[4];
  initMatrixAndMetrics();

  initAdvCache();
}

public StandardGlyphVector(Font font, FontRenderContext frc, int[] glyphs, float[] positions,
                           int[] indices, int flags) {
    initGlyphVector(font, frc, glyphs, positions, indices, flags);

    // this code should go into layout
    float track = getTracking(font);
    if (track != 0) {
        track *= font.getSize2D();
        Point2D.Float trackPt = new Point2D.Float(track, 0); // advance delta
        if (font.isTransformed()) {
            AffineTransform at = font.getTransform();
            at.deltaTransform(trackPt, trackPt);
        }

        // how do we know its a base glyph
        // for now, it is if the natural advance of the glyph is non-zero
        Font2D f2d = FontUtilities.getFont2D(font);
        FontStrike strike = f2d.getStrike(font, frc);

        float[] deltas = { trackPt.x, trackPt.y };
        for (int j = 0; j < deltas.length; ++j) {
            float inc = deltas[j];
            if (inc != 0) {
                float delta = 0;
                for (int i = j, n = 0; n < glyphs.length; i += 2) {
                    if (strike.getGlyphAdvance(glyphs[n++]) != 0) { // might be an inadequate test
                        positions[i] += delta;
                        delta += inc;
                    }
                }
                positions[positions.length-2+j] += delta;
            }
        }
    }
}

public StandardGlyphVector(Font font, FontRenderContext frc, int[] glyphs, float[] positions,
                           int[] indices, int flags) {
    initGlyphVector(font, frc, glyphs, positions, indices, flags);

    // this code should go into layout
    float track = getTracking(font);
    if (track != 0) {
        track *= font.getSize2D();
        Point2D.Float trackPt = new Point2D.Float(track, 0); // advance delta
        if (font.isTransformed()) {
            AffineTransform at = font.getTransform();
            at.deltaTransform(trackPt, trackPt);
        }

        // how do we know its a base glyph
        // for now, it is if the natural advance of the glyph is non-zero
        Font2D f2d = FontUtilities.getFont2D(font);
        FontStrike strike = f2d.getStrike(font, frc);

        float[] deltas = { trackPt.x, trackPt.y };
        for (int j = 0; j < deltas.length; ++j) {
            float inc = deltas[j];
            if (inc != 0) {
                float delta = 0;
                for (int i = j, n = 0; n < glyphs.length; i += 2) {
                    if (strike.getGlyphAdvance(glyphs[n++]) != 0) { // might be an inadequate test
                        positions[i] += delta;
                        delta += inc;
                    }
                }
                positions[positions.length-2+j] += delta;
            }
        }
    }
}

/**
 * Estimates the maximum width of the tick labels, assuming the specified 
 * tick unit is used.
 * <P>
 * Rather than computing the string bounds of every tick on the axis, we
 * just look at two values: the lower bound and the upper bound for the 
 * axis.  These two values will usually be representative.
 *
 * @param g2  the graphics device.
 * @param unit  the tick unit to use for calculation.
 *
 * @return The estimated maximum width of the tick labels.
 */
private double estimateMaximumTickLabelWidth(Graphics2D g2, 
                                             DateTickUnit unit) {

    RectangleInsets tickLabelInsets = getTickLabelInsets();
    double result = tickLabelInsets.getLeft() + tickLabelInsets.getRight();

    Font tickLabelFont = getTickLabelFont();
    FontRenderContext frc = g2.getFontRenderContext();
    LineMetrics lm = tickLabelFont.getLineMetrics("ABCxyz", frc);
    if (isVerticalTickLabels()) {
        // all tick labels have the same width (equal to the height of 
        // the font)...
        result += lm.getHeight();
    }
    else {
        // look at lower and upper bounds...
        DateRange range = (DateRange) getRange();
        Date lower = range.getLowerDate();
        Date upper = range.getUpperDate();
        String lowerStr = null;
        String upperStr = null;
        DateFormat formatter = getDateFormatOverride();
        if (formatter != null) {
            lowerStr = formatter.format(lower);
            upperStr = formatter.format(upper);
        }
        else {
            lowerStr = unit.dateToString(lower);
            upperStr = unit.dateToString(upper);
        }
        FontMetrics fm = g2.getFontMetrics(tickLabelFont);
        double w1 = fm.stringWidth(lowerStr);
        double w2 = fm.stringWidth(upperStr);
        result += Math.max(w1, w2);
    }

    return result;

}