@Override
  protected List<?> createSelectionHandles() {
    List<BendpointHandle> list = new ArrayList<BendpointHandle>();
    ConnectionEditPart connEP = (ConnectionEditPart) getHost();
    PointList points = getConnection().getPoints();
    List<?> bendPoints = (List<?>) getConnection().getRoutingConstraint();
    int bendPointIndex = 0;
    Point currBendPoint = null;

    if (bendPoints == null) bendPoints = NULL_CONSTRAINT;
    else if (!bendPoints.isEmpty()) currBendPoint = ((Bendpoint) bendPoints.get(0)).getLocation();

    for (int i = 0; i < points.size() - 1; i++) {
      // Put a create handle on the middle of every segment
      list.add(new SnappingBendpointCreationHandle(connEP, bendPointIndex, i));

      // If the current user bendpoint matches a bend location, show a
      // move handle
      if (i < points.size() - 1
          && bendPointIndex < bendPoints.size()
          && currentBendPointMatches(currBendPoint, points.getPoint(i + 1))) {
        list.add(new SnappingBendpointMoveHandle(connEP, bendPointIndex, i + 1));

        // Go to the next user bendpoint
        bendPointIndex++;
        if (bendPointIndex < bendPoints.size())
          currBendPoint = ((Bendpoint) bendPoints.get(bendPointIndex)).getLocation();
      }
    }
    return list;
  }
Пример #2
0
  /**
   * straightenPoints This is a simpler version of the.
   *
   * @see updateIfNotRectilinear that simply ensures that the lines are horizontal or vertical
   *     without any intelligence in terms of shortest distance around a rectangle.
   * @param newLine PointList to check for rectilinear qualities and change if necessary.
   * @param tolerance int tolerance value by which points will be straightened in HiMetrics
   */
  protected static void straightenPoints(final PointList newLine, final int tolerance) {
    for (int i = 0; i < newLine.size() - 1; i++) {
      final Point ptCurrent = newLine.getPoint(i);
      final Point ptNext = newLine.getPoint(i + 1);

      final int xDelta = Math.abs(ptNext.x - ptCurrent.x);
      final int yDelta = Math.abs(ptNext.y - ptCurrent.y);

      if (xDelta < yDelta) {
        if (xDelta > tolerance) {
          return;
        }
        if (i == newLine.size() - 2) {
          // The last point is more important than the other (not
          // change the end of the line)
          ptCurrent.x = ptNext.x;
        } else {
          ptNext.x = ptCurrent.x;
        }
      } else {
        if (yDelta > tolerance) {
          return;
        }
        if (i == newLine.size() - 2) {
          // The last point is more important than the other (not
          // change the end of the line)
          ptCurrent.y = ptNext.y;
        } else {
          ptNext.y = ptCurrent.y;
        }
      }

      newLine.setPoint(ptNext, i + 1);
    }
  }
 protected List<BezierPoint> getBezierPoints(PointList points, double zoom) {
   List<BezierPoint> ret = new ArrayList<BezierPoint>(points.size());
   for (int i = 0; i < points.size(); i++) {
     int bezierDistance = (int) (getGeneralBezierDistance() * zoom);
     Point point = points.getPoint(i);
     ret.add(new BezierPoint(point.x, point.y, bezierDistance, bezierDistance));
   }
   return ret;
 }
Пример #4
0
  private boolean trunkVertexEqual(final Connection connMaster, final Connection connSlave) {
    final PointList cmPts = connMaster.getPoints();
    final PointList csPts = connSlave.getPoints();
    if (cmPts.size() > 2 && csPts.size() > 2) {
      return cmPts.getPoint(2).equals(csPts.getPoint(2));
    }

    return false;
  }
 @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;
 }
  @Override
  public void route(Connection conn) {
    if (isDirty) {
      ignoreInvalidate = true;
      processStaleConnections();
      isDirty = false;
      List<?> updated = algorithm.solve();
      Connection current;
      for (int i = 0; i < updated.size(); i++) {
        Path path = (Path) updated.get(i);
        current = (Connection) path.data;
        current.revalidate();

        PointList points = path.getPoints().getCopy();
        Point ref1;
        Point ref2;
        Point start;
        Point end;
        ref1 = new PrecisionPoint(points.getPoint(1));
        ref2 = new PrecisionPoint(points.getPoint(points.size() - 2));
        current.translateToAbsolute(ref1);
        current.translateToAbsolute(ref2);

        start = current.getSourceAnchor().getLocation(ref1).getCopy();
        end = current.getTargetAnchor().getLocation(ref2).getCopy();

        current.translateToRelative(start);
        current.translateToRelative(end);
        points.setPoint(start, 0);
        points.setPoint(end, points.size() - 1);

        current.setPoints(points);
      }
      ignoreInvalidate = false;
    }
  }
