Package pl.tecna.gwt.connectors.client

Examples of pl.tecna.gwt.connectors.client.CornerPoint


    cornerPoints.removeAll(cornerPoints);

    int width = Math.abs(startEndPoint.getLeft() - endEndPoint.getLeft());
    int height = Math.abs(startEndPoint.getTop() - endEndPoint.getTop());

    CornerPoint cp1 = new CornerPoint(0, 0);
    CornerPoint cp2 = new CornerPoint(0, 0);
    if (width < height) {
      // the connection contains two vertical sections and one horizontal section
      cp1.setLeft(startEndPoint.getLeft());
      cp1.setTop(startEndPoint.getTop() + ((endEndPoint.getTop() - startEndPoint.getTop()) / 2));
      cp2.setLeft(endEndPoint.getLeft());
      cp2.setTop(cp1.getTop());
    } else {
      // the connection contains two horizontal sections and one vertical section
      cp1.setLeft(startEndPoint.getLeft() + ((endEndPoint.getLeft() - startEndPoint.getLeft()) / 2));
      cp1.setTop(startEndPoint.getTop());
      cp2.setLeft(cp1.getLeft());
      cp2.setTop(endEndPoint.getTop());
    }
    cornerPoints.add(cp1);
    cornerPoints.add(cp2);

  }
View Full Code Here


    boundaryPanel.add(new Label("Connectors example for GWT 2.4"), 10, 2);
    Connector connector1 = new Connector(50, 80, 150, 200, new SectionDecoration(DecorationType.ARROW_SOLID), new SectionDecoration(DecorationType.ARROW_SOLID));
    connector1.showOnDiagram(diagram);

    ArrayList<CornerPoint> cp = new ArrayList<CornerPoint>();
    cp.add(new CornerPoint(370, 200));
    cp.add(new CornerPoint(370, 120));
    cp.add(new CornerPoint(270, 120));
    SectionDecoration startDecoration = new SectionDecoration(DecorationType.ARROW_LINE);
    SectionDecoration endDecoration = new SectionDecoration(
        new Image("http://code.google.com/images/code_sm.png"),
        new Image("http://code.google.com/images/code_sm.png"));
    Connector connector2 = new Connector(350, 200, 270, 80, cp, startDecoration, endDecoration);
