Package com.mxgraph.util

Examples of com.mxgraph.util.mxPoint


   */
  public void updateFloatingTerminalPoint(mxCellState edge,
      mxCellState start, mxCellState end, boolean source)
  {
    start = getTerminalPort(edge, start, source);
    mxPoint next = getNextPoint(edge, end, source);
    double border = mxUtils.getDouble(edge.getStyle(),
        mxConstants.STYLE_PERIMETER_SPACING);
    border += mxUtils.getDouble(edge.getStyle(),
        (source) ? mxConstants.STYLE_SOURCE_PERIMETER_SPACING
            : mxConstants.STYLE_TARGET_PERIMETER_SPACING);
    mxPoint pt = getPerimeterPoint(start, next, graph.isOrthogonal(edge),
        border);
    edge.setAbsoluteTerminalPoint(pt, source);
  }
View Full Code Here


   * @param border Optional border between the perimeter and the shape.
   */
  public mxPoint getPerimeterPoint(mxCellState terminal, mxPoint next,
      boolean orthogonal, double border)
  {
    mxPoint point = null;

    if (terminal != null)
    {
      mxPerimeterFunction perimeter = getPerimeterFunction(terminal);

View Full Code Here

   */
  public mxPoint getNextPoint(mxCellState edge, mxCellState opposite,
      boolean source)
  {
    List<mxPoint> pts = edge.getAbsolutePoints();
    mxPoint point = null;

    if (pts != null && (source || pts.size() > 2 || opposite == null))
    {
      int count = pts.size();
      int index = (source) ? Math.min(1, count - 1) : Math.max(0,
          count - 2);
      point = pts.get(index);
    }

    if (point == null && opposite != null)
    {
      point = new mxPoint(opposite.getCenterX(), opposite.getCenterY());
    }

    return point;
  }
View Full Code Here

  {
    List<mxPoint> points = state.getAbsolutePoints();

    if (points != null && points.size() > 0)
    {
      mxPoint p0 = points.get(0);
      mxPoint pe = points.get(points.size() - 1);

      if (p0 == null || pe == null)
      {
        // Note: This is an error that normally occurs
        // if a connected edge has a null-terminal, ie.
        // source is null and/or target is null and no
        // additional control points are defined
        removeState(state.getCell());
      }
      else
      {
        if (p0.getX() != pe.getX() || p0.getY() != pe.getY())
        {
          double dx = pe.getX() - p0.getX();
          double dy = pe.getY() - p0.getY();
          state.setTerminalDistance(Math.sqrt(dx * dx + dy * dy));
        }
        else
        {
          state.setTerminalDistance(0);
        }

        double length = 0;
        double[] segments = new double[points.size() - 1];
        mxPoint pt = p0;

        double minX = pt.getX();
        double minY = pt.getY();
        double maxX = minX;
        double maxY = minY;

        for (int i = 1; i < points.size(); i++)
        {
          mxPoint tmp = points.get(i);

          if (tmp != null)
          {
            double dx = pt.getX() - tmp.getX();
            double dy = pt.getY() - tmp.getY();

            double segment = Math.sqrt(dx * dx + dy * dy);
            segments[i - 1] = segment;
            length += segment;
            pt = tmp;
View Full Code Here

      }

      if (segment != 0)
      {
        double factor = (dist - length) / segment;
        mxPoint p0 = state.getAbsolutePoint(index - 1);
        mxPoint pe = state.getAbsolutePoint(index);

        if (p0 != null && pe != null)
        {
          double gy = 0;
          double offsetX = 0;
          double offsetY = 0;

          if (geometry != null)
          {
            gy = geometry.getY();
            mxPoint offset = geometry.getOffset();

            if (offset != null)
            {
              offsetX = offset.getX();
              offsetY = offset.getY();
            }
          }

          double dx = pe.getX() - p0.getX();
          double dy = pe.getY() - p0.getY();
          double nx = dy / segment;
          double ny = dx / segment;

          x = p0.getX() + dx * factor + (nx * gy + offsetX) * scale;
          y = p0.getY() + dy * factor - (ny * gy - offsetY) * scale;
        }
      }
    }
    else if (geometry != null)
    {
      mxPoint offset = geometry.getOffset();

      if (offset != null)
      {
        x += offset.getX();
        y += offset.getY();
      }
    }

    return new mxPoint(x, y);
  }
View Full Code Here

      {
        double totalLength = edgeState.getLength();
        double[] segments = edgeState.getSegments();

        // Works which line segment the point of the label is closest to
        mxPoint p0 = edgeState.getAbsolutePoint(0);
        mxPoint pe = edgeState.getAbsolutePoint(1);
        Line2D line = new Line2D.Double(p0.getPoint(), pe.getPoint());
        double minDist = line.ptSegDistSq(x, y);

        int index = 0;
        double tmp = 0;
        double length = 0;

        for (int i = 2; i < pointCount; i++)
        {
          tmp += segments[i - 2];
          pe = edgeState.getAbsolutePoint(i);

          line = new Line2D.Double(p0.getPoint(), pe.getPoint());
          double dist = line.ptSegDistSq(x, y);

          if (dist < minDist)
          {
            minDist = dist;
            index = i - 1;
            length = tmp;
          }

          p0 = pe;
        }

        double seg = segments[index];
        p0 = edgeState.getAbsolutePoint(index);
        pe = edgeState.getAbsolutePoint(index + 1);

        double x2 = p0.getX();
        double y2 = p0.getY();

        double x1 = pe.getX();
        double y1 = pe.getY();

        double px = x;
        double py = y;

        double xSegment = x2 - x1;
        double ySegment = y2 - y1;

        px -= x1;
        py -= y1;
        double projlenSq = 0;

        px = xSegment - px;
        py = ySegment - py;
        double dotprod = px * xSegment + py * ySegment;

        if (dotprod <= 0.0)
        {
          projlenSq = 0;
        }
        else
        {
          projlenSq = dotprod * dotprod
              / (xSegment * xSegment + ySegment * ySegment);
        }

        double projlen = Math.sqrt(projlenSq);

        if (projlen > seg)
        {
          projlen = seg;
        }

        double yDistance = Line2D.ptLineDist(p0.getX(), p0.getY(),
            pe.getX(), pe.getY(), x, y);
        int direction = Line2D.relativeCCW(p0.getX(), p0.getY(),
            pe.getX(), pe.getY(), x, y);

        if (direction == -1)
        {
          yDistance = -yDistance;
        }

        // Constructs the relative point for the label
        return new mxPoint(
            Math.round(((totalLength / 2 - length - projlen) / totalLength)
                * -2), Math.round(yDistance / scale));
      }
    }

    return new mxPoint();
  }
View Full Code Here

   */
  private void translatePoint(List<mxPoint> points, int index, mxPoint offset)
  {
    if (offset != null)
    {
      mxPoint pt = (mxPoint) points.get(index).clone();
      pt.setX(pt.getX() + offset.getX());
      pt.setY(pt.getY() + offset.getY());
      points.set(index, pt);
    }
  }
View Full Code Here

    double absSize = size * canvas.getScale();

    List<mxPoint> points = state.getAbsolutePoints();
    mxLine markerVector = getMarkerVector(points, source, absSize);
    mxPoint p0 = new mxPoint(markerVector.getX(), markerVector.getY());
    mxPoint pe = markerVector.getEndPoint();

    mxPoint offset = null;

    // Computes the norm and the inverse norm
    double dx = pe.getX() - p0.getX();
    double dy = pe.getY() - p0.getY();

    double dist = Math.max(1, Math.sqrt(dx * dx + dy * dy));
    double unitX = dx / dist;
    double unitY = dy / dist;
    double nx = unitX * absSize;
    double ny = unitY * absSize;

    // Allow for stroke width in the end point used and the
    // orthogonal vectors describing the direction of the
    // marker
    double strokeX = unitX * strokeWidth;
    double strokeY = unitY * strokeWidth;
    pe = (mxPoint) pe.clone();
    pe.setX(pe.getX() - strokeX / 2.0);
    pe.setY(pe.getY() - strokeY / 2.0);
   
    mxIMarker marker = mxMarkerRegistry.getMarker(type);
   
    if (marker != null)
    {
      offset = marker.paintMarker(canvas, state, type, pe, nx, ny, absSize);
     
      if (offset != null)
      {
        offset.setX(offset.getX() - strokeX / 2.0);
        offset.setY(offset.getY() - strokeY / 2.0);
      }
    }
    else
    {
      // Offset for the strokewidth
      nx = dx * strokeWidth / dist;
      ny = dy * strokeWidth / dist;

      offset = new mxPoint(-strokeX / 2.0, -strokeY / 2.0);
    }

    return offset;
  }
View Full Code Here

            });
          }
          else
          {
            // Resets the translation of the view
            mxPoint tr = graphComponent.getGraph().getView()
                .getTranslate();

            if (tr.getX() != 0 || tr.getY() != 0)
            {
              graphComponent.getGraph().getView().setTranslate(
                  new mxPoint());
            }
          }
        }
      }
    });
View Full Code Here

    {
      Object tmp = view.getCurrentRoot();
      view.currentRoot = previous;
      previous = tmp;

      mxPoint translate = view.graph.getTranslateForRoot(view
          .getCurrentRoot());

      if (translate != null)
      {
        view.translate = new mxPoint(-translate.getX(),
            translate.getY());
      }

      // Removes all existing cell states and revalidates
      view.reload();
      up = !up;
View Full Code Here

TOP

Related Classes of com.mxgraph.util.mxPoint

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.