private Point getPointForEnd(PointList points) { Point point = null; if (end == End_c.Middle) { point = points.getMidpoint(); } else if (end == End_c.Start) { point = points.getFirstPoint(); } else if (end == End_c.End) { point = points.getLastPoint(); } return point; }
@Override public boolean test() throws Exception { boolean location = false; PointList points = ((PolylineConnectionEx) connectionEditPart.getFigure()).getPoints(); if (checkFirstBendpoint) { location = !initialLocation.equals(points.getFirstPoint()); } else if (checkLastBendpoint) { location = !initialLocation.equals(points.getLastPoint()); } else if (bendpointPosition >= 0 || bendpointPosition < points.size()) { location = !initialLocation.equals(points.getPoint(bendpointPosition)); } return location; }
private Point getAbsoluteEdgeExtremity( ConnectionNodeEditPart editPart, boolean isStart, Float[] preferPosition) { if (editPart == null) { return null; } PointList points = editPart.getConnectionFigure().getPoints().getCopy(); if (points.size() == 2 && new Point(0, 0).equals(points.getFirstPoint()) && new Point(100, 100).equals(points.getLastPoint())) { // not display yet. if (preferPosition != null) { if (isStart && preferPosition[0] != null) { return new Point(0, preferPosition[0].intValue()); } else if (!isStart && preferPosition[1] != null) { return new Point(0, preferPosition[1].intValue()); } } return SequenceUtil.getAbsoluteEdgeExtremity(editPart, isStart, false); } return SequenceUtil.getAbsoluteEdgeExtremity(editPart, isStart, true); }
@Override public void execute() { // configure the request EditPart source = request.getSourceEditPart(); EditPart target = request.getTargetEditPart(); PointList list = feedback.getPoints(); DiagramEditPart diagramEditPart = null; if (source.getParent() instanceof DiagramEditPart) { diagramEditPart = (DiagramEditPart) source.getParent(); } else if (source instanceof DiagramEditPart) { diagramEditPart = (DiagramEditPart) source; } else { if (source.getParent().getParent() instanceof DiagramEditPart) { diagramEditPart = (DiagramEditPart) source.getParent().getParent(); } } if (diagramEditPart == null) { return; } if (!(source instanceof DiagramEditPart || target instanceof DiagramEditPart)) { // one must be whitespace, we make it the target request.setTargetEditPart(diagramEditPart); // additionally we must cut the drawn connection // in half to share room with the element that will // be auto-created PointList newList = new PointList(); newList.addPoint(list.getFirstPoint()); if (list.size() == 4) { // rectilinear routing will have a three points newList.addPoint(list.getPoint(1)); } newList.addPoint(list.getMidpoint()); feedback.setPoints(newList); } // create the active tool's element first CreateConnectionCommand command = new CreateConnectionCommand(request, feedback); command.execute(); Connector_c newConnector = command.result; if (newConnector == null) { return; } // we need to now refresh the diagram to get the new edit part source.refresh(); source.getParent().refresh(); GraphicalEditPart newPart = (GraphicalEditPart) source.getViewer().getEditPartRegistry().get(newConnector); // transfer the feedback connection points to the newly created // edit part ((Connection) newPart.getFigure()).setPoints(feedback.getPoints().getCopy()); // now adjust the request for the new element to be created for each // terminal specification that requires auto-creation createElementForTerminalSpec( autoStartSpec, ((NonRootModelElement) diagramEditPart.getModel()).getModelRoot(), list, newPart, target, diagramEditPart); createElementForTerminalSpec( autoEndSpec, ((NonRootModelElement) diagramEditPart.getModel()).getModelRoot(), list, newPart, target, diagramEditPart); }
/** * Computes clipping rectangle(s) for a given connection. Will consider all enclosing viewports, * excluding the root viewport. */ protected Rectangle[] getEdgeClippingRectangle(Connection connection) { // start with clipping the connection at its original bounds Rectangle clipRect = getAbsoluteBoundsAsCopy(connection); // in case we cannot infer source and target of the connection (e.g. // if XYAnchors are used), returning the bounds is all we can do ConnectionAnchor sourceAnchor = connection.getSourceAnchor(); ConnectionAnchor targetAnchor = connection.getTargetAnchor(); if (sourceAnchor == null || sourceAnchor.getOwner() == null || targetAnchor == null || targetAnchor.getOwner() == null) { return new Rectangle[] {clipRect}; } // source and target figure are known, see if there is common // viewport // the connection has to be clipped at. IFigure sourceFigure = sourceAnchor.getOwner(); IFigure targetFigure = targetAnchor.getOwner(); Viewport nearestEnclosingCommonViewport = ViewportUtilities.getNearestCommonViewport(sourceFigure, targetFigure); if (nearestEnclosingCommonViewport == null) { return new Rectangle[] {clipRect}; } // if the nearest common viewport is not the root viewport, we may // start with clipping the connection at this viewport. if (nearestEnclosingCommonViewport != getRootViewport()) { clipRect.intersect(getNodeClippingRectangle(nearestEnclosingCommonViewport)); } // if the nearest common viewport of source and target is not // simultaneously // the nearest enclosing viewport of source and target respectively, the // connection has to be further clipped (the connection may even not be // visible at all) Viewport nearestEnclosingSourceViewport = ViewportUtilities.getNearestEnclosingViewport(sourceFigure); Viewport nearestEnclosingTargetViewport = ViewportUtilities.getNearestEnclosingViewport(targetFigure); if (nearestEnclosingSourceViewport != nearestEnclosingTargetViewport) { // compute if source and target anchor are visible // within the nearest common enclosing viewport (which may // itself be nested in other viewports). Rectangle sourceClipRect = getAbsoluteBoundsAsCopy(connection); if (nearestEnclosingSourceViewport != nearestEnclosingCommonViewport) { clipAtViewports( sourceClipRect, ViewportUtilities.getViewportsPath( nearestEnclosingSourceViewport, nearestEnclosingCommonViewport, false)); } Rectangle targetClipRect = getAbsoluteBoundsAsCopy(connection); if (nearestEnclosingTargetViewport != nearestEnclosingCommonViewport) { clipAtViewports( targetClipRect, ViewportUtilities.getViewportsPath( nearestEnclosingTargetViewport, nearestEnclosingCommonViewport, false)); } PointList absolutePointsAsCopy = getAbsolutePointsAsCopy(connection); boolean sourceAnchorVisible = sourceClipRect.getExpanded(PRIVATE_INSETS).contains(absolutePointsAsCopy.getFirstPoint()); boolean targetAnchorVisible = targetClipRect.getExpanded(PRIVATE_INSETS).contains(absolutePointsAsCopy.getLastPoint()); if (!sourceAnchorVisible || !targetAnchorVisible) { // one (or both) of source or target anchor is invisible // within the nearest common viewport, so up to now // we regard the edge as invisible. return new Rectangle[] {}; // TODO: We could come up with a more decent strategy here, // which also computes clipping fragments in those cases // where source/target are not visible but the edge // intersects with the enclosing source/target viewport's // parents bounds. } else { // both ends are visible, so just return what we have // computed before // (clipping at nearest enclosing viewport) return new Rectangle[] {clipRect}; } } else { // source and target share the same enclosing viewport, so just // return what we have computed before (clipping at nearest // enclosing viewport) return new Rectangle[] {clipRect}; } }