bundles/org.simantics.diagram/src/org/simantics/diagram/participant/ConnectTool2.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.diagram.participant;\r
  13 \r
  14 import java.awt.AlphaComposite;\r
  15 import java.awt.BasicStroke;\r
  16 import java.awt.Color;\r
  17 import java.awt.Composite;\r
  18 import java.awt.geom.AffineTransform;\r
  19 import java.awt.geom.Path2D;\r
  20 import java.awt.geom.Point2D;\r
  21 import java.awt.geom.Rectangle2D;\r
  22 import java.util.ArrayDeque;\r
  23 import java.util.ArrayList;\r
  24 import java.util.Arrays;\r
  25 import java.util.Collection;\r
  26 import java.util.Collections;\r
  27 import java.util.Deque;\r
  28 import java.util.Iterator;\r
  29 import java.util.List;\r
  30 \r
  31 import org.simantics.Simantics;\r
  32 import org.simantics.db.ReadGraph;\r
  33 import org.simantics.db.Resource;\r
  34 import org.simantics.db.WriteGraph;\r
  35 import org.simantics.db.common.request.UniqueRead;\r
  36 import org.simantics.db.common.request.WriteRequest;\r
  37 import org.simantics.db.common.utils.NameUtils;\r
  38 import org.simantics.db.exception.DatabaseException;\r
  39 import org.simantics.diagram.connection.RouteGraph;\r
  40 import org.simantics.diagram.connection.RouteGraphConnectionClass;\r
  41 import org.simantics.diagram.connection.RouteLine;\r
  42 import org.simantics.diagram.connection.RouteTerminal;\r
  43 import org.simantics.diagram.connection.delta.RouteGraphDelta;\r
  44 import org.simantics.diagram.connection.rendering.arrows.PlainLineEndStyle;\r
  45 import org.simantics.diagram.content.ResourceTerminal;\r
  46 import org.simantics.diagram.stubs.DiagramResource;\r
  47 import org.simantics.diagram.synchronization.ISynchronizationContext;\r
  48 import org.simantics.diagram.synchronization.SynchronizationHints;\r
  49 import org.simantics.diagram.synchronization.graph.RouteGraphConnection;\r
  50 import org.simantics.g2d.canvas.ICanvasContext;\r
  51 import org.simantics.g2d.canvas.impl.DependencyReflection.Dependency;\r
  52 import org.simantics.g2d.canvas.impl.DependencyReflection.Reference;\r
  53 import org.simantics.g2d.canvas.impl.SGNodeReflection.SGCleanup;\r
  54 import org.simantics.g2d.canvas.impl.SGNodeReflection.SGInit;\r
  55 import org.simantics.g2d.connection.IConnectionAdvisor;\r
  56 import org.simantics.g2d.diagram.DiagramHints;\r
  57 import org.simantics.g2d.diagram.DiagramUtils;\r
  58 import org.simantics.g2d.diagram.IDiagram;\r
  59 import org.simantics.g2d.diagram.handler.PickContext;\r
  60 import org.simantics.g2d.diagram.handler.Topology.Terminal;\r
  61 import org.simantics.g2d.diagram.participant.ElementPainter;\r
  62 import org.simantics.g2d.diagram.participant.TerminalPainter;\r
  63 import org.simantics.g2d.diagram.participant.TerminalPainter.TerminalHoverStrategy;\r
  64 import org.simantics.g2d.diagram.participant.pointertool.AbstractMode;\r
  65 import org.simantics.g2d.diagram.participant.pointertool.PointerInteractor;\r
  66 import org.simantics.g2d.diagram.participant.pointertool.TerminalUtil;\r
  67 import org.simantics.g2d.diagram.participant.pointertool.TerminalUtil.TerminalInfo;\r
  68 import org.simantics.g2d.element.ElementClass;\r
  69 import org.simantics.g2d.element.ElementClasses;\r
  70 import org.simantics.g2d.element.ElementUtils;\r
  71 import org.simantics.g2d.element.IElement;\r
  72 import org.simantics.g2d.element.IElementClassProvider;\r
  73 import org.simantics.g2d.element.handler.EdgeVisuals.EdgeEnd;\r
  74 import org.simantics.g2d.element.handler.SceneGraph;\r
  75 import org.simantics.g2d.element.handler.TerminalTopology;\r
  76 import org.simantics.g2d.element.handler.impl.BranchPointTerminal;\r
  77 import org.simantics.g2d.element.impl.Element;\r
  78 import org.simantics.g2d.elementclass.BranchPoint;\r
  79 import org.simantics.g2d.elementclass.BranchPoint.Direction;\r
  80 import org.simantics.g2d.elementclass.FlagClass;\r
  81 import org.simantics.g2d.elementclass.FlagHandler;\r
  82 import org.simantics.g2d.participant.RenderingQualityInteractor;\r
  83 import org.simantics.g2d.participant.TransformUtil;\r
  84 import org.simantics.g2d.utils.geom.DirectionSet;\r
  85 import org.simantics.modeling.ModelingResources;\r
  86 import org.simantics.scenegraph.g2d.G2DParentNode;\r
  87 import org.simantics.scenegraph.g2d.events.EventHandlerReflection.EventHandler;\r
  88 import org.simantics.scenegraph.g2d.events.KeyEvent;\r
  89 import org.simantics.scenegraph.g2d.events.KeyEvent.KeyPressedEvent;\r
  90 import org.simantics.scenegraph.g2d.events.MouseEvent;\r
  91 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseButtonEvent;\r
  92 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseButtonPressedEvent;\r
  93 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseMovedEvent;\r
  94 import org.simantics.scenegraph.g2d.events.command.CommandEvent;\r
  95 import org.simantics.scenegraph.g2d.events.command.Commands;\r
  96 import org.simantics.scenegraph.g2d.nodes.BranchPointNode;\r
  97 import org.simantics.scenegraph.g2d.nodes.ShapeNode;\r
  98 import org.simantics.scenegraph.g2d.snap.ISnapAdvisor;\r
  99 import org.simantics.scenegraph.utils.GeometryUtils;\r
 100 import org.simantics.scenegraph.utils.Quality;\r
 101 import org.simantics.structural2.modelingRules.ConnectionJudgement;\r
 102 import org.simantics.utils.datastructures.Callback;\r
 103 import org.simantics.utils.datastructures.Pair;\r
 104 import org.simantics.utils.logging.TimeLogger;\r
 105 import org.simantics.utils.ui.ErrorLogger;\r
 106 import org.simantics.utils.ui.ExceptionUtils;\r
 107 \r
 108 import gnu.trove.map.hash.THashMap;\r
 109 \r
 110 /**\r
 111  * A basic tool for making connection on diagrams.\r
 112  * \r
 113  * This version defines the starting, ending and route points of a connection.\r
 114  * The routing itself is left up to the diagram router employed by\r
 115  * {@link DiagramUtils#validateAndFix(IDiagram, ICanvasContext)}.\r
 116  * \r
 117  * Manual:\r
 118  * \r
 119  * This tool is added to the diagram when a connection sequence is initiated by\r
 120  * another participant. PointerInteractor is one such participant which adds the\r
 121  * tool when a terminal or non-terminal-occupied canvas space is ALT+clicked\r
 122  * (see {@link PointerInteractor#checkInitiateConnectTool(MouseEvent, Point2D)}\r
 123  * ). The connection will be finished when another allowed terminal is clicked\r
 124  * upon or empty canvas space is ALT+clicked. Route points for the connection\r
 125  * can be created by clicking around on non-terminal-occupied canvas space while\r
 126  * connecting.\r
 127  * \r
 128  * <p>\r
 129  * Connections can be started from and ended in flags by pressing ALT while\r
 130  * left-clicking.\r
 131  * \r
 132  * @author Tuukka Lehtonen\r
 133  */\r
 134 public class ConnectTool2 extends AbstractMode {\r
 135 \r
 136     public static final int          PAINT_PRIORITY        = ElementPainter.ELEMENT_PAINT_PRIORITY + 5;\r
 137 \r
 138     @Reference\r
 139     protected RenderingQualityInteractor quality;\r
 140 \r
 141     @Dependency\r
 142     protected TransformUtil          util;\r
 143 \r
 144     @Dependency\r
 145     protected ElementPainter         diagramPainter;\r
 146 \r
 147     @Dependency\r
 148     protected PointerInteractor      pi;\r
 149 \r
 150     @Dependency\r
 151     protected PickContext            pickContext;\r
 152 \r
 153     /**\r
 154      * Start element terminal of the connection. <code>null</code> if connection\r
 155      * was started from a flag or a branch point.\r
 156      * \r
 157      * The value is received by the constructor.\r
 158      */\r
 159     protected List<TerminalInfo>     startTerminals;\r
 160 \r
 161     /**\r
 162      * Refers to any of the possible overlapping start terminals. The value is\r
 163      * taken from the first index of {@link #startTerminals} assuming that the\r
 164      * first one is the nearest. It is <code>null</code> if\r
 165      * {@link #startTerminals} is empty.\r
 166      */\r
 167     protected TerminalInfo           startTerminal;\r
 168 \r
 169     protected TerminalInfo           startFlag;\r
 170 \r
 171     /**\r
 172      * Starting position of the connection, received as an external argument.\r
 173      */\r
 174     protected final Point2D          startPos;\r
 175 \r
 176     /**\r
 177      * <code>true</code> if this tool should create connection continuation\r
 178      * flags, <code>false</code> otherwise.\r
 179      */\r
 180     protected boolean                createFlags;\r
 181 \r
 182     /**\r
 183      * \r
 184      */\r
 185     protected IElementClassProvider  elementClassProvider;\r
 186 \r
 187     /**\r
 188      * \r
 189      */\r
 190     protected Deque<ControlPoint>    controlPoints         = new ArrayDeque<ControlPoint>();\r
 191 \r
 192     /**\r
 193      * Contains <code>null</code> when a connection is started from a new flag\r
 194      * or one of the terminals in {@link #startTerminals} when a connection is\r
 195      * being created starting from a terminal or possibly a set of terminals.\r
 196      * \r
 197      * <p>\r
 198      * Note that this is different from {@link #startTerminal} which simply\r
 199      * represents the first element of {@link #startTerminals}.\r
 200      * \r
 201      * <p>\r
 202      * Only when this value and {@link #endTerminal} is properly set will a\r
 203      * connection be created between two element terminals.\r
 204      */\r
 205     protected TerminalInfo           selectedStartTerminal;\r
 206 \r
 207     /**\r
 208      * Element terminal of connection end element. <code>null</code> if\r
 209      * connection cannot be ended where it is currently being attempted to end.\r
 210      */\r
 211     protected TerminalInfo           endTerminal;\r
 212 \r
 213     /**\r
 214      * The latest connectability judgment from the active\r
 215      * {@link IConnectionAdvisor} should the connection happen between\r
 216      * {@link #selectedStartTerminal} and {@link #endTerminal}.\r
 217      */\r
 218     protected ConnectionJudgement    connectionJudgment;\r
 219 \r
 220     /**\r
 221      * If non-null during connection drawing this field tells the direction\r
 222      * forced for the current branch point by the user through the UI commands\r
 223      * {@link Commands#ROTATE_ELEMENT_CCW} and\r
 224      * {@link Commands#ROTATE_ELEMENT_CW}.\r
 225      */\r
 226     private Direction                forcedBranchPointDirection;\r
 227 \r
 228     /**\r
 229      * A temporary variable for use with\r
 230      * {@link TerminalTopology#getTerminals(IElement, Collection)}.\r
 231      */\r
 232     protected Collection<Terminal>   terminals             = new ArrayList<Terminal>();\r
 233 \r
 234     /**\r
 235      * Previous mouse canvas position recorded by\r
 236      * {@link #processMouseMove(MouseMovedEvent)}.\r
 237      */\r
 238     protected Point2D                lastMouseCanvasPos    = new Point2D.Double();\r
 239 \r
 240     /**\r
 241      * Set to true once {@link #processMouseMove(MouseMovedEvent)} has been\r
 242      * invoked at least once. This is used to tell whether to allow creation of\r
 243      * branch points or finising the connection in thin air. It will not be\r
 244      * allowed if the mouse has not moved at all since starting the connection.\r
 245      */\r
 246     protected boolean                mouseHasMoved         = false;\r
 247 \r
 248     protected TerminalHoverStrategy  originalStrategy      = null;\r
 249 \r
 250     protected TerminalHoverStrategy  terminalHoverStrategy = new TerminalHoverStrategy() {\r
 251         @Override\r
 252         public boolean highlightEnabled() {\r
 253             return !isEndingInFlag();\r
 254         }\r
 255 \r
 256         @Override\r
 257         public boolean highlight(TerminalInfo ti) {\r
 258             boolean reflexive = isStartTerminal(ti.e, ti.t);\r
 259             if (reflexive && !allowReflexiveConnections())\r
 260                 return false;\r
 261 \r
 262             return canConnect(ti.e, ti.t) != null;\r
 263         }\r
 264     };\r
 265 \r
 266     protected final static Composite ALPHA_COMPOSITE       = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.75f);\r
 267 \r
 268     /**\r
 269      * Root scene graph node for all visualization performed by this tool.\r
 270      */\r
 271     protected G2DParentNode          ghostNode;\r
 272 \r
 273     /**\r
 274      * Indicates whether the connection is about to be ended into a new\r
 275      * flag/branchpoint or not.\r
 276      */\r
 277     protected TerminalInfo           endFlag;\r
 278 \r
 279     protected G2DParentNode          endFlagNode;\r
 280 \r
 281     private RouteGraphTarget         lastRouteGraphTarget;\r
 282 \r
 283     /**\r
 284      * @param startTerminal\r
 285      * @param mouseId\r
 286      * @param startCanvasPos\r
 287      */\r
 288     public ConnectTool2(TerminalInfo startTerminal, int mouseId, Point2D startCanvasPos) {\r
 289         this(startTerminal == null ? Collections.<TerminalInfo> emptyList()\r
 290                 : Collections.singletonList(startTerminal),\r
 291                 mouseId,\r
 292                 startCanvasPos);\r
 293     }\r
 294 \r
 295     /**\r
 296      * @param startTerminals\r
 297      * @param mouseId\r
 298      * @param startCanvasPos\r
 299      */\r
 300     public ConnectTool2(List<TerminalInfo> startTerminals, int mouseId, Point2D startCanvasPos) {\r
 301         super(mouseId);\r
 302 \r
 303         if (startCanvasPos == null)\r
 304             throw new NullPointerException("null start position");\r
 305         if (startTerminals == null)\r
 306             throw new NullPointerException("null start terminals");\r
 307 \r
 308         this.startPos = startCanvasPos;\r
 309         this.lastMouseCanvasPos.setLocation(startPos);\r
 310 \r
 311         this.startTerminals = startTerminals;\r
 312         this.startTerminal = startTerminals.isEmpty() ? null : startTerminals.get(0);\r
 313     }\r
 314 \r
 315     @Override\r
 316     public void addedToContext(ICanvasContext ctx) {\r
 317         super.addedToContext(ctx);\r
 318 \r
 319         if (quality != null)\r
 320             quality.setStaticQuality(Quality.LOW);\r
 321 \r
 322         // Force terminals to always be highlighted without pressing certain\r
 323         // keys or key combinations.\r
 324         originalStrategy = getHint(TerminalPainter.TERMINAL_HOVER_STRATEGY);\r
 325         setHint(TerminalPainter.TERMINAL_HOVER_STRATEGY, terminalHoverStrategy);\r
 326     }\r
 327 \r
 328     @Override\r
 329     protected void onDiagramSet(IDiagram newDiagram, IDiagram oldDiagram) {\r
 330         if (newDiagram != null) {\r
 331             // Get IElementClassProvider\r
 332             ISynchronizationContext ctx = newDiagram.getHint(SynchronizationHints.CONTEXT);\r
 333             if (ctx != null) {\r
 334                 this.elementClassProvider = ctx.get(SynchronizationHints.ELEMENT_CLASS_PROVIDER);\r
 335             }\r
 336 \r
 337             // See if flags should be created or not.\r
 338             this.createFlags = Boolean.TRUE.equals(newDiagram.getHint(DiagramHints.KEY_USE_CONNECTION_FLAGS));\r
 339             startConnection();\r
 340         }\r
 341     }\r
 342 \r
 343     @Override\r
 344     public void removedFromContext(ICanvasContext ctx) {\r
 345         if (getHint(TerminalPainter.TERMINAL_HOVER_STRATEGY) == terminalHoverStrategy) {\r
 346             if (originalStrategy != null)\r
 347                 setHint(TerminalPainter.TERMINAL_HOVER_STRATEGY, originalStrategy);\r
 348             else\r
 349                 removeHint(TerminalPainter.TERMINAL_HOVER_STRATEGY);\r
 350         }\r
 351 \r
 352         if (quality != null)\r
 353             quality.setStaticQuality(null);\r
 354 \r
 355         super.removedFromContext(ctx);\r
 356     }\r
 357 \r
 358     protected void startConnection() {\r
 359         Point2D startPos = (Point2D) this.startPos.clone();\r
 360         ISnapAdvisor snapAdvisor = getHint(DiagramHints.SNAP_ADVISOR);\r
 361         if (snapAdvisor != null)\r
 362             snapAdvisor.snap(startPos);\r
 363 \r
 364         // Resolve the first element and terminal of the connection.\r
 365         ControlPoint start = new ControlPoint(startPos);\r
 366 \r
 367         if (startTerminal != null) {\r
 368             assert ElementUtils.peekDiagram(startTerminal.e) == diagram;\r
 369             Point2D terminalPos = new Point2D.Double(startTerminal.posDia.getTranslateX(),\r
 370                     startTerminal.posDia.getTranslateY());\r
 371             start.setPosition(terminalPos).setAttachedToTerminal(startTerminal);\r
 372         } else {\r
 373             // Create TerminalInfo describing the flag to be created.\r
 374             if (createFlags) {\r
 375                 // This prevents connection creation from creating a branch\r
 376                 // point in place of this flag.\r
 377                 startFlag = createFlag(EdgeEnd.Begin);\r
 378                 start.setAttachedToTerminal(startFlag);\r
 379                 showElement(ghostNode, "startFlag", startFlag.e, startPos);\r
 380             }\r
 381         }\r
 382         controlPoints.add(start);\r
 383         controlPoints.add(new ControlPoint(startPos));\r
 384 \r
 385         // Make sure that we are ending with a flag if ALT is pressed.\r
 386         // This makes the tool always start with a flag which can be quite\r
 387         // cumbersome and is therefore disabled. The current version will not\r
 388         // end the connection if the mouse has not moved at all.\r
 389         //if (keyUtil.isKeyPressed(java.awt.event.KeyEvent.VK_ALT)) {\r
 390         //    endWithoutTerminal(lastMouseCanvasPos, true);\r
 391         //}\r
 392     }\r
 393 \r
 394     @SGInit\r
 395     public void initSG(G2DParentNode parent) {\r
 396         ghostNode = parent.addNode(G2DParentNode.class);\r
 397         ghostNode.setZIndex(PAINT_PRIORITY);\r
 398 \r
 399         ShapeNode pathNode = ghostNode.getOrCreateNode("path", ShapeNode.class);\r
 400         pathNode.setColor(new Color(160, 0, 0));\r
 401         pathNode.setStroke(new BasicStroke(0.1f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10,\r
 402                 new float[] { 0.5f, 0.2f }, 0));\r
 403         pathNode.setScaleStroke(false);\r
 404         pathNode.setZIndex(0);\r
 405 \r
 406         G2DParentNode points = ghostNode.getOrCreateNode("points", G2DParentNode.class);\r
 407         points.setZIndex(1);\r
 408 \r
 409         updateSG();\r
 410     }\r
 411 \r
 412     static class Segment {\r
 413         public final ControlPoint begin;\r
 414         public final ControlPoint end;\r
 415         public Path2D             path;\r
 416 \r
 417         public Segment(ControlPoint begin, ControlPoint end) {\r
 418             this.begin = begin;\r
 419             this.end = end;\r
 420         }\r
 421 \r
 422         @Override\r
 423         public String toString() {\r
 424             return "Segment[begin=" + begin + ", end=" + end + ", path=" + path + "]";\r
 425         }\r
 426     }\r
 427 \r
 428     private RouteTerminal addControlPoint(RouteGraph routeGraph, ControlPoint cp) {\r
 429         TerminalInfo ti = cp.getAttachedTerminal();\r
 430         if(ti != null && ti != startFlag && ti != endFlag) {\r
 431             Rectangle2D bounds = ElementUtils.getElementBoundsOnDiagram(ti.e, new Rectangle2D.Double());\r
 432             GeometryUtils.expandRectangle(bounds, 2);\r
 433             int allowedDirections = RouteGraphConnectionClass.shortestDirectionOutOfBounds(\r
 434                     ti.posDia.getTranslateX(), ti.posDia.getTranslateY(), bounds);\r
 435             return routeGraph.addTerminal(ti.posDia.getTranslateX(), ti.posDia.getTranslateY(),\r
 436                     bounds, allowedDirections, PlainLineEndStyle.INSTANCE);\r
 437         }\r
 438         else {\r
 439             double x = cp.getPosition().getX();\r
 440             double y = cp.getPosition().getY();\r
 441             int allowedDirections = 0xf;\r
 442             switch(cp.getDirection()) {\r
 443             case Horizontal: allowedDirections = 5; break;\r
 444             case Vertical: allowedDirections = 10; break;\r
 445             case Any: allowedDirections = 15; break;\r
 446             }\r
 447             return routeGraph.addTerminal(x, y, x, y, x, y, allowedDirections);\r
 448         }\r
 449     }\r
 450     \r
 451     protected void updateSG() {\r
 452         if (controlPoints.size() != 2)\r
 453             return;\r
 454 \r
 455         ControlPoint begin = controlPoints.getFirst();\r
 456         ControlPoint end = controlPoints.getLast();\r
 457 \r
 458         RouteGraph routeGraph = new RouteGraph();\r
 459         RouteTerminal a = addControlPoint(routeGraph, begin);\r
 460         RouteTerminal b = addControlPoint(routeGraph, end);\r
 461         routeGraph.link(a, b);\r
 462 \r
 463         Path2D path = routeGraph.getPath2D();\r
 464 \r
 465         // Create scene graph to visualize the connection.\r
 466         ShapeNode pathNode = ghostNode.getOrCreateNode("path", ShapeNode.class);\r
 467         pathNode.setShape(path);\r
 468 \r
 469         setDirty();\r
 470     }\r
 471 \r
 472     private G2DParentNode showElement(G2DParentNode parent, String nodeId, IElement element, Point2D pos) {\r
 473         return showElement(parent, nodeId, element, AffineTransform.getTranslateInstance(pos.getX(), pos.getY()));\r
 474     }\r
 475 \r
 476     private G2DParentNode showElement(G2DParentNode parent, String nodeId, IElement element, AffineTransform tr) {\r
 477         G2DParentNode elementParent = parent.getOrCreateNode(nodeId, G2DParentNode.class);\r
 478         elementParent.setTransform(tr);\r
 479         elementParent.removeNodes();\r
 480         for (SceneGraph sg : element.getElementClass().getItemsByClass(SceneGraph.class))\r
 481             sg.init(element, elementParent);\r
 482         return elementParent;\r
 483     }\r
 484 \r
 485     private List<Segment> toSegments(Deque<ControlPoint> points) {\r
 486         if (points.isEmpty())\r
 487             return Collections.emptyList();\r
 488 \r
 489         List<Segment> segments = new ArrayList<Segment>();\r
 490 \r
 491         Iterator<ControlPoint> it = points.iterator();\r
 492         ControlPoint prev = it.next();\r
 493         while (it.hasNext()) {\r
 494             ControlPoint next = it.next();\r
 495             segments.add(new Segment(prev, next));\r
 496             prev = next;\r
 497         }\r
 498 \r
 499         return segments;\r
 500     }\r
 501 \r
 502     @SGCleanup\r
 503     public void cleanupSG() {\r
 504         ghostNode.remove();\r
 505         ghostNode = null;\r
 506     }\r
 507 \r
 508     @EventHandler(priority = 200)\r
 509     public boolean handleCommandEvents(CommandEvent ce) {\r
 510         if (ce.command.equals(Commands.CANCEL)) {\r
 511             setDirty();\r
 512             remove();\r
 513             return true;\r
 514         } else if (ce.command.equals(Commands.ROTATE_ELEMENT_CCW) || ce.command.equals(Commands.ROTATE_ELEMENT_CW)) {\r
 515             return rotateLastBranchPoint(ce.command.equals(Commands.ROTATE_ELEMENT_CW));\r
 516         }\r
 517         return false;\r
 518     }\r
 519 \r
 520     @EventHandler(priority = PointerInteractor.TOOL_PRIORITY + 20)\r
 521     public boolean handleKeyEvents(KeyEvent ke) {\r
 522         if (ke instanceof KeyPressedEvent) {\r
 523             // Back-space, cancel prev bend\r
 524             if (ke.keyCode == java.awt.event.KeyEvent.VK_BACK_SPACE)\r
 525                 return cancelPreviousBend();\r
 526         }\r
 527 \r
 528         if (ke.keyCode == java.awt.event.KeyEvent.VK_ALT) {\r
 529             if (createFlags) {\r
 530                 endWithoutTerminal(lastMouseCanvasPos, shouldEndWithFlag(ke instanceof KeyPressedEvent));\r
 531                 return true;\r
 532             }\r
 533         }\r
 534 \r
 535         return false;\r
 536     }\r
 537 \r
 538     @EventHandler(priority = PointerInteractor.TOOL_PRIORITY + 20)\r
 539     public boolean handleEvent(MouseEvent me) {\r
 540         // Only handle events for the connection-initiating mouse\r
 541         if (me.mouseId != mouseId)\r
 542             return false;\r
 543 \r
 544         if (me instanceof MouseMovedEvent)\r
 545             return processMouseMove((MouseMovedEvent) me);\r
 546 \r
 547         if (me instanceof MouseButtonPressedEvent)\r
 548             return processMouseButtonPress((MouseButtonPressedEvent) me);\r
 549 \r
 550         return false;\r
 551     }\r
 552 \r
 553     protected boolean processMouseMove(MouseMovedEvent me) {\r
 554         mouseHasMoved = true;\r
 555 \r
 556         Point2D mouseControlPos = me.controlPosition;\r
 557         Point2D mouseCanvasPos = util.controlToCanvas(mouseControlPos, new Point2D.Double());\r
 558 \r
 559         ISnapAdvisor snapAdvisor = getHint(DiagramHints.SNAP_ADVISOR);\r
 560         if (snapAdvisor != null)\r
 561             snapAdvisor.snap(mouseCanvasPos);\r
 562 \r
 563         // Record last snapped canvas position of mouse.\r
 564         this.lastMouseCanvasPos.setLocation(mouseCanvasPos);\r
 565 \r
 566         if (isEndingInFlag()) {\r
 567             endFlagNode.setTransform(AffineTransform.getTranslateInstance(mouseCanvasPos.getX(), mouseCanvasPos.getY()));\r
 568         }\r
 569 \r
 570         List<TerminalInfo> tis = pi.pickTerminals(me.controlPosition);\r
 571         tis = TerminalUtil.findNearestOverlappingTerminals(tis);\r
 572         if (!tis.isEmpty() && !containsStartTerminal(tis)) {\r
 573             //System.out.println("end terminals (" + tis.size() + "):\n" + EString.implode(tis));\r
 574             for (TerminalInfo ti : tis) {\r
 575                 Pair<ConnectionJudgement, TerminalInfo> canConnect = canConnect(ti.e, ti.t);\r
 576                 if (canConnect != null) {\r
 577                     connectionJudgment = canConnect.first;\r
 578 \r
 579                     if (!isEndingInFlag() || !TerminalUtil.isSameTerminal(ti, endTerminal)) {\r
 580                         if (canConnect.second != null) {\r
 581                             controlPoints.getFirst()\r
 582                             .setPosition(canConnect.second.posDia)\r
 583                             .setAttachedToTerminal(canConnect.second);\r
 584                         }\r
 585                         controlPoints.getLast()\r
 586                         .setPosition(ti.posDia)\r
 587                         .setAttachedToTerminal(ti);\r
 588 \r
 589                         selectedStartTerminal = canConnect.second;\r
 590                         endTerminal = ti;\r
 591                     }\r
 592 \r
 593                     // Make sure that we are ending with a flag if ALT is pressed\r
 594                     // and no end terminal is defined.\r
 595                     if (!endWithoutTerminal(lastMouseCanvasPos, shouldEndWithFlag(me)))\r
 596                         updateSG();\r
 597                     return false;\r
 598                 }\r
 599             }\r
 600         } else {\r
 601             RouteGraphTarget cp = RouteGraphConnectTool.pickRouteGraphConnection(\r
 602                     diagram,\r
 603                     pi.getCanvasPickShape(me.controlPosition),\r
 604                     pi.getPickDistance());\r
 605             if (cp != null) {\r
 606                 // Remove branch point highlight from previously picked route graph.\r
 607                 if (lastRouteGraphTarget != null && cp.getNode() != lastRouteGraphTarget.getNode())\r
 608                     cp.getNode().showBranchPoint(null);\r
 609                 lastRouteGraphTarget = cp;\r
 610 \r
 611                 // Validate connection before visualizing connectability\r
 612                 Point2D isectPos = cp.getIntersectionPosition();\r
 613                 TerminalInfo ti = TerminalInfo.create(\r
 614                         isectPos,\r
 615                         cp.getElement(),\r
 616                         BranchPointTerminal.existingTerminal(\r
 617                                 isectPos,\r
 618                                 DirectionSet.ANY,\r
 619                                 BranchPointNode.SHAPE),\r
 620                         BranchPointNode.SHAPE);\r
 621                 Pair<ConnectionJudgement, TerminalInfo> canConnect = canConnect(ti.e, ti.t);\r
 622                 if (canConnect != null) {\r
 623                     connectionJudgment = canConnect.first;\r
 624                     controlPoints.getLast().setPosition(ti.posDia).setAttachedToTerminal(ti);\r
 625                     endTerminal = ti;\r
 626                     cp.getNode().showBranchPoint(isectPos);\r
 627                     if (!endWithoutTerminal(lastMouseCanvasPos, shouldEndWithFlag(me)))\r
 628                         updateSG();\r
 629                     return false;\r
 630                 }\r
 631             } else {\r
 632                 if (lastRouteGraphTarget != null) {\r
 633                     lastRouteGraphTarget.getNode().showBranchPoint(null);\r
 634                     lastRouteGraphTarget = null;\r
 635                 }\r
 636             }\r
 637         }\r
 638 \r
 639         connectionJudgment = null;\r
 640         if (isEndTerminalDefined()) {\r
 641             // CASE: Mouse was previously on top of a valid terminal to end\r
 642             // the connection. Now the mouse has been moved where there is\r
 643             // no longer a terminal to connect to.\r
 644             //\r
 645             // => Disconnect the last edge segment from the previous\r
 646             // terminal, mark endElement/endTerminal non-existent\r
 647             // and connect the disconnected edge to a new branch point.\r
 648 \r
 649             controlPoints.getLast()\r
 650             .setPosition(mouseCanvasPos)\r
 651             .setDirection(calculateCurrentBranchPointDirection())\r
 652             .setAttachedToTerminal(null);\r
 653 \r
 654             endTerminal = null;\r
 655         } else {\r
 656             // CASE: Mouse was not previously on top of a valid ending\r
 657             // element terminal.\r
 658             //\r
 659             // => Move and re-orient last branch point.\r
 660 \r
 661             controlPoints.getLast()\r
 662             .setPosition(mouseCanvasPos)\r
 663             .setDirection(calculateCurrentBranchPointDirection());\r
 664         }\r
 665 \r
 666         // Make sure that we are ending with a flag if ALT is pressed and no end\r
 667         // terminal is defined.\r
 668         if (!endWithoutTerminal(lastMouseCanvasPos, shouldEndWithFlag(me)))\r
 669             updateSG();\r
 670 \r
 671         return false;\r
 672     }\r
 673 \r
 674     protected boolean processMouseButtonPress(MouseButtonPressedEvent e) {\r
 675         MouseButtonEvent me = e;\r
 676 \r
 677         // Do nothing before the mouse has moved at least a little.\r
 678         // This prevents the user from ending the connection right where\r
 679         // it started.\r
 680         if (!mouseHasMoved)\r
 681             return true;\r
 682 \r
 683         if (me.button == MouseEvent.LEFT_BUTTON) {\r
 684             Point2D mouseControlPos = me.controlPosition;\r
 685             Point2D mouseCanvasPos = util.getInverseTransform().transform(mouseControlPos, new Point2D.Double());\r
 686 \r
 687             ISnapAdvisor snapAdvisor = getHint(DiagramHints.SNAP_ADVISOR);\r
 688             if (snapAdvisor != null)\r
 689                 snapAdvisor.snap(mouseCanvasPos);\r
 690 \r
 691             if (lastRouteGraphTarget != null) {\r
 692                 lastRouteGraphTarget.getNode().showBranchPoint(null);\r
 693                 attachToConnection();\r
 694                 remove();\r
 695                 return true;\r
 696             } else if (isEndTerminalDefined()) {\r
 697                 // Clicked on an allowed end terminal. End connection & end mode.\r
 698                 createConnection();\r
 699                 remove();\r
 700                 return true;\r
 701             } else {\r
 702                 // Finish connection in thin air only if the\r
 703                 // connection was started from a valid terminal.\r
 704                 if (me.hasAnyModifier(MouseEvent.ALT_MASK | MouseEvent.ALT_GRAPH_MASK) && !startTerminals.isEmpty()) {\r
 705                     Pair<ConnectionJudgement, TerminalInfo> pair = canConnect(null, null);\r
 706                     if (pair != null) {\r
 707                         connectionJudgment = (ConnectionJudgement) pair.first;\r
 708                         selectedStartTerminal = pair.second;\r
 709 //                        endFlag = createFlag(EdgeEnd.End);\r
 710 //                        controlPoints.getLast().setAttachedToTerminal(endFlag);\r
 711                         createConnection();\r
 712                         setDirty();\r
 713                         remove();\r
 714                     } else {\r
 715                         // Inform the user why connection couldn't be created.\r
 716                         String tmsg = terminalsToString(startTerminals);\r
 717                         ErrorLogger.defaultLogWarning("Can't resolve connection type for new connection when starting from one of the following terminals:\n" + tmsg, null);\r
 718                     }\r
 719                     return true;\r
 720                 } else if (routePointsAllowed()\r
 721                         && (me.stateMask & (MouseEvent.ALT_MASK | MouseEvent.SHIFT_MASK | MouseEvent.CTRL_MASK)) == 0) {\r
 722                     // Add new connection control point.\r
 723                     controlPoints.add(newControlPointWithCalculatedDirection(mouseCanvasPos));\r
 724                     resetForcedBranchPointDirection();\r
 725                     updateSG();\r
 726                 }\r
 727             }\r
 728 \r
 729             // Eat the event to prevent other participants from doing\r
 730             // incompatible things while in this connection mode.\r
 731             return true;\r
 732         } else if (me.button == MouseEvent.RIGHT_BUTTON) {\r
 733             return cancelPreviousBend();\r
 734         }\r
 735 \r
 736         return false;\r
 737     }\r
 738 \r
 739     private void attachToConnection() {\r
 740         ConnectionJudgement judgment = this.connectionJudgment;\r
 741         if (judgment == null) {\r
 742             ErrorLogger.defaultLogError("Cannot attach to connection, no judgment available on connection validity", null);\r
 743             return;\r
 744         }\r
 745 \r
 746         ConnectionBuilder builder = new ConnectionBuilder(this.diagram);\r
 747         RouteGraph before = lastRouteGraphTarget.getNode().getRouteGraph();\r
 748         THashMap<Object, Object> copyMap = new THashMap<>();\r
 749         RouteGraph after = before.copy(copyMap);\r
 750 \r
 751         RouteLine attachTo = (RouteLine) copyMap.get(lastRouteGraphTarget.getLine());\r
 752         after.makePersistent(attachTo);\r
 753         for (RouteLine line : after.getAllLines()) {\r
 754             if (!line.isTransient() && line.isHorizontal() == attachTo.isHorizontal()\r
 755                     && line.getPosition() == attachTo.getPosition()) {\r
 756                 attachTo = line;\r
 757                 break;\r
 758             }\r
 759         }\r
 760         RouteLine attachToLine = attachTo;\r
 761         RouteGraphDelta delta = new RouteGraphDelta(before, after);\r
 762 \r
 763         Simantics.getSession().asyncRequest(new WriteRequest() {\r
 764             @Override\r
 765             public void perform(WriteGraph graph) throws DatabaseException {\r
 766                 graph.markUndoPoint();\r
 767                 Resource connection = ElementUtils.getObject(endTerminal.e);\r
 768                 if (!delta.isEmpty()) {\r
 769                     new RouteGraphConnection(graph, connection).synchronize(graph, before, after, delta);\r
 770                 }\r
 771                 Resource line = RouteGraphConnection.deserialize(graph, attachToLine.getData());\r
 772                 Deque<ControlPoint> cps = new ArrayDeque<>();\r
 773                 for (Iterator<ControlPoint> iterator = controlPoints.descendingIterator(); iterator.hasNext();)\r
 774                     cps.add(iterator.next());\r
 775                 builder.attachToRouteGraph(graph, judgment, connection, line, cps, startTerminal, FlagClass.Type.In);\r
 776             }\r
 777         }, new Callback<DatabaseException>() {\r
 778             @Override\r
 779             public void run(DatabaseException parameter) {\r
 780                 if (parameter != null)\r
 781                     ExceptionUtils.logAndShowError(parameter);\r
 782             }\r
 783         });\r
 784     }\r
 785 \r
 786     protected boolean cancelPreviousBend() {\r
 787         if (!routePointsAllowed())\r
 788             return false;\r
 789 \r
 790         // Just to make this code more comprehensible, prevent an editing\r
 791         // case that requires ugly code to work.\r
 792         if (isEndingInFlag())\r
 793             return true;\r
 794 \r
 795         // If there are no real route points, cancel whole connection.\r
 796         if (controlPoints.size() <= 2) {\r
 797             setDirty();\r
 798             remove();\r
 799             return true;\r
 800         }\r
 801 \r
 802         // Cancel last bend\r
 803         controlPoints.removeLast();\r
 804         controlPoints.getLast().setPosition(lastMouseCanvasPos);\r
 805         resetForcedBranchPointDirection();\r
 806 \r
 807         updateSG();\r
 808         return true;\r
 809     }\r
 810 \r
 811     /**\r
 812      * Rotates the last branch point in the created connection in either\r
 813      * clockwise or counter-clockwise direction as a response to a user\r
 814      * interaction.\r
 815      * \r
 816      * <p>\r
 817      * At the same time it use {@link #forcedBranchPointDirection} to mark the\r
 818      * current last branch point to be forcefully oriented according to the\r
 819      * users wishes instead of calculating a default value for the orientation\r
 820      * from the routed connection path. See\r
 821      * {@link #calculateCurrentBranchPointDirection()} for more information on\r
 822      * this.\r
 823      * \r
 824      * <p>\r
 825      * The logic of this method goes as follows:\r
 826      * <ul>\r
 827      * <li>Calculate the current branch point direction</li>\r
 828      * <li>If the branch point direction is currently user selected (\r
 829      * {@link #forcedBranchPointDirection}</li>\r
 830      * <li></li>\r
 831      * <li></li>\r
 832      * </ul>\r
 833      * \r
 834      * @param clockwise\r
 835      * @return <code>true</code> if the rotation was successful\r
 836      */\r
 837     protected boolean rotateLastBranchPoint(boolean clockwise) {\r
 838         Direction oldDir = calculateCurrentBranchPointDirection();\r
 839 \r
 840         if (forcedBranchPointDirection == null) {\r
 841             forcedBranchPointDirection = oldDir.toggleDetermined();\r
 842         } else {\r
 843             forcedBranchPointDirection = clockwise ? oldDir.cycleNext() : oldDir.cyclePrevious();\r
 844         }\r
 845 \r
 846         controlPoints.getLast().setDirection(forcedBranchPointDirection);\r
 847 \r
 848         updateSG();\r
 849 \r
 850         return true;\r
 851     }\r
 852 \r
 853     /**\r
 854      * Set preferred direction for a branch/route point element.\r
 855      * \r
 856      * @param branchPoint the element to set the direction for\r
 857      * @param direction the direction to set\r
 858      * @return\r
 859      */\r
 860     protected void setDirection(IElement branchPoint, Direction direction) {\r
 861         branchPoint.getElementClass().getSingleItem(BranchPoint.class).setDirectionPreference(branchPoint, direction);\r
 862     }\r
 863 \r
 864     protected Direction forcedBranchPointDirection() {\r
 865         return forcedBranchPointDirection;\r
 866     }\r
 867 \r
 868     protected void resetForcedBranchPointDirection() {\r
 869         forcedBranchPointDirection = null;\r
 870     }\r
 871 \r
 872     protected void forceBranchPointDirection(Direction direction) {\r
 873         forcedBranchPointDirection = direction;\r
 874     }\r
 875 \r
 876     /**\r
 877      * @return\r
 878      */\r
 879     protected Direction calculateCurrentBranchPointDirection() {\r
 880         // If this is not the first branch point, toggle direction compared to\r
 881         // last.\r
 882         if (forcedBranchPointDirection != null)\r
 883             return forcedBranchPointDirection;\r
 884 \r
 885         if (controlPoints.size() > 2) {\r
 886             // This is not the first edge segment, toggle route point\r
 887             // directions.\r
 888             Iterator<ControlPoint> it = controlPoints.descendingIterator();\r
 889             it.next();\r
 890             ControlPoint secondLastCp = it.next();\r
 891 \r
 892             Direction dir = secondLastCp.getDirection();\r
 893             switch (dir) {\r
 894                 case Horizontal:\r
 895                     return Direction.Vertical;\r
 896                 case Vertical:\r
 897                     return Direction.Horizontal;\r
 898                 case Any:\r
 899             }\r
 900         }\r
 901 \r
 902         // If this is the first branch point, calculate based on edge segment\r
 903         // angle.\r
 904         if (controlPoints.size() > 1) {\r
 905             Iterator<ControlPoint> it = controlPoints.descendingIterator();\r
 906             ControlPoint last = it.next();\r
 907             ControlPoint secondLast = it.next();\r
 908 \r
 909             double angle = Math.atan2(Math.abs(last.getPosition().getY() - secondLast.getPosition().getY()),\r
 910                     Math.abs(last.getPosition().getX() - secondLast.getPosition().getX()));\r
 911 \r
 912             if (angle >= 0 && angle < Math.PI / 4) {\r
 913                 return Direction.Horizontal;\r
 914             } else if (angle > Math.PI / 4 && angle <= Math.PI / 2) {\r
 915                 return Direction.Vertical;\r
 916             }\r
 917         }\r
 918 \r
 919         return Direction.Any;\r
 920     }\r
 921 \r
 922     protected boolean isEndingInFlag() {\r
 923         return endFlag != null;\r
 924     }\r
 925 \r
 926     /**\r
 927      * @param mousePos\r
 928      * @param altDown\r
 929      * @return <code>true</code> if updateSG was executed, <code>false</code>\r
 930      *         otherwise\r
 931      */\r
 932     protected boolean endWithoutTerminal(Point2D mousePos, boolean altDown) {\r
 933         // Just go with branch points if flags are not allowed.\r
 934         if (!createFlags)\r
 935             return false;\r
 936 \r
 937         boolean endTerminalDefined = isEndTerminalDefined();\r
 938 \r
 939         if (altDown) {\r
 940             if (!isEndingInFlag()) {\r
 941                 endFlag = createFlag(EdgeEnd.End);\r
 942                 endFlagNode = showElement(ghostNode, "endFlag", endFlag.e, mousePos);\r
 943                 controlPoints.getLast()\r
 944                 .setDirection(calculateCurrentBranchPointDirection())\r
 945                 .setAttachedToTerminal(endFlag);\r
 946 \r
 947                 // TerminalPainter must refresh\r
 948                 setHint(TerminalPainter.TERMINAL_HOVER_STRATEGY, terminalHoverStrategy);\r
 949 \r
 950                 updateSG();\r
 951                 return true;\r
 952             }\r
 953         } else {\r
 954             if (isEndingInFlag()) {\r
 955                 // Currently ending with flag but ALT is no longer down\r
 956                 // so that flag must be removed.\r
 957                 endFlag = null;\r
 958                 endFlagNode.remove();\r
 959                 endFlagNode = null;\r
 960 \r
 961                 ControlPoint cp = controlPoints.getLast();\r
 962                 cp.setDirection(calculateCurrentBranchPointDirection())\r
 963                 .setAttachedToTerminal(endTerminal);\r
 964 \r
 965                 if (endTerminalDefined) {\r
 966                     cp.setPosition(endTerminal.posDia);\r
 967                 } else {\r
 968                     cp.setPosition(mousePos);\r
 969                 }\r
 970 \r
 971                 // Force TerminalPainter refresh\r
 972                 setHint(TerminalPainter.TERMINAL_HOVER_STRATEGY, terminalHoverStrategy);\r
 973 \r
 974                 updateSG();\r
 975                 return true;\r
 976             }\r
 977         }\r
 978         return false;\r
 979     }\r
 980 \r
 981     protected void createConnection() {\r
 982         createConnection(\r
 983                 this.selectedStartTerminal,\r
 984                 this.endTerminal,\r
 985                 this.connectionJudgment,\r
 986                 this.controlPoints);\r
 987     }\r
 988 \r
 989     protected void createConnection(\r
 990             final TerminalInfo startTerminal,\r
 991             final TerminalInfo endTerminal,\r
 992             final ConnectionJudgement judgement,\r
 993             final Deque<ControlPoint> controlPoints)\r
 994     {\r
 995         TimeLogger.resetTimeAndLog(getClass(), "createConnection");\r
 996         if (judgement == null) {\r
 997             // Inform the user why connection couldn't be created.\r
 998             String tmsg = terminalsToString(Arrays.asList(startTerminal, endTerminal));\r
 999             ErrorLogger.defaultLogError("Cannot create connection, no judgment available on connection validity when connecting the terminals:\n" + tmsg, null);\r
1000             return;\r
1001         }\r
1002 \r
1003         final ConnectionBuilder builder = new ConnectionBuilder(this.diagram);\r
1004 \r
1005         Simantics.getSession().asyncRequest(new WriteRequest() {\r
1006             @Override\r
1007             public void perform(WriteGraph graph) throws DatabaseException {\r
1008                 builder.create(graph, judgement, controlPoints, startTerminal, endTerminal);\r
1009             }\r
1010         }, new Callback<DatabaseException>() {\r
1011             @Override\r
1012             public void run(DatabaseException parameter) {\r
1013                 if (parameter != null)\r
1014                     ExceptionUtils.logAndShowError(parameter);\r
1015             }\r
1016         });\r
1017     }\r
1018 \r
1019     /**\r
1020      * @param canvasPos\r
1021      * @return\r
1022      */\r
1023     protected ControlPoint newControlPointWithCalculatedDirection(Point2D canvasPos) {\r
1024         return new ControlPoint(canvasPos, calculateCurrentBranchPointDirection());\r
1025     }\r
1026 \r
1027     /**\r
1028      * @param e\r
1029      * @param t\r
1030      * @return <code>true</code> if the specified element terminal matches any\r
1031      *         TerminalInfo in {@link #startTerminals}\r
1032      */\r
1033     protected boolean isStartTerminal(IElement e, Terminal t) {\r
1034         if (startTerminal == null)\r
1035             return false;\r
1036         for (TerminalInfo st : startTerminals) {\r
1037             if (st.e == e && st.t == t) {\r
1038                 return true;\r
1039             }\r
1040         }\r
1041         return false;\r
1042     }\r
1043 \r
1044     /**\r
1045      * @param e\r
1046      * @param t\r
1047      * @return <code>true</code> if the specified element terminal matches any\r
1048      *         TerminalInfo in {@link #startTerminals}\r
1049      */\r
1050     protected boolean containsStartTerminal(List<TerminalInfo> tis) {\r
1051         if (startTerminal == null)\r
1052             return false;\r
1053         for (TerminalInfo st : startTerminals) {\r
1054             for (TerminalInfo et : tis) {\r
1055                 if (st.e == et.e && st.t == et.t) {\r
1056                     return true;\r
1057                 }\r
1058             }\r
1059         }\r
1060         return false;\r
1061     }\r
1062 \r
1063     protected static FlagClass.Type endToFlagType(EdgeEnd end) {\r
1064         switch (end) {\r
1065             case Begin:\r
1066                 return FlagClass.Type.In;\r
1067             case End:\r
1068                 return FlagClass.Type.Out;\r
1069             default:\r
1070                 throw new IllegalArgumentException("unrecognized edge end: " + end);\r
1071         }\r
1072     }\r
1073 \r
1074     protected TerminalInfo createFlag(EdgeEnd connectionEnd) {\r
1075         ElementClass flagClass = elementClassProvider.get(ElementClasses.FLAG);\r
1076         IElement e = Element.spawnNew(flagClass);\r
1077 \r
1078         e.setHint(FlagClass.KEY_FLAG_TYPE, endToFlagType(connectionEnd));\r
1079         e.setHint(FlagClass.KEY_FLAG_MODE, FlagClass.Mode.Internal);\r
1080 \r
1081         TerminalInfo ti = new TerminalInfo();\r
1082         ti.e = e;\r
1083         ti.t = ElementUtils.getSingleTerminal(e);\r
1084         ti.posElem = TerminalUtil.getTerminalPosOnElement(e, ti.t);\r
1085         ti.posDia = TerminalUtil.getTerminalPosOnDiagram(e, ti.t);\r
1086 \r
1087         return ti;\r
1088     }\r
1089 \r
1090     protected boolean shouldEndWithFlag(MouseEvent me) {\r
1091         return shouldEndWithFlag( me.hasAnyModifier(MouseEvent.ALT_MASK | MouseEvent.ALT_GRAPH_MASK) );\r
1092     }\r
1093 \r
1094     protected boolean shouldEndWithFlag(boolean altPressed) {\r
1095         return altPressed && !isEndTerminalDefined() && createFlags && startFlag == null;\r
1096     }\r
1097 \r
1098     protected boolean isEndTerminalDefined() {\r
1099         return endTerminal != null;\r
1100     }\r
1101 \r
1102     protected boolean isFlagTerminal(TerminalInfo ti) {\r
1103         return ti.e.getElementClass().containsClass(FlagHandler.class);\r
1104     }\r
1105 \r
1106     protected boolean allowReflexiveConnections() {\r
1107         return false;\r
1108     }\r
1109 \r
1110     protected boolean routePointsAllowed() {\r
1111         return Boolean.TRUE.equals(diagram.getHint(DiagramHints.KEY_ALLOW_ROUTE_POINTS));\r
1112     }\r
1113 \r
1114     /**\r
1115      * @param endElement\r
1116      * @param endTerminal\r
1117      * @return\r
1118      */\r
1119     @SuppressWarnings("unchecked")\r
1120     protected final Pair<ConnectionJudgement, TerminalInfo> canConnect(IElement endElement, Terminal endTerminal) {\r
1121         IConnectionAdvisor advisor = diagram.getHint(DiagramHints.CONNECTION_ADVISOR);\r
1122         Object judgement = canConnect(advisor, endElement, endTerminal);\r
1123         if (judgement == null)\r
1124             return null;\r
1125         if (judgement instanceof Pair<?, ?>)\r
1126             return (Pair<ConnectionJudgement, TerminalInfo>) judgement;\r
1127         return Pair.<ConnectionJudgement, TerminalInfo>make((ConnectionJudgement) judgement, startTerminal);\r
1128     }\r
1129 \r
1130     protected Object canConnect(IConnectionAdvisor advisor, IElement endElement, Terminal endTerminal) {\r
1131         if (advisor == null)\r
1132             return Pair.make(ConnectionJudgement.CANBEMADELEGAL, startTerminal);\r
1133         if (startTerminals.isEmpty()) {\r
1134             ConnectionJudgement obj = (ConnectionJudgement) advisor.canBeConnected(null, null, null, endElement, endTerminal);\r
1135             return obj != null ? Pair.<ConnectionJudgement, TerminalInfo>make(obj, null) : null;\r
1136         }\r
1137         for (TerminalInfo st : startTerminals) {\r
1138             ConnectionJudgement obj = (ConnectionJudgement) advisor.canBeConnected(null, st.e, st.t, endElement, endTerminal);\r
1139             if (obj != null) {\r
1140                 return Pair.make(obj, st);\r
1141             }\r
1142         }\r
1143         return null;\r
1144     }\r
1145 \r
1146     /**\r
1147      * For generating debugging information of what was attempted by the user\r
1148      * when a connection couldn't be created.\r
1149      * \r
1150      * @param ts\r
1151      * @return\r
1152      */\r
1153     private String terminalsToString(final Iterable<TerminalInfo> ts) {\r
1154         try {\r
1155             return Simantics.sync(new UniqueRead<String>() {\r
1156                 @Override\r
1157                 public String perform(ReadGraph graph) throws DatabaseException {\r
1158                     DiagramResource DIA = DiagramResource.getInstance(graph);\r
1159                     ModelingResources MOD = ModelingResources.getInstance(graph);\r
1160                     StringBuilder sb = new StringBuilder();\r
1161                     boolean first = true;\r
1162                     for (TerminalInfo ti : ts) {\r
1163                         if (!first)\r
1164                             sb.append("\n");\r
1165                         first = false;\r
1166                         sb.append("element ");\r
1167                         Object o = ElementUtils.getObject(ti.e);\r
1168                         if (o instanceof Resource) {\r
1169                             Resource er = (Resource) o;\r
1170                             Resource cer = graph.getPossibleObject(er, MOD.ElementToComponent);\r
1171                             Resource r = cer != null ? cer : er;\r
1172                             sb.append(NameUtils.getSafeName(graph, r)).append(" : ");\r
1173                             for (Resource type : graph.getPrincipalTypes(r)) {\r
1174                                 sb.append(NameUtils.getSafeName(graph, type, true));\r
1175                             }\r
1176                         } else {\r
1177                             sb.append(ti.e.toString());\r
1178                         }\r
1179                         sb.append(", terminal ");\r
1180                         if (ti.t instanceof ResourceTerminal) {\r
1181                             Resource tr = ((ResourceTerminal) ti.t).getResource();\r
1182                             Resource cp = graph.getPossibleObject(tr, DIA.HasConnectionPoint);\r
1183                             Resource r = cp != null ? cp : tr;\r
1184                             sb.append(NameUtils.getSafeName(graph, r, true));\r
1185                         } else {\r
1186                             sb.append(ti.t.toString());\r
1187                         }\r
1188                     }\r
1189                     return sb.toString();\r
1190                 }\r
1191             });\r
1192         } catch (DatabaseException e) {\r
1193             return e.getMessage();\r
1194         }\r
1195     }\r
1196 \r
1197 }