| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2007 IBM Corporation and others. |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v1.0 |
| // which accompanies this distribution, and is available at |
| // http://www.eclipse.org/legal/epl-v10.html |
| // |
| // Contributors: |
| // IBM Corporation - initial implementation |
| //------------------------------------------------------------------------------ |
| package org.eclipse.epf.migration.diagram.ad.map; |
| |
| import org.eclipse.draw2d.geometry.Dimension; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.draw2d.geometry.PrecisionPoint; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.epf.authoring.gef.util.TemplateConstants; |
| import org.eclipse.epf.diagram.ad.edit.parts.ActivityFinalNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.ActivityFinalNodeNameEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.ActivityParameterNode2EditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.ActivityParameterNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.ActivityParameterNodeName2EditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.ActivityParameterNodeNameEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.ControlFlowEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.ControlFlowNameEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.DecisionNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.DecisionNodeNameEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.ForkNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.InitialNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.InitialNodeNameEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.JoinNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.MergeNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.MergeNodeNameEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.StructuredActivityNode2EditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.StructuredActivityNode3EditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.StructuredActivityNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.StructuredActivityNodeName2EditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.StructuredActivityNodeName3EditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.StructuredActivityNodeNameEditPart; |
| import org.eclipse.epf.diagram.ad.part.ActivityDiagramEditorPlugin; |
| import org.eclipse.epf.diagram.add.edit.parts.RoleTaskCompositeEditPart; |
| import org.eclipse.epf.diagram.add.edit.parts.WorkProductCompositeEditPart; |
| import org.eclipse.epf.diagram.add.part.ActivityDetailDiagramEditorPlugin; |
| import org.eclipse.epf.diagram.core.bridge.BridgeHelper; |
| import org.eclipse.epf.diagram.model.Link; |
| import org.eclipse.epf.diagram.model.RoleTaskComposite; |
| import org.eclipse.epf.diagram.model.WorkProductComposite; |
| import org.eclipse.epf.diagram.model.WorkProductNode; |
| import org.eclipse.epf.diagram.model.util.GraphicalDataHelper; |
| import org.eclipse.epf.diagram.wpdd.edit.parts.WorkProductNodeEditPart; |
| import org.eclipse.epf.diagram.wpdd.edit.parts.WorkProductNodeNameEditPart; |
| import org.eclipse.epf.diagram.wpdd.part.WPDDiagramEditorPlugin; |
| import org.eclipse.epf.uma.GraphNode; |
| import org.eclipse.epf.uma.Property; |
| import org.eclipse.gmf.runtime.common.ui.services.parser.CommonParserHint; |
| import org.eclipse.gmf.runtime.diagram.core.services.ViewService; |
| import org.eclipse.gmf.runtime.diagram.core.util.ViewType; |
| import org.eclipse.gmf.runtime.diagram.ui.preferences.IPreferenceConstants; |
| import org.eclipse.gmf.runtime.draw2d.ui.figures.FigureUtilities; |
| import org.eclipse.gmf.runtime.notation.Bounds; |
| import org.eclipse.gmf.runtime.notation.DescriptionStyle; |
| import org.eclipse.gmf.runtime.notation.Diagram; |
| import org.eclipse.gmf.runtime.notation.Edge; |
| import org.eclipse.gmf.runtime.notation.FillStyle; |
| import org.eclipse.gmf.runtime.notation.FontStyle; |
| import org.eclipse.gmf.runtime.notation.LineStyle; |
| import org.eclipse.gmf.runtime.notation.Node; |
| import org.eclipse.gmf.runtime.notation.NotationFactory; |
| import org.eclipse.gmf.runtime.notation.NotationPackage; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.preference.PreferenceConverter; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.uml2.uml.ActivityEdge; |
| import org.eclipse.uml2.uml.ActivityNode; |
| import org.eclipse.uml2.uml.ActivityParameterNode; |
| import org.eclipse.uml2.uml.ControlFlow; |
| import org.eclipse.uml2.uml.DecisionNode; |
| import org.eclipse.uml2.uml.FinalNode; |
| import org.eclipse.uml2.uml.ForkNode; |
| import org.eclipse.uml2.uml.InitialNode; |
| import org.eclipse.uml2.uml.JoinNode; |
| import org.eclipse.uml2.uml.MergeNode; |
| import org.eclipse.uml2.uml.NamedElement; |
| import org.eclipse.uml2.uml.StructuredActivityNode; |
| |
| /** |
| * @author Shilpa Toraskar |
| * @since 1.2 |
| */ |
| |
| public class MapUtil { |
| |
| /** |
| * Create notation node in diagram corresponding to activity node |
| * |
| * @param diagram |
| * @param umlNode |
| * @return |
| */ |
| public static Node createNotationNode_AD(Diagram diagram, Object obj) { |
| Node notationNode = null; |
| |
| ActivityNode umlNode = obj instanceof ActivityNode ? (ActivityNode) obj |
| : null; |
| if (umlNode instanceof StructuredActivityNode) { |
| String type = BridgeHelper.getEAnnotationType(umlNode, |
| BridgeHelper.UMA_TYPE); |
| if (type.equalsIgnoreCase(BridgeHelper.UMA_PHASE)) { |
| // Phase |
| notationNode = ViewService.createNode(diagram, umlNode, |
| new Integer(StructuredActivityNode2EditPart.VISUAL_ID) |
| .toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(notationNode, umlNode, new Integer( |
| StructuredActivityNodeName2EditPart.VISUAL_ID) |
| .toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| |
| } else if (type.equalsIgnoreCase(BridgeHelper.UMA_ITERATION)) { |
| // Iteration |
| notationNode = ViewService.createNode(diagram, umlNode, |
| new Integer(StructuredActivityNode3EditPart.VISUAL_ID) |
| .toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(notationNode, umlNode, new Integer( |
| StructuredActivityNodeName3EditPart.VISUAL_ID) |
| .toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } else { |
| // Activity |
| notationNode = ViewService.createNode(diagram, umlNode, |
| new Integer(StructuredActivityNodeEditPart.VISUAL_ID) |
| .toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(notationNode, umlNode, new Integer( |
| StructuredActivityNodeNameEditPart.VISUAL_ID) |
| .toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } |
| |
| // set default font style |
| setDefaultFontStyle(notationNode); |
| |
| } else if (umlNode instanceof InitialNode) { |
| notationNode = ViewService.createNode(diagram, umlNode, |
| new Integer(InitialNodeEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(notationNode, umlNode, new Integer( |
| InitialNodeNameEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } else if (umlNode instanceof DecisionNode) { |
| notationNode = ViewService.createNode(diagram, umlNode, |
| new Integer(DecisionNodeEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(notationNode, umlNode, new Integer( |
| DecisionNodeNameEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } else if (umlNode instanceof MergeNode) { |
| notationNode = ViewService.createNode(diagram, umlNode, |
| new Integer(MergeNodeEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(notationNode, umlNode, new Integer( |
| MergeNodeNameEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } else if (umlNode instanceof ForkNode) { |
| notationNode = ViewService.createNode(diagram, umlNode, |
| new Integer(ForkNodeEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } else if (umlNode instanceof JoinNode) { |
| notationNode = ViewService.createNode(diagram, umlNode, |
| new Integer(JoinNodeEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } else if (umlNode instanceof FinalNode) { |
| notationNode = ViewService |
| .createNode(diagram, umlNode, new Integer( |
| ActivityFinalNodeEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(notationNode, umlNode, new Integer( |
| ActivityFinalNodeNameEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } else if (umlNode instanceof ActivityParameterNode) { |
| String type = BridgeHelper.getEAnnotationType(umlNode, |
| BridgeHelper.UMA_TYPE); |
| if (type.equalsIgnoreCase(BridgeHelper.UMA_MILESTONE)) { |
| // Milestone |
| notationNode = ViewService.createNode(diagram, umlNode, |
| new Integer(ActivityParameterNode2EditPart.VISUAL_ID) |
| .toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(notationNode, umlNode, new Integer( |
| ActivityParameterNodeName2EditPart.VISUAL_ID) |
| .toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } else if (type.equalsIgnoreCase(BridgeHelper.UMA_TASK_DESCRIPTOR)) { |
| // TaskDescriptor |
| notationNode = ViewService.createNode(diagram, umlNode, |
| new Integer(ActivityParameterNodeEditPart.VISUAL_ID) |
| .toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService |
| .createNode(notationNode, umlNode, new Integer( |
| ActivityParameterNodeNameEditPart.VISUAL_ID) |
| .toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } |
| |
| // set default font style |
| setDefaultFontStyle(notationNode); |
| } |
| |
| return notationNode; |
| } |
| |
| /** |
| * Create notation node for model node in ADD and WPD |
| * @param diagram |
| * @param obj |
| * @return |
| */ |
| public static Node createNotationNode_ADDorWPD(Diagram diagram, org.eclipse.epf.diagram.model.Node obj) { |
| Node notationNode = null; |
| org.eclipse.epf.diagram.model.Node node = obj instanceof org.eclipse.epf.diagram.model.Node ? (org.eclipse.epf.diagram.model.Node) obj |
| : null; |
| if (node instanceof RoleTaskComposite) { |
| notationNode = ViewService.createNode(diagram, node, new Integer( |
| RoleTaskCompositeEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| /* |
| * ViewService.createNode(notationNode, node, new Integer( |
| * RoleTaskCompositeRoleTaskCompartmentEditPart.VISUAL_ID).toString(), |
| * ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| */ |
| } else if (node instanceof WorkProductComposite) { |
| notationNode = ViewService.createNode(diagram, node, new Integer( |
| WorkProductCompositeEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| /* |
| * ViewService.createNode(notationNode, node, new Integer( |
| * WorkProductCompositeWorkProductCompartmentEditPart.VISUAL_ID).toString(), |
| * ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| */ |
| } else if (node instanceof WorkProductNode) { |
| notationNode = ViewService.createNode(diagram, node, new Integer( |
| WorkProductNodeEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(notationNode, node, new Integer( |
| WorkProductNodeNameEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| } |
| |
| // set default font style for notation node |
| setDefaultFontStyle(notationNode); |
| return notationNode; |
| } |
| |
| /** |
| * |
| * Create text for free form text |
| * @param diagram |
| * @param node |
| * @return |
| */ |
| public static Node createText(Diagram diagram, |
| org.eclipse.epf.diagram.model.Node node) { |
| |
| // create text |
| Node text = ViewService.createNode(diagram, ViewType.TEXT, |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| |
| ViewService.createNode(text, ViewType.DIAGRAM_NAME, |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(text, CommonParserHint.DESCRIPTION, |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| |
| // create description |
| GraphNode graphNode = (GraphNode) node.getObject(); |
| String description = ""; //$NON-NLS-1$ |
| Property prop = GraphicalDataHelper.getPropertyByKey(graphNode |
| .getProperty(), GraphicalDataHelper.GRAPH_NODE_FREE_TEXT); |
| |
| if (prop != null) |
| description = prop.getValue(); |
| DescriptionStyle descStyle = (DescriptionStyle) text |
| .getStyle(NotationPackage.Literals.DESCRIPTION_STYLE); |
| descStyle.setDescription(description); |
| |
| // |
| IPreferenceStore store = (IPreferenceStore) ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT |
| .getPreferenceStore(); |
| |
| // create fill style |
| FillStyle fillStyle = (FillStyle) text |
| .getStyle(NotationPackage.Literals.FILL_STYLE); |
| if (fillStyle != null) { |
| // fill color |
| RGB fillRGB = PreferenceConverter.getColor(store, |
| IPreferenceConstants.PREF_FILL_COLOR); |
| fillStyle.setFillColor(FigureUtilities.RGBToInteger(fillRGB) |
| .intValue()); |
| } |
| |
| // create line style |
| LineStyle lineStyle = (LineStyle) text |
| .getStyle(NotationPackage.Literals.LINE_STYLE); |
| if (lineStyle != null) { |
| // line color |
| RGB lineRGB = PreferenceConverter.getColor(store, |
| IPreferenceConstants.PREF_LINE_COLOR); |
| lineStyle.setLineColor(FigureUtilities.RGBToInteger(lineRGB) |
| .intValue()); |
| } |
| |
| // create font style |
| FontStyle fontStyle = (FontStyle) text |
| .getStyle(NotationPackage.Literals.FONT_STYLE); |
| Font oldFont = null; |
| if (fontStyle != null) { |
| // get font properties |
| String fontName = getPropertyValue(graphNode, |
| TemplateConstants.PROPERTY_FONT_NAME); |
| if (fontName == null) fontName = TemplateConstants.DEFAULT_FONT_NAME; |
| String oldFontStyleStr = getPropertyValue(graphNode, |
| TemplateConstants.PROPERTY_FONT_STYLE); |
| String fontHeightStr = getPropertyValue(graphNode, |
| TemplateConstants.PROPERTY_FONT_HEIGHT); |
| String fontRed = getPropertyValue(graphNode, |
| TemplateConstants.PROPERTY_FONT_RED); |
| String fontGreen = getPropertyValue(graphNode, |
| TemplateConstants.PROPERTY_FONT_GREEN); |
| String fontBlue = getPropertyValue(graphNode, |
| TemplateConstants.PROPERTY_FONT_BLUE); |
| |
| int red = 0; |
| int green = 0; |
| int blue = 0; |
| |
| if (fontName != null) |
| fontStyle.setFontName(fontName); |
| |
| int oldFontStyle = 0; |
| if (oldFontStyleStr != null) { |
| oldFontStyle = new Integer(oldFontStyleStr).intValue(); |
| if (oldFontStyle == 1) |
| fontStyle.setBold(true); |
| if (oldFontStyle == 2) |
| fontStyle.setItalic(true); |
| if (oldFontStyle == 3) { |
| fontStyle.setBold(true); |
| fontStyle.setItalic(true); |
| } |
| } |
| |
| // set font height |
| int fontHeight = TemplateConstants.DEFAULT_FONT_SIZE; |
| if (fontHeightStr != null) |
| fontHeight = new Integer(fontHeightStr).intValue(); |
| fontStyle.setFontHeight(fontHeight); |
| |
| // set font RGB color |
| if (fontRed != null) |
| red = new Integer(fontRed).intValue(); |
| if (fontGreen != null) |
| green = new Integer(fontGreen).intValue(); |
| if (fontBlue != null) |
| blue = new Integer(fontBlue).intValue(); |
| |
| RGB fontRGB = new RGB(red, green, blue); |
| fontStyle.setFontColor(FigureUtilities.RGBToInteger(fontRGB) |
| .intValue()); |
| |
| // make old font as well |
| oldFont = new Font(null, fontName, fontHeight, oldFontStyle); |
| } |
| |
| Dimension d = FigureUtilities.getTextExtents(description, oldFont); |
| if (oldFont != null) { |
| oldFont.dispose(); |
| } |
| int noOfLines = 1; |
| if (d != null && d.width > 0) { |
| if (node.getWidth() == -1) |
| noOfLines = 1; |
| else { |
| int div = d.width / node.getWidth(); |
| int mod = d.width % node.getWidth(); |
| // if (mod != 0) |
| div++; |
| noOfLines = div; |
| } |
| } |
| |
| int textHeight = d.height; |
| |
| // create layout contraint |
| Bounds bounds = NotationFactory.eINSTANCE.createBounds(); |
| // bounds.setHeight(noOfLines * textHeight); |
| if (node.getWidth() == -1) { |
| int textWidth = d.width; |
| bounds.setWidth(textWidth); |
| } |
| else |
| bounds.setWidth(node.getWidth()); |
| bounds.setX(node.getLocation().x); |
| bounds.setY(node.getLocation().y); |
| |
| text.setLayoutConstraint(bounds); |
| return text; |
| } |
| |
| /** |
| * Create edge for AD diagram |
| * |
| * @param sourceNode |
| * @param targetNode |
| * @param actEdge |
| * @return |
| */ |
| public static Edge createEdge_AD(Node sourceNode, Node targetNode, |
| ActivityEdge actEdge) { |
| if (actEdge instanceof ControlFlow) { |
| Edge edge = ViewService.createEdge(sourceNode, targetNode, actEdge, |
| new Integer(ControlFlowEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(edge, actEdge, new Integer( |
| ControlFlowNameEditPart.VISUAL_ID).toString(), |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| return edge; |
| } |
| |
| |
| return null; |
| } |
| |
| |
| /** |
| * Create edge for WPD diagram |
| * |
| * @param sourceNode |
| * @param targetNode |
| * @param actEdge |
| * @return |
| */ |
| public static Edge createEdge_WPD(Node sourceNode, Node targetNode, |
| EObject actEdge) { |
| if (actEdge instanceof Link) { |
| Edge edge = ViewService.createEdge(sourceNode, targetNode, actEdge, |
| new Integer(org.eclipse.epf.diagram.wpdd.edit.parts.LinkEditPart.VISUAL_ID).toString(), |
| WPDDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(edge, actEdge, new Integer( |
| org.eclipse.epf.diagram.wpdd.edit.parts.LinkEditPart.VISUAL_ID).toString(), |
| WPDDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| return edge; |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Create edge for ADD diagram |
| * |
| * @param sourceNode |
| * @param targetNode |
| * @param actEdge |
| * @return |
| */ |
| public static Edge createEdge_ADD(Node sourceNode, Node targetNode, |
| EObject actEdge) { |
| if (actEdge instanceof Link) { |
| Edge edge = ViewService.createEdge(sourceNode, targetNode, actEdge, |
| new Integer(org.eclipse.epf.diagram.add.edit.parts.LinkEditPart.VISUAL_ID).toString(), |
| ActivityDetailDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| ViewService.createNode(edge, actEdge, new Integer( |
| org.eclipse.epf.diagram.add.edit.parts.LinkEditPart.VISUAL_ID).toString(), |
| ActivityDetailDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| return edge; |
| } |
| return null; |
| } |
| |
| /** |
| * |
| */ |
| private static String getPropertyValue(GraphNode graphNode, String key) { |
| Property prop = GraphicalDataHelper.getPropertyByKey(graphNode |
| .getProperty(), key); |
| |
| if (prop != null) { |
| return prop.getValue(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Calculates no of lines in the node text based on text width and width of |
| * figure |
| * |
| * @param node |
| * @return |
| */ |
| public static int getNoOfLines(Node node) { |
| int noOfLines = 1; |
| if (node.getElement() != null |
| && node.getElement() instanceof NamedElement) { |
| String text = ((NamedElement) node.getElement()).getName(); |
| Font f = TemplateConstants.DEFAULT_FONT; |
| Dimension d = FigureUtilities.getTextExtents(text, f); |
| |
| Bounds bounds = (Bounds) node.getLayoutConstraint(); |
| if (d != null && d.width > 0) { |
| int div = d.width / bounds.getWidth(); |
| int mod = d.width % bounds.getWidth(); |
| if (mod != 0) |
| div++; |
| noOfLines = div; |
| } |
| } |
| return noOfLines; |
| } |
| |
| /** |
| * Return height of text of th enode |
| * |
| * @param node |
| * @return |
| */ |
| public static int getTextHeight(Node node) { |
| if (node.getElement() != null |
| && node.getElement() instanceof NamedElement) { |
| String text = ((NamedElement) node.getElement()).getName(); |
| Font f = TemplateConstants.DEFAULT_FONT; |
| Dimension d = FigureUtilities.getTextExtents(text, f); |
| |
| if (d != null) |
| return d.height; |
| } |
| return 0; |
| } |
| |
| /** |
| * Convert point to terminal string |
| * |
| * @param p |
| * @return |
| */ |
| public static String composeTerminalString(PrecisionPoint p) { |
| final char TERMINAL_START_CHAR = '('; |
| final char TERMINAL_DELIMITER_CHAR = ','; |
| final char TERMINAL_END_CHAR = ')'; |
| |
| StringBuffer s = new StringBuffer(24); |
| s.append(TERMINAL_START_CHAR); // 1 char |
| s.append((float) p.preciseX); // 10 chars |
| s.append(TERMINAL_DELIMITER_CHAR); // 1 char |
| s.append((float) p.preciseY); // 10 chars |
| s.append(TERMINAL_END_CHAR); // 1 char |
| return s.toString(); // 24 chars max (+1 for safety, i.e. for string |
| // termination) |
| } |
| |
| /** |
| * Get relative anchor location |
| * |
| * @param p |
| * @param bounds |
| * @return |
| */ |
| public static PrecisionPoint getAnchorRelativeLocation(Point p, |
| Bounds bounds) { |
| PrecisionPoint relLocation; |
| Point temp = new Point(p); |
| if (p.x < bounds.getX() || p.x > bounds.getX() + bounds.getWidth() |
| || p.y < bounds.getY() |
| || p.y > bounds.getY() + bounds.getHeight()) { |
| if (p.x < bounds.getX() || p.x > bounds.getX() + bounds.getWidth()) { |
| temp.x = p.x < bounds.getX() ? bounds.getX() : bounds.getX() |
| + bounds.getWidth(); |
| } |
| if (p.y < bounds.getY() || p.y > bounds.getY() + bounds.getHeight()) { |
| temp.y = p.y < bounds.getY() ? bounds.getY() : bounds.getY() |
| + bounds.getHeight(); |
| } |
| relLocation = new PrecisionPoint((double) (temp.x - bounds.getX()) |
| / bounds.getWidth(), (double) (temp.y - bounds.getY()) |
| / bounds.getHeight()); |
| } else { |
| |
| relLocation = new PrecisionPoint((double) (temp.x - bounds.getX()) |
| / bounds.getWidth(), (double) (temp.y - bounds.getY()) |
| / bounds.getHeight()); |
| } |
| return relLocation; |
| } |
| |
| |
| /** |
| * Set default font style for notation node |
| * @param notationNode |
| */ |
| private static void setDefaultFontStyle(Node notationNode) { |
| // create font style |
| FontStyle fontStyle = (FontStyle) notationNode |
| .getStyle(NotationPackage.Literals.FONT_STYLE); |
| |
| if (fontStyle != null) { |
| |
| // set font name |
| String fontName = TemplateConstants.DEFAULT_FONT_NAME; |
| if (fontName != null) |
| fontStyle.setFontName(fontName); |
| |
| // set font height |
| int fontHeight = TemplateConstants.DEFAULT_FONT_SIZE; |
| fontStyle.setFontHeight(fontHeight); |
| } |
| } |
| } |