Пример #7
0
  /**
   * UpdateConstraint Updates the constraint value for the connection based on the tree vertex.
   *
   * @param conn Connection whose constraint is to be updated.
   */
  protected void updateConstraint(final Connection conn) {
    boolean update =
        conn != null && conn.getSourceAnchor() != null && conn.getTargetAnchor() != null;
    update =
        update
            && conn.getSourceAnchor().getOwner() != null
            && conn.getTargetAnchor().getOwner() != null;
    if (update) {
      if (isUpdatingPeers()) {
        return;
      }

      List bendpoints = (List) conn.getRoutingConstraint();
      if (bendpoints == null) {
        bendpoints = new ArrayList(conn.getPoints().size());
      }

      final Point sourceRefPoint = conn.getSourceAnchor().getReferencePoint();
      conn.translateToRelative(sourceRefPoint);

      final Point targetRefPoint = conn.getTargetAnchor().getReferencePoint();
      conn.translateToRelative(targetRefPoint);

      final Point ptTrunk = getTrunkLocation(conn);
      final Point ptSource = getBranchRouter().getSourceLocation(conn, ptTrunk);

      bendpoints.clear();
      final PointList pts = getBranchRouter().recreateBranch(conn, ptSource, ptTrunk);
      for (int i = 0; i < pts.size(); i++) {
        final Bendpoint bp = new AbsoluteBendpoint(pts.getPoint(i));
        bendpoints.add(bp);
      }

      setUpdatingPeers(true);

      try {
        setConstraint(conn, bendpoints);
        conn.invalidate();
        conn.validate();
      } finally {
        setUpdatingPeers(false);
      }
    }
  }
 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);
 }
Пример #9
0
  /**
   * Utility method to determine if the given set of points conforms to the constraints of being a
   * connection tree-branch. 1. Points size must be 4. 2. Source point resides with-in boundary of
   * source shape based on orientation 3. Target point resides with-in boundary of target shape
   * based on orientation
   *
   * @param conn the <code>Connection</code> to test
   * @param points the <code>PointList</code> to test constraints against
   * @return <code>boolean</code> <code>true</code> if points represent valid tree branch, <code>
   *     false</code> otherwise.
   */
  public boolean isTreeBranch(final Connection conn, final PointList points) {
    boolean result = false;
    if (points.size() == 4) {
      // just check if ends are with-in the owner bounding box
      final Rectangle targetBounds = getTargetAnchorRelativeBounds(conn);
      final Rectangle sourceBounds = getSourceAnchorRelativeBounds(conn);

      if (isTopDown(conn)) {
        result =
            (points.getPoint(0).x > sourceBounds.x
                    && points.getPoint(0).x < sourceBounds.x + sourceBounds.width)
                && (points.getPoint(3).x > targetBounds.x
                    && points.getPoint(3).x < targetBounds.x + targetBounds.width);
      } else {
        result =
            (points.getPoint(0).y > sourceBounds.y
                    && points.getPoint(0).y < sourceBounds.y + sourceBounds.height)
                && (points.getPoint(3).y > targetBounds.y
                    && points.getPoint(3).y < targetBounds.y + targetBounds.height);
      }
    }

    return result;
  }
Пример #10
0
 private PointList getTranslated(PointList source, Point offset) {
   PointList target = new PointList(source.size());
   target.addAll(source);
   target.translate(offset);
   return target;
 }
Пример #11
0
 @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);
 }
Пример #12
0
  private void createElementForTerminalSpec(
      TerminalSpecification_c autoCreationSpec,
      ModelRoot modelRoot,
      PointList line,
      EditPart newPart,
      EditPart targetPart,
      final DiagramEditPart diagramEditPart) {
    ElementSpecification_c specification =
        ElementSpecification_c.getOneGD_ESOnR209(autoCreationSpec);
    if (specification != null && request instanceof GraphicsConnectionCreateRequest) {
      // deactivate the current tool
      ModelTool_c activeTool =
          ModelTool_c.ModelToolInstance(
              modelRoot,
              new ClassQueryInterface_c() {

                @Override
                public boolean evaluate(Object candidate) {
                  return ((ModelTool_c) candidate).getActive();
                }
              });
      activeTool.setActive(false);
      // find the new tool and activate it
      ModelTool_c newTool =
          ModelTool_c.getOneCT_MTLOnR103(
              specification,
              new ClassQueryInterface_c() {

                @Override
                public boolean evaluate(Object candidate) {
                  ModelTool_c tool = (ModelTool_c) candidate;
                  return Model_c.getOneGD_MDOnR100(tool) == diagramEditPart.getModel();
                }
              });
      newTool.setActive(true);
      // create the new element
      if (specification.getSymboltype().equals("connector")) { // $NON-NLS-1$
        // creating a connector
        // we want to create the new connector from the
        // midpoint of the drawn line to the end of the
        // drawn line
        PointList newLine = new PointList();
        newLine.addPoint(line.getLastPoint());
        if (line.size() == 4) {
          // rectilinear routing will have a three points
          newLine.addPoint(line.getPoint(2));
        }
        newLine.addPoint(line.getMidpoint());
        feedback.setPoints(newLine);
        // we also need to adjust the request's source and
        // target edit part, we swap the original target as the
        // source as if the new connection was drawn from
        // the original destination element
        request.setTargetEditPart(newPart);
        request.setSourceEditPart(targetPart);
        // need to update the location in the request for
        // those connectors that end on whitespace
        request.setLocation(line.getMidpoint());
        // we need to configure the proper tool id in the
        // request
        GraphicsConnectionCreateRequest gRequest = (GraphicsConnectionCreateRequest) request;
        gRequest.setToolId(newTool.getTool_id());
        CreateConnectionCommand command = new CreateConnectionCommand(request, feedback);
        command.disableCropping();
        command.execute();
        // reset the active tool states
        newTool.setActive(false);
        activeTool.setActive(true);
      } else if (specification.getSymboltype().equals("shape")) { // $NON-NLS-1$
        // TODO: support shape auto creation
      }
    }
    // otherwise this is not an auto create specification
  }