mindmaplayout.java

思维导图(Mind Mapping)以放射性思考(Radiant Thinking)为基础的收放自如方式

        }
        return xBorderSize;
    }


    void updateTreeHeightsAndRelativeYOfDescendantsAndAncestors(NodeView node) {
       updateTreeHeightsAndRelativeYOfDescendants(node);  
       if (! node.isRoot())
       updateTreeHeightsAndRelativeYOfAncestors(node.getParentView()); 
    }

    /**
     * This is called by treeNodesChanged(), treeNodesRemoved() & treeNodesInserted(), so it's the
     * standard mechanism to update the graphical node structure. It updates the parent of the 
     * significant node, and follows recursivly the hierary upwards to root.
     */

    void updateTreeHeightsAndRelativeYOfAncestors(NodeView node) {
		updateTreeGeometry(node);
       if ( !node.isRoot()){
          updateTreeHeightsAndRelativeYOfAncestors(node.getParentView()); }
    }

    //
    // Relative positioning
    //

    // Definiton: relative vertical is either relative Y coord or Treeheight.

    void updateTreeHeightsAndRelativeYOfWholeMap() {
        updateTreeHeightsAndRelativeYOfDescendants(getRoot()); 
		layout(false);
        }

   
    void updateTreeHeightsAndRelativeYOfDescendants(NodeView node) {
	        for (ListIterator e = node.getChildrenViews().listIterator(); e.hasNext();) {
	           updateTreeHeightsAndRelativeYOfDescendants((NodeView)e.next()); }
        updateTreeGeometry(node);
   	}
    
	private void updateRelativeYOfChildren(NodeView node, LinkedList childrenViews) {
		ListIterator e = childrenViews.listIterator();
		if (! e.hasNext())
			return ;
		int vgap = node.getVGap();
		NodeView child = (NodeView)childrenViews.getFirst();
		int pointer  = 0;  
		int upperShift = 0;
		while (e.hasNext()) {
			child = (NodeView)e.next();
			int shiftUp = getShiftUp(child);
			int shiftDown = getShiftDown(child);
			int iAdditionalCloudHeigth = child.getAdditionalCloudHeigth();
			int upperChildShift = child.getUpperChildShift();
			child.relYPos = pointer + upperChildShift
			+ iAdditionalCloudHeigth / 2  + shiftDown; 
			upperShift += upperChildShift + shiftUp;
			pointer +=  child.getTreeHeight()+ shiftUp + shiftDown + iAdditionalCloudHeigth + vgap;
		}
		upperShift += calcStandardTreeShift(node, childrenViews);
		while (e.hasPrevious()) {
			child = (NodeView)e.previous();
			child.relYPos -= upperShift; 
		}
	}

	  protected int getShiftUp(NodeView node) {
	  	int shift = node.getShift();
	  	if (shift < 0)
	  		return -shift;
	  	else
	  		return 0;
	}

	  protected int getShiftDown(NodeView node) {
	  	int shift = node.getShift();
	  	if (shift > 0)
	  		return shift;
	  	else
	  		return 0;
	}
    protected void updateTreeGeometry(NodeView node) {
    	if (node.isRoot()){
    		LinkedList leftNodeViews = getRoot().getLeft();
			LinkedList rightNodeViews = getRoot().getRight();

			int leftWidth = calcTreeWidth(node, leftNodeViews);
			int rightWidth = calcTreeWidth(node, rightNodeViews);
			getRoot().setRootTreeWidths(leftWidth, rightWidth);
			
			updateRelativeYOfChildren(node, leftNodeViews);
			updateRelativeYOfChildren(node, rightNodeViews);
			
			int leftTreeShift = calcUpperChildShift(node, leftNodeViews);
			int rightTreeShift = calcUpperChildShift(node, rightNodeViews);
			
			getRoot().setRootUpperChildShift(leftTreeShift, rightTreeShift);

			int leftTreeHeight = calcTreeHeight(node, leftTreeShift, leftNodeViews);
			int rightTreeHeight = calcTreeHeight(node, rightTreeShift, rightNodeViews);
			
			getRoot().setRootTreeHeights(leftTreeHeight, rightTreeHeight);
    	}
    	else{
			LinkedList childrenViews = node.getChildrenViews();

			int treeWidth = calcTreeWidth(node, childrenViews);
    		node.setTreeWidth(treeWidth); 

    		updateRelativeYOfChildren(node, childrenViews);

			int treeShift = calcUpperChildShift(node, childrenViews);
			node.setUpperChildShift(treeShift);

			int treeHeight = calcTreeHeight(node, treeShift, childrenViews);        	
    		node.setTreeHeight(treeHeight);
    		
// System.out.println(node.getText()
//    				+ ": treeShift=" + treeShift 
//    				+ ": treeHeight=" + treeHeight 
//					);
    	}

    }

	/**
	 * @param node
	 * @param rightNodeViews
	 * @return
	 */
	private int calcUpperChildShift(NodeView node, LinkedList childrenViews) {
		try{
			NodeView firstChild = (NodeView) childrenViews.getFirst();
			int childShift = -firstChild.relYPos 
				+ firstChild.getAdditionalCloudHeigth()/2
				+ firstChild.getUpperChildShift(); 
			return childShift > 0 ? childShift : 0;			
		}
		catch(NoSuchElementException e)
		{
			return 0;
		}
	}

	private int calcStandardTreeShift( NodeView parent, LinkedList childrenViews ) {
    	int parentHeight = parent.getPreferredSize().height;
       if ( childrenViews == null || childrenViews.size() == 0 ) {
          return 0; }
       int height = 0;
       int vgap = parent.getVGap();
       for (ListIterator e = childrenViews.listIterator(); e.hasNext(); ) {
           NodeView node = (NodeView)e.next();
           if (node != null) {
              height += node.getPreferredSize().height + vgap + node.getAdditionalCloudHeigth(); 
           }
       }
       return Math.max(height - vgap - parentHeight, 0) / 2; 
    }

	/**
	 * @param leftNodeViews
	 * @return
	 */
	private int calcTreeHeight(NodeView parent, int treeShift, LinkedList childrenViews) {
    	int parentHeight = parent.getPreferredSize().height;
		try{
			NodeView firstChild = (NodeView) childrenViews.getFirst();
			NodeView lastChild = (NodeView) childrenViews.getLast();
			int minY = Math.min(
					firstChild.relYPos 
					- firstChild.getUpperChildShift()
					- firstChild.getAdditionalCloudHeigth()/2, 
					0);
			int maxY = Math.max(
					lastChild.relYPos 
					- lastChild.getUpperChildShift()
					+ lastChild.getTreeHeight() + lastChild.getAdditionalCloudHeigth()/2 
					, parentHeight);
			return maxY - minY;
		}
		catch(NoSuchElementException e)
		{
	           return parentHeight; 
		}        	        
  	}

	private int calcTreeWidth(NodeView parent, LinkedList childrenViews) {
		int treeWidth = 0;
		for (ListIterator e = childrenViews.listIterator(); e.hasNext(); ) {
			NodeView childNode = (NodeView)e.next();
			if (childNode != null) {
				int childWidth = childNode.getTreeWidth() + childNode.getHGap();
				if(childWidth > treeWidth){
					treeWidth = childWidth;
				}
			}
		}
		return parent.getPreferredSize().width 
		+ 2 * parent.getAdditionalCloudHeigth() 
		+ treeWidth;
	}
	
    //
    // Get Methods
    //

    private RootNodeView getRoot() {
       return (RootNodeView)map.getRoot(); }

    private MapView getMapView() {
       return map; }

    private FreeMindMain getFrame() {
       return map.getController().getFrame(); }


    // This is actually never used.
    public Dimension minimumLayoutSize(Container parent) {
        return new Dimension(200,200); } //For testing Purposes

    public Dimension preferredLayoutSize(Container parent) {
        return new Dimension(getXSize(), getYSize()); }


    private int getXSize() {
        return xSize;
    }

    /**
     * @return
     */
    private int getYSize() {
        return ySize;
    }

    /**
     * @param i
     */
    private void setXSize(int i) {
        xSize = i;
    }

    /**
     * @param i
     */
    private void setYSize(int i) {
        ySize = i;
    }


}//class MindMapLayout