Ejemplo n.º 1
0
  /**
   * This method calculates the size of this compound model and then recursively calculates the size
   * of its parent, which continues until root.
   */
  public void calculateSizeUp() {
    if (getParentModel() != null && !isRoot) {
      if (this.children.size() == 0) {
        setSize(CompoundModel.DEFAULT_SIZE);
      } else {
        Rectangle bound = calculateBounds();
        Dimension diff = getLocationAbs().getDifference(bound.getLocation());

        setLocationAbs(new Point(bound.x - this.MARGIN_SIZE, bound.y - this.MARGIN_SIZE));
        setSize(
            new Dimension(
                bound.width + (2 * this.MARGIN_SIZE),
                bound.height + (2 * this.MARGIN_SIZE) + this.labelHeight));

        Iterator iter = this.children.iterator();

        while (iter.hasNext()) {
          NodeModel child = (NodeModel) iter.next();
          child.setLocationAbs(
              child
                  .getLocationAbs()
                  .translate(diff.width + this.MARGIN_SIZE, diff.height + this.MARGIN_SIZE));
        }
      }

      (getParentModel()).calculateSizeUp();
    }

    updatePolygonsOfChildren();
  }
Ejemplo n.º 2
0
  public void removeChild(Object o) {
    if (o instanceof NodeModel) {
      NodeModel nodeModel = (NodeModel) o;
      nodeModel.resetClusters();
    }

    this.children.remove(o);
    firePropertyChange(P_CHILDREN, o, null);
  }
Ejemplo n.º 3
0
  protected void updatePolygonsOfChildren() {
    super.updatePolygonsOfChildren();

    // Call recursively all children
    Iterator<NodeModel> childrenIter = this.children.iterator();

    while (childrenIter.hasNext()) {
      NodeModel childModel = childrenIter.next();

      childModel.updatePolygonsOfChildren();
    }
  }
Ejemplo n.º 4
0
  /**
   * This method removes the given cluster from the cluster list of this compound model, and
   * moreover it removes this compound model from the set of clustered nodes of the given cluster.
   * This is done by calling super method. Since this is a compound model, this operation is done
   * recursively.
   */
  public void removeCluster(Cluster cluster) {
    // call super method
    super.removeCluster(cluster);

    // get all children node models
    List childrenNodes = this.children;

    Iterator itr = childrenNodes.iterator();

    // iterate over each child node model
    while (itr.hasNext()) {
      NodeModel childModel = (NodeModel) itr.next();

      // recursively remove children node models from the cluster
      childModel.removeCluster(cluster);
    }
  }
Ejemplo n.º 5
0
  public void setParentModel(CompoundModel parent) {
    super.setParentModel(parent);

    // if a parent of a model is set as null, do not update ClusterManager
    if (parent != null) {
      setClusterManager(parent.getClusterManager());
    }
  }
Ejemplo n.º 6
0
  public void resetClusters() {
    List<Cluster> clusters = new ArrayList<Cluster>();
    clusters.addAll(this.clusters);

    super.resetClusters();

    List childrenNodes = this.children;

    Iterator itr = childrenNodes.iterator();

    while (itr.hasNext()) {
      NodeModel childModel = (NodeModel) itr.next();

      for (Cluster cluster : clusters) {
        childModel.removeCluster(cluster);
      }
    }
  }
Ejemplo n.º 7
0
  /**
   * This method add this compound model into a cluster with given cluster ID. If such cluster
   * doesn't exist in ClusterManager, it creates a new cluster. This is done by calling super
   * method. Since this is a compound model, this operation is done recursively for every child.
   */
  public void addCluster(int clusterID) {
    super.addCluster(clusterID);

    // It is guaranteed here that a cluster with clusterID exists.
    // Therefore, instead of iterating for each child, use the other
    // addCluster(cluster) method for recursion.
    Cluster cluster = this.eClusterManager.getClusterByID(clusterID);

    // get all children node models
    List childrenNodes = this.children;

    Iterator itr = childrenNodes.iterator();

    // iterate over each child node model
    while (itr.hasNext()) {
      NodeModel childModel = (NodeModel) itr.next();

      // recursively add children node models to the cluster
      childModel.addCluster(cluster);
    }
  }
