/** * $Id: mxCurveLabelShape.java,v 1.16 2010-11-01 22:18:30 david Exp $ * Copyright (c) 2010, David Benson, Gaudenz Alder */ package com.mxgraph.shape; import java.awt.Color; import java.awt.Font; import java.awt.Graphics2D; import java.awt.Rectangle; import java.awt.RenderingHints; import java.awt.font.FontRenderContext; import java.awt.geom.AffineTransform; import java.util.List; import java.util.Map; import com.mxgraph.canvas.mxGraphics2DCanvas; import com.mxgraph.util.mxConstants; import com.mxgraph.util.mxCurve; import com.mxgraph.util.mxLine; import com.mxgraph.util.mxPoint; import com.mxgraph.util.mxRectangle; import com.mxgraph.util.mxUtils; import com.mxgraph.view.mxCellState; /** * Draws the edge label along a curve derived from the curve describing * the edge's path */ public class mxCurveLabelShape implements mxITextShape { /** * Cache of the label text */ protected String lastValue; /** * Cache of the label font */ protected Font lastFont; /** * Cache of the last set of guide points that this label was calculated for */ protected List<mxPoint> lastPoints; /** * Cache of the points between which drawing straight lines views as a * curve */ protected mxCurve curve; /** * Cache the state associated with this shape */ protected mxCellState state; /** * Cache of information describing characteristics relating to drawing * each glyph of this label */ protected LabelGlyphCache[] labelGlyphs; /** * Cache of the total length of the branch label */ protected double labelSize; /** * Cache of the bounds of the label */ protected mxRectangle labelBounds; /** * ADT to encapsulate label positioning information */ protected LabelPosition labelPosition = new LabelPosition(); /** * Buffer at both ends of the label */ public static double LABEL_BUFFER = 30; /** * Indicates that a glyph does not have valid drawing bounds, usually * because it is not visible */ public static mxRectangle INVALID_GLYPH_BOUNDS = new mxRectangle(0, 0, 0, 0); /** * The index of the central glyph of the label that is visible */ public int centerVisibleIndex = 0; /** * Shared FRC for font size calculations */ public static FontRenderContext frc = new FontRenderContext(null, false, false); /** * */ protected boolean rotationEnabled = true; public mxCurveLabelShape(mxCellState state, mxCurve value) { this.state = state; this.curve = value; } /** * */ public boolean getRotationEnabled() { return rotationEnabled; } /** * */ public void setRotationEnabled(boolean value) { rotationEnabled = value; } /** * */ public void paintShape(mxGraphics2DCanvas canvas, String text, mxCellState state, Map<String, Object> style) { Rectangle rect = state.getLabelBounds().getRectangle(); Graphics2D g = canvas.getGraphics(); if (labelGlyphs == null) { updateLabelBounds(text, style); } if (labelGlyphs != null && (g.getClipBounds() == null || g.getClipBounds().intersects( rect))) { // Creates a temporary graphics instance for drawing this shape float opacity = mxUtils.getFloat(style, mxConstants.STYLE_OPACITY, 100); Graphics2D previousGraphics = g; g = canvas.createTemporaryGraphics(style, opacity, state); Font font = mxUtils.getFont(style, canvas.getScale()); g.setFont(font); Color fontColor = mxUtils.getColor(style, mxConstants.STYLE_FONTCOLOR, Color.black); g.setColor(fontColor); g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON); for (int j = 0; j < text.length(); j++) { mxLine parallel = labelGlyphs[j].glyphVector; if (parallel != null && parallel != mxCurve.INVALID_POSITION) { double rotation = (Math.atan(parallel.getEndPoint().getY() / parallel.getEndPoint().getX())); final AffineTransform old = g.getTransform(); g.translate(parallel.getX(), parallel.getY()); g.rotate(rotation); g.drawString(text.substring(j, j + 1), 0f, 0f); g.setTransform(old); } } g.dispose(); g = previousGraphics; } } /** * Updates the cached position and size of each glyph in the edge label. * @param label the entire string of the label. * @param style the edge style */ public mxRectangle updateLabelBounds(String label, Map<String, Object> style) { double scale = state.getView().getScale(); Font font = mxUtils.getFont(style, scale); // Check that the size of the widths array matches // that of the label size if (labelGlyphs == null || label.length() != labelGlyphs.length) { labelGlyphs = new LabelGlyphCache[label.length()]; } if (!label.equals(lastValue) || !font.equals(lastFont)) { labelSize = 0; for (int i = 0; i < label.length(); i++) { String glyph = label.substring(i, i + 1); mxRectangle size = new mxRectangle(font.getStringBounds(glyph, mxCurveLabelShape.frc)); if (labelGlyphs[i] == null) { labelGlyphs[i] = new LabelGlyphCache(); } labelGlyphs[i].labelGlyphBounds = size; labelSize += size.getWidth(); labelGlyphs[i].glyph = glyph; } // Update values used to determine whether or not the label cache // is valid or not lastValue = label; lastFont = font; lastPoints = curve.getGuidePoints(); } // Store the start/end buffers that pad out the ends of the branch so the label is // visible. We work initially as the start section being at the start of the // branch and the end at the end of the branch. Note that the actual label curve // might be reversed, so we allow for this after completing the buffer calculations, // otherwise they'd need to be constant isReversed() checks throughout labelPosition.startBuffer = LABEL_BUFFER * scale; labelPosition.endBuffer = LABEL_BUFFER * scale; calculationLabelPosition(style, label); if (curve.isLabelReversed()) { double temp = labelPosition.startBuffer; labelPosition.startBuffer = labelPosition.endBuffer; labelPosition.endBuffer = temp; } double curveLength = curve.getCurveLength(mxCurve.LABEL_CURVE); double currentPos = labelPosition.startBuffer / curveLength; // Beyond this value we stop drawing. The +3 is to avoid rounding errors // cutting off the last character // double limitPos = (curveLength - endBuffer + 3) / curveLength; // TODO mxRectangle overallLabelBounds = null; centerVisibleIndex = 0; // TODO on translation just move the points, don't recalculate // Might be better than the curve is the only thing updated and // the curve shapes listen to curve events // !lastPoints.equals(curve.getGuidePoints()) for (int j = 0; j < label.length(); j++) { mxLine parallel = curve.getCurveParallel(mxCurve.LABEL_CURVE, currentPos); labelGlyphs[j].glyphVector = parallel; if (parallel == mxCurve.INVALID_POSITION) { labelGlyphs[j].labelGlyphBounds.setWidth(0); labelGlyphs[j].drawingBounds = INVALID_GLYPH_BOUNDS; continue; } // Get the four corners of the rotated rectangle bounding the glyph // The drawing bounds of the glyph is the unrotated rect that // just bounds those four corners final double w = labelGlyphs[j].labelGlyphBounds.getWidth(); final double h = labelGlyphs[j].labelGlyphBounds.getHeight(); final double x = parallel.getEndPoint().getX(); final double y = parallel.getEndPoint().getY(); // Bottom left double p1X = parallel.getX(); double minX = p1X, maxX = p1X; double p1Y = parallel.getY(); double minY = p1Y, maxY = p1Y; // Top left double p2X = p1X + (h * y); double p2Y = p1Y - (h * x); minX = Math.min(minX, p2X); maxX = Math.max(maxX, p2X); minY = Math.min(minY, p2Y); maxY = Math.max(maxY, p2Y); // Bottom right double p3X = p1X + (w * x); double p3Y = p1Y + (w * y); minX = Math.min(minX, p3X); maxX = Math.max(maxX, p3X); minY = Math.min(minY, p3Y); maxY = Math.max(maxY, p3Y); // Top right double p4X = p2X + (w * x); double p4Y = p2Y + (w * y); minX = Math.min(minX, p4X); maxX = Math.max(maxX, p4X); minY = Math.min(minY, p4Y); maxY = Math.max(maxY, p4Y); // Hook for sub-classers postprocessGlyph(curve, j, currentPos); currentPos += (labelGlyphs[j].labelGlyphBounds.getWidth() + labelPosition.defaultInterGlyphSpace) / curveLength; labelGlyphs[j].drawingBounds = new mxRectangle(minX - 1.0, minY - 1.0, maxX - minX + 2.0, maxY - minY + 2.0); if (overallLabelBounds == null) { overallLabelBounds = (mxRectangle) labelGlyphs[j].drawingBounds .clone(); } else { overallLabelBounds.add(labelGlyphs[j].drawingBounds); } centerVisibleIndex++; } centerVisibleIndex /= 2; if (overallLabelBounds == null) { // Return a small rectangle in the center of the label curve // Null label bounds causes NPE when editing mxLine labelCenter = curve.getCurveParallel(mxCurve.LABEL_CURVE, 0.5); overallLabelBounds = new mxRectangle(labelCenter.getX(), labelCenter.getY(), 1, 1); } this.labelBounds = overallLabelBounds; return overallLabelBounds; } /** * Hook for sub-classers to perform additional processing on * each glyph * @param j the index of the label * @param currentPos the distance along the label curve the glyph is */ protected void postprocessGlyph(mxCurve curve, int j, double currentPos) { } /** * Returns whether or not the rectangle passed in hits any part of this * curve. * @param rect the rectangle to detect for a hit * @return whether or not the rectangle hits this curve */ public boolean intersectsRect(Rectangle rect) { // To save CPU, we can test if the rectangle intersects the entire // bounds of this label if (labelBounds != null && (!labelBounds.getRectangle().intersects(rect))) { return false; } for (int i = 0; i < labelGlyphs.length; i++) { if (rect.intersects(labelGlyphs[i].drawingBounds.getRectangle())) { return true; } } return false; } /** * Hook method to override how the label is positioned on the curve * @param style the style of the curve * @param label the string label to be displayed on the curve */ protected void calculationLabelPosition(Map<String, Object> style, String label) { double curveLength = curve.getCurveLength(mxCurve.LABEL_CURVE); double availableLabelSpace = curveLength - labelPosition.startBuffer - labelPosition.endBuffer; labelPosition.startBuffer = Math.max(labelPosition.startBuffer, labelPosition.startBuffer + availableLabelSpace / 2 - labelSize / 2); labelPosition.endBuffer = Math.max(labelPosition.endBuffer, labelPosition.endBuffer + availableLabelSpace / 2 - labelSize / 2); } /** * @return the curve */ public mxCurve getCurve() { return curve; } /** * @param curve the curve to set */ public void setCurve(mxCurve curve) { this.curve = curve; } /** * Utility class to describe the characteristics of each glyph of a branch * branch label. Each instance represents one glyph * */ public class LabelGlyphCache { /** * Cache of the bounds of the individual element of the label of this * edge. Note that these are the unrotated values used to determine the * width of each glyph. */ public mxRectangle labelGlyphBounds; /** * The un-rotated rectangle that just bounds this character */ public mxRectangle drawingBounds; /** * The glyph being drawn */ public String glyph; /** * A line parallel to the curve segment at which the element is to be * drawn */ public mxLine glyphVector; } /** * Utility class that stores details of how the label is positioned * on the curve */ public class LabelPosition { public double startBuffer = LABEL_BUFFER; public double endBuffer = LABEL_BUFFER; public double defaultInterGlyphSpace = 0;; } public mxRectangle getLabelBounds() { return labelBounds; } /** * Returns the drawing bounds of the central indexed visible glyph * @return the centerVisibleIndex */ public mxRectangle getCenterVisiblePosition() { return labelGlyphs[centerVisibleIndex].drawingBounds; } }