View Full Code Here

          if (Section.this.startPointIsGluedToConnectionPoint() || Section.this.endPointIsGluedToConnectionPoint()) {
            // Calculate new CornerPoints
            ArrayList<CornerPoint> newCornerPoints = new ArrayList<CornerPoint>();
            Point sp = Section.this.startPoint;
            Point ep = Section.this.endPoint;
            CornerPoint cp1 =
                new CornerPoint(sp.getLeft() + (ep.getLeft() - sp.getLeft()) / 2, sp.getTop()
                    + (ep.getTop() - sp.getTop()) / 2);
            CornerPoint cp2 =
                new CornerPoint(sp.getLeft() + (ep.getLeft() - sp.getLeft()) / 2, sp.getTop()
                    + (ep.getTop() - sp.getTop()) / 2);
            newCornerPoints.add(cp1);
            newCornerPoints.add(cp2);
            // Split Section
            Section.this.splitSection(newCornerPoints);
View Full Code Here

        drawSections(cornerPoints, isSelected);
        return false;
      }

      // Last or first cornerPont, depends on endPoint place (start or end of Connector)
      CornerPoint extremeCorner = null;

      // New cornerPoint which is added to make last section perpendicular to shape
      CornerPoint newCornerPoint = null;

      // Creating new CornerPoint
      if (connectionPoint.connectionDirection == ConnectionPoint.DIRECTION_LEFT
          || connectionPoint.connectionDirection == ConnectionPoint.DIRECTION_RIGHT) {
        // Horizontal
        if (last) {
          extremeCorner = cornerPoints.get(cornerPoints.size() - 1);
        } else {
          extremeCorner = cornerPoints.get(0);
        }

        if (connectionPoint.connectionDirection == ConnectionPoint.DIRECTION_RIGHT) {
          extremeCorner.setLeft(extremeCorner.getLeft() + sectionMargin);
        } else {
          extremeCorner.setLeft(extremeCorner.getLeft() - sectionMargin);
        }

        if (last) {
          newCornerPoint = new CornerPoint(extremeCorner.getLeft(), endEndPoint.getTop());
        } else {
          newCornerPoint = new CornerPoint(extremeCorner.getLeft(), startEndPoint.getTop());
        }
      } else if (connectionPoint.connectionDirection == ConnectionPoint.DIRECTION_BOTTOM
          || connectionPoint.connectionDirection == ConnectionPoint.DIRECTION_TOP) {
        // Vertical
        if (last) {
          extremeCorner = cornerPoints.get(cornerPoints.size() - 1);
        } else {
          extremeCorner = cornerPoints.get(0);
        }
        if (connectionPoint.connectionDirection == ConnectionPoint.DIRECTION_BOTTOM) {
          extremeCorner.setTop(extremeCorner.getTop() + sectionMargin);
        } else {
          extremeCorner.setTop(extremeCorner.getTop() - sectionMargin);
        }
        if (last) {
          newCornerPoint = new CornerPoint(endEndPoint.getLeft(), extremeCorner.getTop());
        } else {
          newCornerPoint = new CornerPoint(startEndPoint.getLeft(), extremeCorner.getTop());
        }
      }

      if (newCornerPoint != null) {
        if (last) {
View Full Code Here

   * @return the list of corner points
   */
  public List<CornerPoint> getCorners(List<Section> sectionList) {
    List<CornerPoint> retList = new ArrayList<CornerPoint>();
    for (int i = 0; i < sectionList.size() - 1; i++) {
      retList.add(new CornerPoint(sectionList.get(i).endPoint.getLeft(), sectionList.get(i).endPoint.getTop()));
    }

    return retList;
  }
View Full Code Here

    if (!this.endEndPoint.isGluedToConnectionPoint() || endSection.getLength() > lastSectionTolerance
        || this.sections.size() < 2 || cornerPoints.size() < 2) {
      return false;
    }

    CornerPoint beforeLast = cornerPoints.get(cornerPoints.size() - 2);
    CornerPoint newCorner = null;

    switch (connDirection) {
      case 1:
        if (endSection.isHorizontal()) {
          newCorner = new CornerPoint(endSection.endPoint.getLeft(), beforeLast.getTop());
        }
        break;

      case 2:
        if (endSection.isVertical()) {
          newCorner = new CornerPoint(beforeLast.getLeft(), endSection.endPoint.getTop());
        }
        break;

      case 3:
        if (endSection.isHorizontal()) {
          newCorner = new CornerPoint(endSection.endPoint.getLeft(), beforeLast.getTop());
        }
        break;

      case 4:
        if (endSection.isVertical()) {
          newCorner = new CornerPoint(beforeLast.getLeft(), endSection.endPoint.getTop());
        }
        break;

    }
    if (newCorner != null) {
View Full Code Here

    if (!this.startEndPoint.isGluedToConnectionPoint() || startSection.getLength() > lastSectionTolerance
        || this.sections.size() < 2 || cornerPoints.size() < 2) {
      return false;
    }

    CornerPoint second = cornerPoints.get(1);

    CornerPoint newCorner = null;
    switch (connDirection) {
      case 1:
        if (startSection.isHorizontal()) {
          newCorner = new CornerPoint(startSection.startPoint.getLeft(), second.getTop());
        }
        break;

      case 2:
        if (startSection.isVertical()) {
          newCorner = new CornerPoint(second.getLeft(), startSection.startPoint.getTop());
        }
        break;

      case 3:
        if (startSection.isHorizontal()) {
          newCorner = new CornerPoint(startSection.startPoint.getLeft(), second.getTop());
        }
        break;

      case 4:
        if (startSection.isVertical()) {
          newCorner = new CornerPoint(second.getLeft(), startSection.startPoint.getTop());
        }
        break;
    }

    if (newCorner != null) {
View Full Code Here

  public List<CornerPoint> fixLineSections(List<CornerPoint> corners) {
    if (corners.size() < 3) {
      return corners;
    }

    CornerPoint startCorner = new CornerPoint(startEndPoint.getLeft(), startEndPoint.getTop());
    CornerPoint endCorner = new CornerPoint(endEndPoint.getLeft(), endEndPoint.getTop());
    corners.add(0, startCorner);
    corners.add(endCorner);

    List<CornerPoint> toRemove = new ArrayList<CornerPoint>();
    // fix corners that are in one exact line
    for (int i = 1; i < corners.size() - 1; i++) {
      if (corners.get(i).getLeft().intValue() == corners.get(i + 1).getLeft()
          && corners.get(i).getLeft().intValue() == corners.get(i - 1).getLeft()) {
        toRemove.add(corners.get(i));
      } else if (corners.get(i).getTop().intValue() == corners.get(i + 1).getTop()
          && corners.get(i).getTop().intValue() == corners.get(i - 1).getTop()) {
        toRemove.add(corners.get(i));
      }
    }

    for (CornerPoint removed : toRemove) {
      corners.remove(removed);
    }

    boolean allCornersChecked = false;

    while (!allCornersChecked && corners.size() > 4) {
      toRemove = new ArrayList<CornerPoint>();
      boolean findShortSection = true;
      int i = 2;
      CornerPoint toChange = null;
      CornerPoint nextToChanged = null;
      while (i < corners.size() - 1 && findShortSection) {
        if ((Math.abs(corners.get(i - 1).getLeft() - corners.get(i).getLeft()) < Shape.SECTION_TOLERANCE)
            && ((Math.abs(corners.get(i - 1).getTop() - corners.get(i).getTop()) < Shape.SECTION_TOLERANCE))) {

          boolean doProceed = true;
          if (i < corners.size() - 2) {
            toChange = corners.get(i + 1);
            nextToChanged = corners.get(i - 2);
          } else if (i > 2) {
            toChange = corners.get(i - 2);
            nextToChanged = corners.get(i + 1);
          } else {
            LOG.severe("No condition was meet");
            doProceed = false;
          }

          if (doProceed) {
            toRemove.add(corners.get(i - 1));
            toRemove.add(corners.get(i));

            if (toRemove.get(0).getLeft().compareTo(toRemove.get(1).getLeft()) == 0) {
              // removed corners points were vertically matched
              toChange.setTop(nextToChanged.getTop().intValue());
            } else {
              toChange.setLeft(nextToChanged.getLeft().intValue());
            }

            findShortSection = false;
          }
        }
View Full Code Here

        }
      }
    }

    // Define start connection point
    CornerPoint startCorner = null;
    CornerPoint endCorner = null;

    switch (shapeEnterDirection) {
      case 0:
        startCorner = new CornerPoint(shapeLeft, first.endPoint.getTop().intValue());
        break;
      case 1:
        startCorner = new CornerPoint(first.endPoint.getLeft().intValue(), shapeTop);
        break;
      case 2:
        startCorner = new CornerPoint(shapeRight, first.endPoint.getTop().intValue());
        break;
      case 3:
        startCorner = new CornerPoint(first.endPoint.getLeft().intValue(), shapeBottom);
        break;
    }

    // Define leave connection point
    switch (shapeLeaveDirection) {
      case 0:
        endCorner = new CornerPoint(shapeLeft, last.endPoint.getTop().intValue());
        break;
      case 1:
        endCorner = new CornerPoint(last.endPoint.getLeft().intValue(), shapeTop);
        break;
      case 2:
        endCorner = new CornerPoint(shapeRight, last.endPoint.getTop().intValue());
        break;
      case 3:
        endCorner = new CornerPoint(last.endPoint.getLeft().intValue(), shapeBottom);
        break;
    }

    // Define middle connection points
    i = shapeEnterDirection;
    proceed = true;
    CornerPoint tempCorner = null;
    List<CornerPoint> middleCorners = new ArrayList<CornerPoint>();

    while (i != shapeLeaveDirection) {
      if (direction == 0) {
        i++;
        if (i == 4) {
          i = 0;
        }
      } else {
        i--;
        if (i == -1) {
          i = 3;
        }
      }

      switch (i) {
        case 0:
          if (direction == 0) {
            tempCorner = new CornerPoint(shapeLeft, shapeBottom);
          } else {
            tempCorner = new CornerPoint(shapeLeft, shapeTop);
          }
          break;

        case 1:
          if (direction == 0) {
            tempCorner = new CornerPoint(shapeLeft, shapeTop);
          } else {
            tempCorner = new CornerPoint(shapeRight, shapeTop);
          }
          break;

        case 2:
          if (direction == 0) {
            tempCorner = new CornerPoint(shapeRight, shapeTop);
          } else {
            tempCorner = new CornerPoint(shapeRight, shapeBottom);
          }
          break;

        case 3:
          if (direction == 0) {
            tempCorner = new CornerPoint(shapeRight, shapeBottom);
          } else {
            tempCorner = new CornerPoint(shapeLeft, shapeBottom);
          }
          break;
      }
      middleCorners.add(tempCorner);
    }

    // add startEndPoint and endEndPoint to corners, for easier defining
    // insert position
    CornerPoint firstSectionStart = new CornerPoint(first.startPoint.getLeft(), first.startPoint.getTop());
    CornerPoint lastSectionEnd = new CornerPoint(last.endPoint.getLeft(), last.endPoint.getTop());
    boolean addToRemove = false;

    // Index in cornerpoints list after which new corner points will be inserted
    int insertIndex = -1;

    List<CornerPoint> toRemove = new ArrayList<CornerPoint>();

    CornerPoint startEndPointCorner =
        new CornerPoint(this.startEndPoint.getLeft().intValue(), this.startEndPoint.getTop().intValue());
    CornerPoint endEndPointCorner =
        new CornerPoint(this.endEndPoint.getLeft().intValue(), this.endEndPoint.getTop().intValue());

    corners.add(0, startEndPointCorner);
    corners.add(endEndPointCorner);

    // define corner points to remove (corners lying inside evaded shape)
View Full Code Here

TOP

Related Classes of pl.tecna.gwt.connectors.client.CornerPoint

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.