Ejemplo n.º 8
0
  public boolean isAncestorofNode(NodeModel node) {
    CompoundModel root = node.getParentModel();

    while (root != null) {
      if (root == this) {
        return true;
      } else {
        root = root.getParentModel();
      }
    }

    return false;
  }
Ejemplo n.º 9
0
  /** This method calculates sizes of children recursively and then calculates its own size. */
  public void calculateSizeDown() {

    // First, recursively calculate sizes of children compounds
    Iterator iter = this.children.iterator();

    while (iter.hasNext()) {
      NodeModel child = (NodeModel) iter.next();

      if (child instanceof CompoundModel) {
        ((CompoundModel) child).calculateSizeDown();
      }
    }

    if (getParentModel() != null && !isRoot) {
      // Second, calculate size of this compound model
      if (this.children.size() == 0) {
        setSize(CompoundModel.DEFAULT_SIZE);
      } else {
        Rectangle bound = calculateBounds();
        Dimension diff = getLocationAbs().getDifference(bound.getLocation());

        setLocationAbs(new Point(bound.x - this.MARGIN_SIZE, bound.y - this.MARGIN_SIZE));
        setSize(
            new Dimension(
                bound.width + (2 * this.MARGIN_SIZE),
                bound.height + (2 * this.MARGIN_SIZE) + this.labelHeight));

        iter = this.children.iterator();

        while (iter.hasNext()) {
          NodeModel child = (NodeModel) iter.next();
          child.setLocationAbs(
              child
                  .getLocationAbs()
                  .translate(diff.width + this.MARGIN_SIZE, diff.height + this.MARGIN_SIZE));
        }
      }
    }
  }
Ejemplo n.º 10
0
  /** This method finds the boundaries of this compound node. */
  public Rectangle calculateBounds() {
    int top = Integer.MAX_VALUE;
    int left = Integer.MAX_VALUE;
    int right = 0;
    int bottom = 0;
    int nodeTop;
    int nodeLeft;
    int nodeRight;
    int nodeBottom;

    /* Checks the nodes' locations which are children of
     * this compound node.
     */
    Iterator itr = this.getChildren().iterator();

    while (itr.hasNext()) {
      NodeModel node = (NodeModel) itr.next();

      Point locAbs = node.getLocationAbs();
      Dimension size = node.getSize();
      nodeTop = locAbs.y;
      nodeLeft = locAbs.x;
      nodeRight = locAbs.x + size.width;
      nodeBottom = locAbs.y + size.height;

      if (top > nodeTop) {
        top = nodeTop;
      }

      if (left > nodeLeft) {
        left = nodeLeft;
      }

      if (right < nodeRight) {
        right = nodeRight;
      }

      if (bottom < nodeBottom) {
        bottom = nodeBottom;
      }
    }

    // Checks the bendpoints' locations.
    if (this.isRoot) {
      itr = this.getEdges().iterator();
    } else {
      itr = this.getEdgeIterator(ALL_EDGES, true, true);
    }

    while (itr.hasNext()) {
      EdgeModel edge = (EdgeModel) itr.next();
      edge.updateBendpoints();

      for (int i = 0; i < edge.bendpoints.size(); i++) {
        EdgeBendpoint eb = (EdgeBendpoint) edge.bendpoints.get(i);
        Point loc = eb.getLocationFromModel(edge);

        int x = loc.x;
        int y = loc.y;

        if (top > y) {
          top = y;
        }

        if (left > x) {
          left = x;
        }

        if (right < x) {
          right = x;
        }

        if (bottom < y) {
          bottom = y;
        }
      }
    }

    // Do we have any nodes in this graph?
    if (top == Double.MAX_VALUE) {
      return null;
    }

    return new Rectangle(left, top, right - left, bottom - top);
  }