Java tutorial
/* ****************************************************************************** * Copyright (c) 2006-2012 XMind Ltd. and others. * * This file is a part of XMind 3. XMind releases 3 and * above are dual-licensed under the Eclipse Public License (EPL), * which is available at http://www.eclipse.org/legal/epl-v10.html * and the GNU Lesser General Public License (LGPL), * which is available at http://www.gnu.org/licenses/lgpl.html * See http://www.xmind.net/license.html for details. * * Contributors: * XMind Ltd. - initial API and implementation *******************************************************************************/ package org.xmind.ui.internal.views; import java.net.URL; import java.util.HashMap; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.eclipse.draw2d.ColorConstants; import org.eclipse.draw2d.Graphics; import org.eclipse.draw2d.geometry.Dimension; import org.eclipse.draw2d.geometry.Point; import org.eclipse.draw2d.geometry.Rectangle; import org.eclipse.jface.resource.JFaceResources; import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.RGB; import org.eclipse.swt.widgets.Display; import org.eclipse.ui.internal.util.BundleUtility; import org.xmind.core.internal.dom.NumberUtils; import org.xmind.core.style.IStyle; import org.xmind.core.style.IStyleSheet; import org.xmind.gef.draw2d.geometry.Geometry; import org.xmind.gef.draw2d.geometry.PrecisionPoint; import org.xmind.gef.draw2d.geometry.PrecisionPointPair; import org.xmind.gef.draw2d.geometry.PrecisionRectangle; import org.xmind.gef.draw2d.graphics.GradientPattern; import org.xmind.gef.draw2d.graphics.GraphicsUtils; import org.xmind.gef.draw2d.graphics.Path; import org.xmind.ui.internal.svgsupport.SvgFileLoader; import org.xmind.ui.internal.svgsupport.SvgPathParser; import org.xmind.ui.mindmap.MindMapUI; import org.xmind.ui.resources.ColorUtils; import org.xmind.ui.resources.FontUtils; import org.xmind.ui.style.StyleUtils; import org.xmind.ui.style.Styles; public class StyleFigureUtils { public static final int BOUNDARY_STEP = 16; public static final int BOUNDARY_PADDING = 8; public static final float CALLOUT_RRECT_PARAM = 0.2f; public static final float CALLOUT_ELLIPSE_STARTANGLE = -130; public static final float CALLOUT_ELLIPSE_ARCANGLE = 345; public static final int SPINY_WIDTH = 2; public static final int ROUNDED_CORNER = 7; public static final int ROUNDED_CORNER_ADAPTER = 30; private static final IStyleSheet defaultStyles = MindMapUI.getResourceManager().getDefaultStyleSheet(); public static final IStyle defaultSheetStyle = findOrCreateDefaultStyle(Styles.FAMILY_MAP, IStyle.MAP); public static final IStyle defaultCentralStyle = findOrCreateDefaultStyle(Styles.FAMILY_CENTRAL_TOPIC, IStyle.TOPIC); public static final IStyle defaultMainStyle = findOrCreateDefaultStyle(Styles.FAMILY_MAIN_TOPIC, IStyle.TOPIC); public static final IStyle defaultRelationshipStyle = findOrCreateDefaultStyle(Styles.FAMILY_RELATIONSHIP, IStyle.RELATIONSHIP); private StyleFigureUtils() { } private static IStyle findOrCreateDefaultStyle(String family, String type) { IStyle style = defaultStyles.findStyle(family); if (style == null) style = defaultStyles.createStyle(type); return style; } public static void angledRel(Path shape, Rectangle relBounds, Point c1, Point c2) { int dx = relBounds.width / 8; int dy = relBounds.height / 8; shape.moveTo(relBounds.getBottomLeft()); c1.setLocation(relBounds.getCenter().translate(-dx, -dy)); shape.lineTo(c1); c2.setLocation(relBounds.getCenter().translate(dx, dy)); shape.lineTo(c2); shape.lineTo(relBounds.getTopRight()); } public static void calloutEllipse(Path shape, Rectangle r) { Rectangle outlineBox = r; shape.addArc(outlineBox.x, outlineBox.y, outlineBox.width, outlineBox.height, CALLOUT_ELLIPSE_STARTANGLE, CALLOUT_ELLIPSE_ARCANGLE); float h = outlineBox.height; shape.lineTo(outlineBox.x, outlineBox.y + h); shape.close(); } public static void calloutRoundRect(Path shape, Rectangle r) { Rectangle box = r; float x = box.x; float y = box.y; float w = box.width; float h = box.height; float dy = h - box.height / 4.0f; float c = getAppliedCorner(r); shape.moveTo(x + w * CALLOUT_RRECT_PARAM, y + dy); shape.lineTo(x + w - c, y + dy); shape.addArc(x + w - c, y + dy - c, c, c, -90, 90); shape.lineTo(x + w, y + c); shape.addArc(x + w - c, y, c, c, 0, 90); shape.lineTo(x + c, y); shape.addArc(x, y, c, c, 90, 90); shape.lineTo(x, y + dy - c); shape.addArc(x, y + dy - c, c, c, 180, 90); shape.lineTo(box.x, box.y + h); shape.close(); } protected static int getAppliedCorner(Rectangle r) { int t = Math.min(r.height, r.width); return ROUNDED_CORNER * t / ROUNDED_CORNER_ADAPTER; } public static void circle(Path shape, Rectangle r) { shape.addArc(r, 0, 360); } public static void parallelogram(Path shape, Rectangle r) { shape.moveTo(r.x + r.height * 0.5f, r.y); shape.lineTo(r.getBottomLeft()); shape.lineTo(r.right() - r.height * 0.5f, r.bottom()); shape.lineTo(r.getTopRight()); shape.close(); } public static void cloud(Path path, Rectangle r) { URL url = BundleUtility.find("org.xmind.ui", //$NON-NLS-1$ "shapes/topic-shape-cloud.svg"); //$NON-NLS-1$ SvgFileLoader loader = SvgFileLoader.getInstance(); String svgPath = loader.loadSvgFile(url); SvgPathParser parser = SvgPathParser.getInstance(); parser.parseSvgPath(path, r.getCenter().x, r.getCenter().y, r.width, r.height, svgPath); } public static void strokeCircle(Path path, Rectangle r) { URL url = BundleUtility.find("org.xmind.ui", //$NON-NLS-1$ "shapes/topic-shape-stroke-circle.svg"); //$NON-NLS-1$ SvgFileLoader loader = SvgFileLoader.getInstance(); String svgPath = loader.loadSvgFile(url); SvgPathParser parser = SvgPathParser.getInstance(); parser.parseSvgPath(path, r.getCenter().x, r.getCenter().y, r.width, r.height, svgPath); } public static void curvedRel(Path shape, Rectangle relBounds, Point c1, Point c2) { // int dx = -relBounds.width / 10; // int dy = relBounds.height / 10; // shape.moveTo(relBounds.getBottomLeft()); int dx = -relBounds.width / 4; int dy = relBounds.height / 4; shape.moveTo(relBounds.getTopLeft()); Point p1 = relBounds.getTop().translate(-dx, -dy); Point p2 = relBounds.getBottom().translate(dx, dy); shape.cubicTo(p1, p2, relBounds.getTopRight()); c1.setLocation(p1.translate(0, dy)); c2.setLocation(p2.translate(0, -dy)); } public static void diamondTopic(Path shape, Rectangle r) { Rectangle r2 = r; shape.moveTo(r2.getLeft()); shape.lineTo(r2.getBottom()); shape.lineTo(r2.getRight()); shape.lineTo(r2.getTop()); shape.close(); } public static void diamondArrow(Path shape, Point head, double angle, int lineWidth) { int side1 = lineWidth + 3; int side2 = lineWidth + 2; PrecisionPoint p = new PrecisionPoint(head); PrecisionPoint p1 = p.getMoved(angle, side1); PrecisionPoint p2 = p.getMoved(angle - Math.PI / 2, side2); PrecisionPoint p3 = p.getMoved(angle + Math.PI, side1); PrecisionPoint p4 = p.getMoved(angle + Math.PI / 2, side2); shape.moveTo(p1); shape.lineTo(p2); shape.lineTo(p3); shape.lineTo(p4); shape.close(); } public static void dotArrow(Path shape, Point head, double angle, int lineWidth) { PrecisionRectangle bounds = new PrecisionRectangle(head.x, head.y, 0, 0).expand(lineWidth, lineWidth); shape.addArc(bounds, 0, 360); } public static void drawArrow(Graphics graphics, String arrowValue, Point head, Point tail, int lineWidth) { Path shape = new Path(Display.getCurrent()); boolean fill = true; double angle = new PrecisionPoint(tail).getAngle(new PrecisionPoint(head)); if (Styles.ARROW_SHAPE_DIAMOND.equals(arrowValue)) { diamondArrow(shape, head, angle, lineWidth); } else if (Styles.ARROW_SHAPE_DOT.equals(arrowValue)) { dotArrow(shape, head, angle, lineWidth); } else if (Styles.ARROW_SHAPE_HERRINGBONE.equals(arrowValue)) { herringBone(shape, head, angle, lineWidth); fill = false; } else if (Styles.ARROW_SHAPE_SPEARHEAD.equals(arrowValue)) { spearhead(shape, head, angle, lineWidth); } else if (Styles.ARROW_SHAPE_SQUARE.equals(arrowValue)) { square(shape, head, angle, lineWidth); } else if (Styles.ARROW_SHAPE_TRIANGLE.equals(arrowValue)) { triangle(shape, head, angle, lineWidth); } else { normalArrow(shape, head, angle, lineWidth); fill = false; } Color fgColor = graphics.getForegroundColor(); if (fgColor != null) { if (fill) { graphics.setBackgroundColor(fgColor); graphics.fillPath(shape); } graphics.drawPath(shape); } shape.dispose(); } public static void drawBoundary(Graphics graphics, Rectangle bounds, IStyle style, IStyle template) { drawBoundary(graphics, bounds, null, style, template); } public static void drawBoundary(Graphics graphics, Rectangle bounds, HashMap<String, String> existedStyle, IStyle style, IStyle template) { Rectangle boundaryBounds = boundaryBounds(bounds); Path shape = new Path(Display.getCurrent()); String shapeValue = getValue(existedStyle, Styles.ShapeClass, style, template); if (shapeValue == null || Styles.BOUNDARY_SHAPE_ROUNDEDRECT.equals(shapeValue)) { roundedRect(shape, boundaryBounds); } else if (Styles.BOUNDARY_SHAPE_RECT.equals(shapeValue)) { rectangle(shape, boundaryBounds); } else if (Styles.BOUNDARY_SHAPE_SCALLOPS.equals(shapeValue)) { scallops(shape, boundaryBounds); } else if (Styles.BOUNDARY_SHAPE_TENSION.equals(shapeValue)) { tension(shape, boundaryBounds); } else if (Styles.BOUNDARY_SHAPE_WAVES.equals(shapeValue)) { waves(shape, boundaryBounds); } else if (Styles.BOUNDARY_SHAPE_POLYGON.equals(shapeValue)) { polygon(shape, boundaryBounds); } else if (Styles.BOUNDARY_SHAPE_ROUNDEDPOLYGON.equals(shapeValue)) { roundedPolygon(shape, boundaryBounds); } else { roundedRect(shape, boundaryBounds); } String fillColorValue = getValue(existedStyle, Styles.FillColor, style, template); if (fillColorValue != null) { Color fillColor = ColorUtils.getColor(fillColorValue); if (fillColor != null) { String opacityValue = getValue(existedStyle, Styles.Opacity, style, template); double opacity = NumberUtils.safeParseDouble(opacityValue, 1); int alpha = (int) (opacity * 0xff); graphics.setAlpha(alpha); graphics.setBackgroundColor(fillColor); graphics.fillPath(shape); } } Color lineColor = getLineColor(existedStyle, style, template, ColorConstants.gray); String lineWidthValue = getValue(existedStyle, Styles.LineWidth, style, template); lineWidthValue = StyleUtils.trimNumber(lineWidthValue); int lineWidth = NumberUtils.safeParseInt(lineWidthValue, 3); graphics.setLineWidth(lineWidth); String linePatternValue = getValue(existedStyle, Styles.LinePattern, style, template); int linePattern = StyleUtils.toSWTLineStyle(linePatternValue, SWT.LINE_DASH); graphics.setLineStyle(linePattern); graphics.setAlpha(0xff); graphics.setForegroundColor(lineColor); graphics.drawPath(shape); shape.dispose(); } public static void drawMainBranches(Graphics graphics, Rectangle bounds, boolean spiny, boolean rainbow) { PrecisionPoint center = new PrecisionPoint(bounds.getCenter()); double length = Math.min(bounds.width, bounds.height) / 3; for (int i = 0; i < 6; i++) { double angle = Math.PI * (i - 1) / 3; PrecisionPoint p = center.getMoved(angle, length); if (p.y < center.y) p.y += (center.y - p.y) / 6; else if (p.y > center.y) p.y -= (p.y - center.y) / 6; if (Math.abs(p.y - center.y) > 0.000001) { if (p.x < center.x) p.x -= (center.x - p.x) / 6; else if (p.y > center.x) p.x += (p.x - center.x) / 6; } Color c = rainbow ? ColorUtils.getRainbowColor(i, 6) : ColorConstants.gray; graphics.setAlpha(0xff); graphics.setForegroundColor(c); graphics.setLineWidth(1); graphics.setLineStyle(SWT.LINE_SOLID); if (spiny) { PrecisionPoint c1 = center.getMoved(angle + Math.PI / 3, SPINY_WIDTH); PrecisionPoint c2 = center.getMoved(angle - Math.PI / 3, SPINY_WIDTH); Path shape = new Path(Display.getCurrent()); shape.moveTo(p); shape.lineTo(c1); shape.lineTo(c2); shape.close(); graphics.setBackgroundColor(c); graphics.fillPath(shape); graphics.drawPath(shape); shape.dispose(); } else { graphics.drawLine(center.toDraw2DPoint(), p.toDraw2DPoint()); } graphics.setBackgroundColor(ColorConstants.white); Rectangle oval = new PrecisionRectangle(center, center).getExpanded(4, 3).toDraw2DRectangle(); graphics.fillOval(oval); } } public static void drawSheetBackground(Graphics graphics, Rectangle bounds, IStyle style, IStyle template) { drawSheetBackground(graphics, bounds, null, style, template, true); } public static void drawSheetBackground(Graphics graphics, Rectangle bounds, IStyle style, IStyle template, boolean withMainBranches) { drawSheetBackground(graphics, bounds, null, style, template, withMainBranches); } public static void drawSheetBackground(Graphics graphics, Rectangle bounds, HashMap<String, String> existedStyle, IStyle style, IStyle template, boolean withMainBranches) { Rectangle sheetBounds = sheetBounds(bounds); Color fillColor = null; String fillColorValue = getValue(existedStyle, Styles.FillColor, style, template); if (fillColorValue != null) fillColor = ColorUtils.getColor(fillColorValue); if (fillColor != null) { graphics.setAlpha(0xff); graphics.setBackgroundColor(fillColor); graphics.fillRectangle(sheetBounds); } // if (fillColor == null) // fillColor = ColorUtils.getColor("#e0e0e0"); //$NON-NLS-1$ // if (withMainBranches) { // String spinyValue = getValue(Styles.SPINY_LINES, style, template); // String rainbowValue = getValue(Styles.RAINBOWCOLOR, style, template); // boolean spiny = Boolean.parseBoolean(spinyValue); // boolean rainbow = Boolean.parseBoolean(rainbowValue); // if (spiny || rainbow) { // drawMainBranches(graphics, bounds, spiny, rainbow); // } // } } public static void drawRelationship(Graphics graphics, Rectangle bounds, IStyle style, IStyle template) { drawRelationship(graphics, bounds, null, style, template); } public static void drawRelationship(Graphics graphics, Rectangle bounds, HashMap<String, String> existedStyle, IStyle style, IStyle template) { Rectangle relBounds = relBounds(bounds); Path shape = new Path(Display.getCurrent()); Point c1 = new Point(); Point c2 = new Point(); String shapeValue = getValue(existedStyle, Styles.ShapeClass, style, template); if (Styles.REL_SHAPE_ANGLED.equals(shapeValue)) { angledRel(shape, relBounds, c1, c2); } else if (Styles.REL_SHAPE_STRAIGHT.equals(shapeValue)) { straightRel(shape, relBounds, c1, c2); } else { curvedRel(shape, relBounds, c1, c2); } Color lineColor = getLineColor(existedStyle, style, template, ColorConstants.gray); String lineWidthValue = getValue(existedStyle, Styles.LineWidth, style, template); lineWidthValue = StyleUtils.trimNumber(lineWidthValue); int lineWidth = NumberUtils.safeParseInt(lineWidthValue, 3); graphics.setLineWidth(lineWidth); String linePatternValue = getValue(existedStyle, Styles.LinePattern, style, template); int linePattern = StyleUtils.toSWTLineStyle(linePatternValue, SWT.LINE_DOT); graphics.setLineStyle(linePattern); graphics.setAlpha(0xff); graphics.setForegroundColor(lineColor); graphics.drawPath(shape); shape.dispose(); graphics.setLineStyle(SWT.LINE_SOLID); String beginArrowValue = getValue(existedStyle, Styles.ArrowBeginClass, style, template); if (beginArrowValue != null && !Styles.ARROW_SHAPE_NONE.equals(beginArrowValue)) { drawArrow(graphics, beginArrowValue, relBounds.getBottomLeft(), c1, lineWidth); } String endArrowValue = getValue(existedStyle, Styles.ArrowEndClass, style, template); if (endArrowValue == null) endArrowValue = Styles.ARROW_SHAPE_NORMAL; if (!Styles.ARROW_SHAPE_NONE.equals(endArrowValue)) { drawArrow(graphics, endArrowValue, relBounds.getTopRight(), c2, lineWidth); } } public static Color getBranchConnectionColor(IStyle style, IStyle template, IStyle parentStyle, IStyle parentTemplate, int preferredIndex, Color defaultLineColor) { Color lineColor = null; if (preferredIndex >= 0 && parentStyle != null) { String multiColors = getValue(Styles.MultiLineColors, parentStyle, parentTemplate); if (multiColors == null) multiColors = template.getProperty(Styles.MultiLineColors); if (multiColors != null) { multiColors = multiColors.trim(); String[] colors = multiColors.split("[\\s]+"); //$NON-NLS-1$ if (colors.length > 0) { preferredIndex %= colors.length; String color = colors[preferredIndex].trim(); lineColor = ColorUtils.getColor(color); } } } if (lineColor == null) { lineColor = getLineColor(style, template, defaultLineColor); } return lineColor; } public static Color getLineColor(IStyle style, IStyle template, Color defaultLineColor) { return getLineColor(null, style, template, defaultLineColor); } public static Color getLineColor(HashMap<String, String> existedStyle, IStyle style, IStyle template, Color defaultLineColor) { Color lineColor = null; String lineColorValue = getValue(existedStyle, Styles.LineColor, style, template); if (lineColorValue != null) lineColor = ColorUtils.getColor(lineColorValue); if (lineColor == null) { lineColor = defaultLineColor; } return lineColor; } public static String getValue(String key, IStyle style, IStyle template) { return getValue(null, key, style, template); } public static String getValue(HashMap<String, String> existedStyle, String key, IStyle style, IStyle template) { String value = existedStyle == null ? null : existedStyle.get(key); value = style != null ? style.getProperty(key, value) : value; if (value == null) { value = template == null ? null : template.getProperty(key); } return value; } public static void drawLine(Graphics g, Rectangle srcBounds, IStyle srcStyle, IStyle srcTemplate, boolean srcCenterUnderline, Rectangle tgtBounds, IStyle tgtStyle, IStyle tgtTemplate, boolean tgtCenterUnderline, boolean tapered) { String line = getValue(Styles.LineClass, srcStyle, srcTemplate); if (Styles.BRANCH_CONN_NONE.equals(line)) return; String lineWidth = getValue(Styles.LineWidth, srcStyle, srcTemplate); lineWidth = StyleUtils.trimNumber(lineWidth); int width = NumberUtils.safeParseInt(lineWidth, 1); srcBounds = srcBounds.getExpanded(-width / 2, -width / 2); int tgtWidth = NumberUtils .safeParseInt(StyleUtils.trimNumber(getValue(Styles.LineWidth, tgtStyle, tgtTemplate)), 1); tgtBounds = tgtBounds.getExpanded(-tgtWidth / 2, -tgtWidth / 2); String srcShape = getValue(Styles.ShapeClass, srcStyle, srcTemplate); String tgtShape = getValue(Styles.ShapeClass, tgtStyle, tgtTemplate); Point srcPos = getSourcePos(srcBounds, srcShape, tgtBounds, tgtShape, srcCenterUnderline); Point tgtPos = getTargetPos(tgtBounds, tgtShape, srcBounds, srcShape, tgtCenterUnderline); Path shape = new Path(Display.getCurrent()); if (Styles.BRANCH_CONN_ELBOW.equals(line)) { elbow(shape, srcPos, tgtPos, tapered, width); } else if (Styles.BRANCH_CONN_ROUNDEDELBOW.equals(line)) { roundElbow(shape, srcPos, tgtPos, tapered, width); } else if (Styles.BRANCH_CONN_CURVE.equals(line) || Styles.BRANCH_CONN_ARROWED_CURVE.equals(line)) { curveConn(shape, srcPos, tgtPos, tapered, width); } else { // Straight and other unidentifiable line types straightConn(shape, srcPos, tgtPos, tapered, width); } g.setLineWidth(width); g.setLineStyle(SWT.LINE_SOLID); g.setAlpha(0xff); Color fgColor = g.getForegroundColor(); if (fgColor != null) { if (tapered) { g.setBackgroundColor(fgColor); g.fillPath(shape); } else g.drawPath(shape); } shape.dispose(); } public static Point getSourcePos(Rectangle srcBounds, String srcShape, Rectangle tgtBounds, String tgtShape, boolean centerUnderline) { if (Styles.TOPIC_SHAPE_UNDERLINE.equals(srcShape)) { if (centerUnderline) { if (tgtBounds.getCenter().x < srcBounds.getCenter().x) return srcBounds.getLeft(); return srcBounds.getRight(); } else { if (tgtBounds.getCenter().x < srcBounds.getCenter().x) return srcBounds.getBottomLeft(); return srcBounds.getBottomRight(); } } return Geometry.getChopBoxLocation(tgtBounds.getCenter(), srcBounds); } public static Point getTargetPos(Rectangle tgtBounds, String tgtShape, Rectangle srcBounds, String srcShape, boolean centerUnderline) { if (Styles.TOPIC_SHAPE_UNDERLINE.equals(tgtShape)) { if (centerUnderline) { if (tgtBounds.getCenter().x < srcBounds.getCenter().x) return tgtBounds.getRight(); return tgtBounds.getLeft(); } else { if (tgtBounds.getCenter().x < srcBounds.getCenter().x) return tgtBounds.getBottomRight(); return tgtBounds.getBottomLeft(); } } if (tgtBounds.getCenter().x < srcBounds.getCenter().x) return tgtBounds.getRight(); return tgtBounds.getLeft(); // return Geometry.getChopBoxLocation( srcBounds.getCenter(), tgtBounds ); } public static void drawTopic(Graphics graphics, Rectangle bounds, IStyle style, IStyle template, boolean centerUnderline) { drawTopic(graphics, bounds, style, template, centerUnderline, false); } public static void drawTopic(Graphics graphics, Rectangle bounds, IStyle style, IStyle template, boolean centerUnderline, boolean isGradientColor) { drawTopic(graphics, bounds, null, style, template, centerUnderline, isGradientColor); } public static void drawTopic(Graphics graphics, Rectangle bounds, HashMap<String, String> existedStyle, IStyle style, IStyle template, boolean centerUnderline, boolean isGradientColor) { Rectangle topicBounds = topicBounds(bounds); Path shape = new Path(Display.getCurrent()); boolean outline = true; boolean fill = true; String shapeValue = getValue(existedStyle, Styles.ShapeClass, style, template); if (shapeValue == null || Styles.TOPIC_SHAPE_ROUNDEDRECT.equals(shapeValue)) { roundedRect(shape, topicBounds); } else if (Styles.TOPIC_SHAPE_ELLIPSE.equals(shapeValue)) { ellipse(shape, topicBounds); } else if (Styles.TOPIC_SHAPE_RECT.equals(shapeValue)) { rectangle(shape, topicBounds); } else if (Styles.TOPIC_SHAPE_UNDERLINE.equals(shapeValue)) { underline(shape, topicBounds, centerUnderline); fill = false; } else if (Styles.TOPIC_SHAPE_NO_BORDER.equals(shapeValue)) { noBorder(shape, topicBounds); outline = false; } else if (Styles.TOPIC_SHAPE_DIAMOND.equals(shapeValue)) { diamondTopic(shape, topicBounds); } else if (Styles.TOPIC_SHAPE_CALLOUT_ELLIPSE.equals(shapeValue)) { calloutEllipse(shape, topicBounds); } else if (Styles.TOPIC_SHAPE_CALLOUT_ROUNDEDRECT.equals(shapeValue)) { calloutRoundRect(shape, topicBounds); } else if (Styles.TOPIC_SHAPE_CIRCLE.equals(shapeValue)) { Rectangle circleTopicBounds = circleTopicBounds(bounds); circle(shape, circleTopicBounds); } else if (Styles.TOPIC_SHAPE_PARALLELOGRAM.equals(shapeValue)) { parallelogram(shape, topicBounds); } else if (Styles.TOPIC_SHAPE_CLOUD.equals(shapeValue)) { cloud(shape, topicBounds); } else if (Styles.TOPIC_SHAPE_STROKE_CIRCLE.equals(shapeValue)) { strokeCircle(shape, topicBounds); } else { roundedRect(shape, topicBounds); } String fillColorValue = getValue(existedStyle, Styles.FillColor, style, template); graphics.setAlpha(0xff); if (fillColorValue != null) { Color fillColor = ColorUtils.getColor(fillColorValue); if (fillColor != null) { Path newPath = new Path(Display.getCurrent(), shape.getPathData()); if (!fill) { rectangle(newPath, topicBounds.expand(0, -1)); } int x = topicBounds.x; int y1 = topicBounds.y - topicBounds.height / 4; int y2 = topicBounds.y + topicBounds.height; if (isGradientColor) { GradientPattern bgPattern = new GradientPattern(Display.getCurrent(), x, y1, x, y2, ColorConstants.white, 0xff, fillColor, 0xff); graphics.setBackgroundPattern(bgPattern); graphics.fillPath(newPath); bgPattern.dispose(); } else { graphics.setBackgroundColor(fillColor); graphics.fillPath(newPath); } newPath.dispose(); } } if (outline) { Color lineColor = getLineColor(style, template, ColorConstants.gray); String lineColorValue = getValue(existedStyle, Styles.BorderLineColor, style, template); if (lineColorValue != null) lineColor = ColorUtils.getColor(lineColorValue); if (lineColor != null) { String lineWidthValue = getValue(existedStyle, Styles.BorderLineWidth, style, template); lineWidthValue = StyleUtils.trimNumber(lineWidthValue); if (lineWidthValue == null) lineWidthValue = getValue(existedStyle, Styles.LineWidth, style, template); int lineWidth = NumberUtils.safeParseInt(lineWidthValue, 1); if (lineWidth > 0) { graphics.setLineWidth(lineWidth); graphics.setLineStyle(SWT.LINE_SOLID); graphics.setForegroundColor(lineColor); graphics.drawPath(shape); } } } shape.dispose(); } public static void ellipse(Path shape, Rectangle r) { shape.addArc(r, 0, 360); } public static int getBoundaryPadding() { return BOUNDARY_PADDING; } public static void elbow(Path shape, Point p1, Point p2, boolean tapered, int width) { Point c = new Point(p1.x, p2.y); if (tapered) { PrecisionPoint _c = new PrecisionPoint(c); PrecisionPoint _p1 = new PrecisionPoint(p1); PrecisionPoint _p2 = new PrecisionPoint(p2); PrecisionPointPair _cc = Geometry.calculatePositionPair(_c, _p2, 0.5); PrecisionPointPair _pp2 = Geometry.calculatePositionPair(_p2, _c, 0.5).swap(); PrecisionPointPair _pp1 = Geometry.calculatePositionPair(_p1, _c, width); double d = (p1.x > p2.x == p1.y > p2.y) ? width * 0.5 : -width * 0.5; _cc.p1().x -= d; _cc.p2().x += d; shape.moveTo(_pp1.p1()); shape.lineTo(_cc.p1()); shape.lineTo(_pp2.p1()); shape.lineTo(_pp2.p2()); shape.lineTo(_cc.p2()); shape.lineTo(_pp1.p2()); shape.close(); } else { shape.moveTo(p1); shape.lineTo(c); shape.lineTo(p2); } } public static void roundElbow(Path shape, Point p1, Point p2, boolean tapered, int width) { Point c = new Point(p1.x, p2.y); int corner = getAppliedCorner(new Rectangle(p1, p2)) * 2; Point q1 = new Point(c.x, p1.y > p2.y ? c.y + corner : c.y - corner); Point q2 = new Point(p1.x > p2.x ? c.x - corner : c.x + corner, c.y); if (tapered) { PrecisionPoint _p1 = new PrecisionPoint(p1); PrecisionPoint _p2 = new PrecisionPoint(p2); PrecisionPoint _q1 = new PrecisionPoint(q1); PrecisionPoint _q2 = new PrecisionPoint(q2); PrecisionPoint _c1 = new PrecisionPoint(_q1.x, _q1.y + (c.y - _q1.y) * 3 / 4); PrecisionPoint _c2 = new PrecisionPoint(_q2.x + (c.x - _q2.x) * 3 / 4, _q2.y); PrecisionPoint _pc1 = new PrecisionPoint(_p1.x, _p1.y + (_c1.y - _p1.y) * 2); PrecisionPoint _pc2 = new PrecisionPoint(_p2.x + (_c2.x - _p2.x) * 2, _p2.y); PrecisionPointPair _pp1 = Geometry.calculatePositionPair(_p1, _c1, width); PrecisionPointPair _qq1 = Geometry.calculatePositionPair(_q1, _c1, width); PrecisionPointPair _cc1 = Geometry.calculatePositionPair(_c1, _pc1, width); PrecisionPointPair _pp2 = Geometry.calculatePositionPair(_p2, _c2, 0.5).swap(); PrecisionPointPair _qq2 = Geometry.calculatePositionPair(_q2, _c2, 0.5).swap(); PrecisionPointPair _cc2 = Geometry.calculatePositionPair(_c2, _pc2, 0.5).swap(); double d = (p1.x > p2.x == p1.y > p2.y) ? width * 0.5 : -width * 0.5; _qq2.p1().x -= d; _qq2.p2().x += d; _cc2.p1().x -= d; _cc2.p2().x += d; shape.moveTo(_pp1.p1()); shape.lineTo(_qq1.p1()); shape.cubicTo(_cc1.p1(), _cc2.p1(), _qq2.p1()); shape.lineTo(_pp2.p1()); shape.lineTo(_pp2.p2()); shape.lineTo(_qq2.p2()); shape.cubicTo(_cc2.p2(), _cc1.p2(), _qq1.p2()); shape.lineTo(_pp1.p2()); shape.close(); } else { shape.moveTo(p1); shape.lineTo(q1); shape.cubicTo(q1.x, q1.y + (c.y - q1.y) * 3 / 4, q2.x + (c.x - q2.x) * 3 / 4, q2.y, q2.x, q2.y); shape.lineTo(p2); } } public static void straightConn(Path shape, Point p1, Point p2, boolean tapered, int width) { if (tapered) { PrecisionPoint _p1 = new PrecisionPoint(p1); PrecisionPoint _p2 = new PrecisionPoint(p2); PrecisionPointPair _pp1 = Geometry.calculatePositionPair(_p1, _p2, width); PrecisionPointPair _pp2 = Geometry.calculatePositionPair(_p2, _p1, 0.5).swap(); shape.moveTo(_pp1.p1()); shape.lineTo(_pp2.p1()); shape.lineTo(_pp2.p2()); shape.moveTo(_pp1.p2()); shape.close(); } else { shape.moveTo(p1); shape.lineTo(p2); } } public static void curveConn(Path shape, Point p1, Point p2, boolean tapered, int width) { if (tapered) { PrecisionPoint _p1 = new PrecisionPoint(p1); PrecisionPoint _p2 = new PrecisionPoint(p2); PrecisionPoint _c = new PrecisionPoint(_p1.x + (_p2.x - _p1.x) * 2 / 10, _p2.y); PrecisionPointPair _pp1 = Geometry.calculatePositionPair(_p1, _p2, width); PrecisionPointPair _pp2 = Geometry.calculatePositionPair(_p2, _c, 0.5).swap(); PrecisionPointPair _cc = Geometry.calculatePositionPair(_c, _p2, 0.5); double d = (p1.x > p2.x == p1.y > p2.y) ? width * 0.5 : -width * 0.5; _cc.p1().x -= d; _cc.p2().x += d; shape.moveTo(_pp1.p1()); shape.quadTo(_cc.p1(), _pp2.p1()); shape.lineTo(_pp2.p2()); shape.quadTo(_cc.p2(), _pp1.p2()); shape.close(); } else { Point c = new Point(p1.x, p2.y); c.x += (p2.x - c.x) * 2 / 10; shape.moveTo(p1); shape.quadTo(c, p2); } } public static void herringBone(Path shape, Point head, double angle, int lineWidth) { int l = lineWidth * 2 + 4; int w = lineWidth * 2 + 2; PrecisionPoint p = new PrecisionPoint(head); PrecisionPoint p1 = p.getMoved(angle, l / 2); PrecisionPoint p2 = p.getMoved(angle, l); PrecisionPoint p01 = p.getMoved(angle - Math.PI * 2 / 3, w); PrecisionPoint p02 = p.getMoved(angle + Math.PI * 2 / 3, w); PrecisionPoint p11 = p1.getMoved(angle - Math.PI * 2 / 3, w); PrecisionPoint p12 = p1.getMoved(angle + Math.PI * 2 / 3, w); PrecisionPoint p21 = p2.getMoved(angle - Math.PI * 2 / 3, w); PrecisionPoint p22 = p2.getMoved(angle + Math.PI * 2 / 3, w); shape.moveTo(p01); shape.lineTo(head); shape.lineTo(p02); shape.moveTo(p11); shape.lineTo(p1); shape.lineTo(p12); shape.moveTo(p21); shape.lineTo(p2); shape.lineTo(p22); shape.moveTo(head); shape.lineTo(p2); } public static void noBorder(Path shape, Rectangle r) { shape.addRectangle(r); } public static void normalArrow(Path shape, Point head, double angle, int lineWidth) { int side = lineWidth * 2 + 4; PrecisionPoint p = new PrecisionPoint(head); PrecisionPoint p1 = p.getMoved(angle - Math.PI / 6, side); PrecisionPoint p2 = p.getMoved(angle + Math.PI / 6, side); shape.moveTo(p1); shape.lineTo(head); shape.lineTo(p2); } public static void rectangle(Path shape, Rectangle r) { shape.addRectangle(r); } public static void roundedRect(Path shape, Rectangle r) { shape.addRoundedRectangle(r, getAppliedCorner(r)); } public static void scallops(Path shape, Rectangle box) { int margin = getBoundaryPadding() * 3 / 5; if (box.width <= margin * 2 || box.height <= margin * 2) return; float width = box.width - margin * 2; float height = box.height - margin * 2; float stepX = BOUNDARY_STEP; float stepY = BOUNDARY_STEP * 6 / 8; int numX = Math.max(1, (int) (width / stepX)); int numY = Math.max(1, (int) (height / stepY)); stepX = width / numX; stepY = height / numY; float x = box.x + margin; float y = box.y + margin; shape.moveTo(x, y); for (int i = 0; i < numX; i++) { shape.cubicTo(x + stepX / 4, y - margin, x + stepX * 3 / 4, y - margin, x + stepX, y); x += stepX; } for (int i = 0; i < numY; i++) { shape.cubicTo(x + margin, y + stepY / 4, x + margin, y + stepY * 3 / 4, x, y + stepY); y += stepY; } for (int i = 0; i < numX; i++) { shape.cubicTo(x - stepX / 4, y + margin, x - stepX * 3 / 4, y + margin, x - stepX, y); x -= stepX; } for (int i = 0; i < numY; i++) { shape.cubicTo(x - margin, y - stepY / 4, x - margin, y - stepY * 3 / 4, x, y - stepY); y -= stepY; } shape.close(); } public static void spearhead(Path shape, Point head, double angle, int lineWidth) { int side = lineWidth * 2 + 6; PrecisionPoint p = new PrecisionPoint(head); PrecisionPoint p1 = p.getMoved(angle - Math.PI / 8, side); PrecisionPoint p2 = p.getMoved(angle + Math.PI / 8, side); PrecisionPoint cp = p.getMoved(angle, side / 2); shape.moveTo(head); shape.lineTo(p1); shape.quadTo(cp, p2); shape.close(); } public static void square(Path shape, Point head, double angle, int lineWidth) { int side = lineWidth + 2; PrecisionPoint p = new PrecisionPoint(head); PrecisionPoint p1 = p.getMoved(angle - Math.PI / 4, side); PrecisionPoint p2 = p.getMoved(angle - Math.PI * 3 / 4, side); PrecisionPoint p3 = p.getMoved(angle + Math.PI * 3 / 4, side); PrecisionPoint p4 = p.getMoved(angle + Math.PI / 4, side); shape.moveTo(p1); shape.lineTo(p2); shape.lineTo(p3); shape.lineTo(p4); shape.close(); } public static void straightRel(Path shape, Rectangle relBounds, Point c1, Point c2) { Point p = relBounds.getBottomLeft(); shape.moveTo(p); c2.setLocation(p); p = relBounds.getTopRight(); c1.setLocation(p); shape.lineTo(p); } public static void tension(Path shape, Rectangle box) { int margin = getBoundaryPadding() / 2; int margin2 = Math.max(1, margin / 4); if (box.width <= margin * 2 || box.height <= margin * 2) return; float width = box.width - margin2 * 2; float height = box.height - margin2 * 2; float stepX = BOUNDARY_STEP; float stepY = BOUNDARY_STEP; int numX = Math.max(1, (int) (width / stepX)); int numY = Math.max(1, (int) (height / stepY)); stepX = width / numX; stepY = height / numY; float x = box.x + margin2; float y = box.y + margin2; shape.moveTo(x, y); for (int i = 0; i < numX; i++) { shape.cubicTo(x + stepX / 4, y + margin, x + stepX * 3 / 4, y + margin, x + stepX, y); x += stepX; } for (int i = 0; i < numY; i++) { shape.cubicTo(x - margin, y + stepY / 4, x - margin, y + stepY * 3 / 4, x, y + stepY); y += stepY; } for (int i = 0; i < numX; i++) { shape.cubicTo(x - stepX / 4, y - margin, x - stepX * 3 / 4, y - margin, x - stepX, y); x -= stepX; } for (int i = 0; i < numY; i++) { shape.cubicTo(x + margin, y - stepY / 4, x + margin, y - stepY * 3 / 4, x, y - stepY); y -= stepY; } shape.close(); } public static void triangle(Path shape, Point head, double angle, int lineWidth) { int side = lineWidth * 2 + 4; PrecisionPoint p = new PrecisionPoint(head); PrecisionPoint p1 = p.getMoved(angle - Math.PI / 6, side); PrecisionPoint p2 = p.getMoved(angle + Math.PI / 6, side); shape.moveTo(p1); shape.lineTo(head); shape.lineTo(p2); shape.close(); } public static void underline(Path shape, Rectangle r, boolean center) { Rectangle r2 = r; if (center) { shape.moveTo(r2.getLeft()); shape.lineTo(r2.getRight()); } else { shape.moveTo(r2.getBottomLeft()); shape.lineTo(r2.getBottomRight()); } } public static void waves(Path shape, Rectangle box) { int margin = getBoundaryPadding() / 4; if (box.width <= margin * 2 || box.height <= margin * 2) return; float width = box.width - margin * 2; float height = box.height - margin * 2; float stepX = BOUNDARY_STEP; float stepY = BOUNDARY_STEP; int numX = Math.max(1, (int) (width / stepX)); int numY = Math.max(1, (int) (height / stepY)); stepX = width / numX; stepY = height / numY; float x = box.x + margin; float y = box.y + margin; float h = ((float) getBoundaryPadding()) / 4; shape.moveTo(x, y); for (int i = 0; i < numX; i++) { shape.cubicTo(x + stepX / 8, y - h, x + stepX * 3 / 8, y - h, x + stepX / 2, y); shape.cubicTo(x + stepX * 5 / 8, y + h, x + stepX * 7 / 8, y + h, x + stepX, y); x += stepX; } for (int i = 0; i < numY; i++) { shape.cubicTo(x + h, y + stepY / 8, x + h, y + stepY * 3 / 8, x, y + stepY / 2); shape.cubicTo(x - h, y + stepY * 5 / 8, x - h, y + stepY * 7 / 8, x, y + stepY); y += stepY; } for (int i = 0; i < numX; i++) { shape.cubicTo(x - stepX / 8, y + h, x - stepX * 3 / 8, y + h, x - stepX / 2, y); shape.cubicTo(x - stepX * 5 / 8, y - h, x - stepX * 7 / 8, y - h, x - stepX, y); x -= stepX; } for (int i = 0; i < numY; i++) { shape.cubicTo(x - h, y - stepY / 8, x - h, y - stepY * 3 / 8, x, y - stepY / 2); shape.cubicTo(x + h, y - stepY * 5 / 8, x + h, y - stepY * 7 / 8, x, y - stepY); y -= stepY; } shape.close(); } public static void polygon(Path shape, Rectangle box) { shape.moveTo(box.x + box.width / 2, box.y); shape.lineTo(box.x, box.y + box.height / 4); shape.lineTo(box.x, box.bottom() - box.height / 4); shape.lineTo(box.x + box.width / 2, box.bottom()); shape.lineTo(box.getBottomRight()); shape.lineTo(box.getTopRight()); shape.close(); } public static void roundedPolygon(Path shape, Rectangle box) { int corner = 4; Point p0 = calcRoundedPoint(box.getTop(), box.getTopRight(), corner); shape.moveTo(p0); cubicAndLine(shape, box.getTopRight(), box.getTop(), box.getTopLeft().getTranslated(0, box.height / 4), corner); cubicAndLine(shape, box.getTop(), box.getTopLeft().getTranslated(0, box.height / 4), box.getBottomLeft().getTranslated(0, -box.height / 4), corner); cubicAndLine(shape, box.getTopLeft().getTranslated(0, box.height / 4), box.getBottomLeft().getTranslated(0, -box.height / 4), box.getBottom(), corner); cubicAndLine(shape, box.getBottomLeft().getTranslated(0, -box.height / 4), box.getBottom(), box.getBottomRight(), corner); cubicAndLine(shape, box.getBottom(), box.getBottomRight(), box.getTopRight(), corner); cubicAndLine(shape, box.getBottomRight(), box.getTopRight(), box.getTop(), corner); shape.close(); } private static void cubicAndLine(Path shape, Point p0, Point p1, Point p2, int corner) { Point p3 = calcRoundedPoint(p1, p0, corner); Point p4 = calcRoundedPoint(p1, p2, corner); Point c1 = calcControlPoint(p3, p1); Point c2 = calcControlPoint(p4, p1); shape.cubicTo(c1, c2, p4); shape.lineTo(calcRoundedPoint(p2, p1, corner)); } private static Point calcRoundedPoint(Point p1, Point p2, int corner) { int dx = p2.x - p1.x; int dy = p2.y - p1.y; if (dx == 0) { if (dy > 0) return p1.getTranslated(0, corner); return p1.getTranslated(0, -corner); } else if (dy == 0) { if (dx > 0) return p1.getTranslated(corner, 0); return p1.getTranslated(-corner, 0); } else { double l = p1.getDistance(p2); double x = dx / l * corner; double y = dy / l * corner; return p1.getTranslated(x, y); } } private static Point calcControlPoint(Point p1, Point p2) { double dx = p2.x - p1.x; double dy = p2.y - p1.y; return p1.getTranslated(dx * 0.447715f, dy * 0.447715f); } private static void drawtext(Graphics graphics, String text, Rectangle parentRect, IStyle style, IStyle template, Font font) { drawtext(graphics, text, parentRect, null, style, template, font); } private static void drawtext(Graphics graphics, String text, Rectangle parentRect, HashMap<String, String> existedStyle, IStyle style, IStyle template, Font font) { String fontColor = getValue(existedStyle, Styles.TextColor, style, template); RGB fontColorRGB = ColorUtils.toRGB(fontColor); if (fontColorRGB == null) return; graphics.setForegroundColor(ColorUtils.getColor(fontColorRGB)); String textAlign = getValue(existedStyle, Styles.TextAlign, style, template); String textCase = getValue(existedStyle, Styles.TextCase, style, template); boolean isStrikedThrough = isStrikeout(existedStyle, style); boolean isUnderlined = isUnderline(existedStyle, style); if (Styles.UPPERCASE.equals(textCase)) { text = text.toUpperCase(); } else if (Styles.LOWERCASE.equals(textCase)) { text = text.toLowerCase(); } else if (Styles.CAPITALIZE.equals(textCase)) { text = capitalize(text); } Dimension textSize = GraphicsUtils.getAdvanced().getTextSize(text, font); graphics.setFont(font); int x = parentRect.x + (parentRect.width - textSize.width) / 4; int y = parentRect.y + (parentRect.height - textSize.height) / 2; if (Styles.ALIGN_CENTER.equals(textAlign)) { x += (parentRect.width - textSize.width) / 4; } else if (Styles.ALIGN_RIGHT.equals(textAlign)) { x += (parentRect.width - textSize.width) / 2; } graphics.drawText(text, x, y); y += textSize.height; if (isUnderlined) { Path underline = new Path(Display.getCurrent()); underline.moveTo(x, y - 1); underline.lineTo(x + textSize.width, y - 1); graphics.drawPath(underline); underline.dispose(); } if (isStrikedThrough) { Path strikeOutLine = new Path(Display.getCurrent()); strikeOutLine.moveTo(x, y - textSize.height / 2); strikeOutLine.lineTo(x + textSize.width, y - textSize.height / 2); graphics.drawPath(strikeOutLine); strikeOutLine.dispose(); } font.dispose(); } private static String capitalize(String str) { StringBuffer stringbf = new StringBuffer(); Matcher m = Pattern.compile("([a-z])([a-z]*)", Pattern.CASE_INSENSITIVE) //$NON-NLS-1$ .matcher(str); while (m.find()) { m.appendReplacement(stringbf, m.group(1).toUpperCase() + m.group(2).toLowerCase()); } return m.appendTail(stringbf).toString(); } public static void drawThemeText(Graphics graphics, String text, Rectangle parentRect, IStyle style, IStyle template) { String fontName = getFontName(style, template); int fontDataStyle = getFontDataStyle(style); Font font = new Font(null, fontName, 2, fontDataStyle); drawtext(graphics, text, parentRect, style, template, font); font.dispose(); } public static void drawStyleText(Graphics graphics, String text, Rectangle bounds, HashMap<String, String> existedStyle, IStyle style, IStyle template) { Rectangle parentRect = topicBounds(bounds); String fontName = getFontName(existedStyle, style, template); int fontDataStyle = getFontDataStyle(style); Font font = new Font(null, fontName, 7, fontDataStyle); drawtext(graphics, text, parentRect, existedStyle, style, template, font); font.dispose(); } private static int getFontDataStyle(HashMap<String, String> existedStyle, IStyle style) { boolean isBold = isBold(existedStyle, style); boolean isItalic = isItalic(existedStyle, style); int fontDataStyle = SWT.NORMAL; if (isBold) fontDataStyle |= SWT.BOLD; if (isItalic) fontDataStyle |= SWT.ITALIC; return fontDataStyle; } private static boolean isBold(HashMap<String, String> existedStyle, IStyle style) { String weight = getValue(existedStyle, Styles.FontWeight, style, null); return weight != null && weight.contains(Styles.FONT_WEIGHT_BOLD); } private static boolean isItalic(HashMap<String, String> existedStyle, IStyle style) { String weight = getValue(existedStyle, Styles.FontStyle, style, null); return weight != null && weight.contains(Styles.FONT_STYLE_ITALIC); } private static boolean isUnderline(HashMap<String, String> existedStyle, IStyle style) { String weight = getValue(existedStyle, Styles.TextDecoration, style, null); return weight != null && weight.contains(Styles.TEXT_DECORATION_UNDERLINE); } private static boolean isStrikeout(HashMap<String, String> existedStyle, IStyle style) { String weight = getValue(existedStyle, Styles.TextDecoration, style, null); return weight != null && weight.contains(Styles.TEXT_DECORATION_LINE_THROUGH); } private static int getFontDataStyle(IStyle style) { return getFontDataStyle(null, style); } private static String getFontName(IStyle style, IStyle template) { return getFontName(null, style, template); } private static String getFontName(HashMap<String, String> existedStyle, IStyle style, IStyle template) { String fontName = getValue(existedStyle, Styles.FontFamily, style, template); String availableFontName = FontUtils.getAAvailableFontNameFor(fontName); fontName = availableFontName != null ? availableFontName : fontName; if (Styles.SYSTEM.equals(fontName)) { fontName = JFaceResources.getDefaultFont().getFontData()[0].getName(); } return fontName; } private static Rectangle topicBounds(Rectangle r) { int width = r.width * 7 / 8; int height = width * 9 / 20; int x = r.x + r.width / 2 - width / 2; int y = r.y + r.height / 2 - height / 2; return new Rectangle(x, y, width, height); } private static Rectangle circleTopicBounds(Rectangle r) { int width = Math.min(r.width * 6 / 8, r.height * 6 / 8); int height = width; int x = r.x + r.width / 2 - width / 2; int y = r.y + r.height / 2 - height / 2; return new Rectangle(x, y, width, height); } private static Rectangle boundaryBounds(Rectangle r) { int width = r.width * 7 / 8; int height = width * 7 / 10; int x = r.x + r.width / 2 - width / 2; int y = r.y + r.height / 2 - height / 2; return new Rectangle(x, y, width, height); } private static Rectangle relBounds(Rectangle r) { int width = r.width * 6 / 8; int height = width * 7 / 10; int x = r.x + r.width / 2 - width / 2; int y = r.y + r.height / 2 - height / 2; return new Rectangle(x, y, width, height); } private static Rectangle sheetBounds(Rectangle r) { int width = r.width * 7 / 8; int height = width * 7 / 8; int x = r.x + r.width / 2 - width / 2; int y = r.y + r.height / 2 - height / 2; return new Rectangle(x, y, width, height); } }