Java TreePath.pathByAddingChild方法代码示例

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
/**
 * Gets the total rowspan of the last element of irTreePath.
 *
 * @param irTreePath
 * @return
 */
protected int getRowSpanOfLastElement(TreePath irTreePath) {
    OutlineModel lrModel = getOutline().getOutlineModel();

    if (!isExpanded(irTreePath)) {
        return 1;
    }

    Object lrLast = irTreePath.getLastPathComponent();
    int lnRowspan = 1; //1 for the current node
    int lnChildCount = lrModel.getChildCount(lrLast);

    for (int i = 0; i < lnChildCount; i++) {
        Object lnChild = lrModel.getChild(lrLast, i);

        TreePath lrTempPath = irTreePath.pathByAddingChild(lnChild);
        lnRowspan += getRowSpanOfLastElement(lrTempPath);
    }

    return lnRowspan;
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
TreePath getNextPath(TreePath path, boolean down) {
    TreeModel _model = model.treeModel;
    TreeNode node = (TreeNode)path.getLastPathComponent();
    if (down && _model.getChildCount(node) > 0)
        return path.pathByAddingChild(_model.getChild(node, 0));

    TreePath parentPath = path.getParentPath();
    if (!down && parentPath == null)
        return path.pathByAddingChild(_model.getChild(node, 0));
    
    TreeNode parent = (TreeNode)parentPath.getLastPathComponent();
    int idx = _model.getIndexOfChild(parent, node) + 1;

    if (_model.getChildCount(parent) > idx)
        return parentPath.pathByAddingChild(_model.getChild(parent, idx));

    if (!down && parentPath.getParentPath() == null) {
        return parentPath.pathByAddingChild(_model.getChild(parent, 0));
    } else {
        return getNextPath(parentPath, false);
    }
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
/**
 * iterate through every child and do the action
 *
 * @param parent
 * @param expand
 */
private void expandAll(TreePath parent, boolean expand) {
    TreeNode node = (TreeNode) parent.getLastPathComponent();
    if (getChildCount(node) >= 0) {
        for (int i = 0; i < getChildCount(node); i++) {
            TreePath path = parent.pathByAddingChild(getChildAt(node, i));
            expandAll(path, expand);
        }
    }
    if (expand) {
        expandPath(parent);
    } else {
        collapsePath(parent);
    }

}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
public void expandFirstPath(int row) {
    if (tree != null) try {
        markExpansionTransaction();

        TreePath tpath = tree.getPathForRow(row);
        if (tpath == null) return;

        TreeModel tmodel = tree.getModel();    

        while (tmodel.getChildCount(tpath.getLastPathComponent()) > 0)
            tpath = tpath.pathByAddingChild(tmodel.getChild(tpath.getLastPathComponent(), 0));

        tree.putClientProperty(UIUtils.PROP_AUTO_EXPANDING, Boolean.TRUE);
        try { selectPath(tpath, true); }
        finally { tree.putClientProperty(UIUtils.PROP_AUTO_EXPANDING, null); }

    } finally {
        clearExpansionTransaction();
    }
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
/**
 * Option tree expand.
 *
 * @param parent the parent
 * @param expand the expand
 * @param currNodeLevel the curr node level
 * @param up2TreeLevel the up2 tree level
 */
private void optionTreeExpand(TreePath parent, boolean expand, Integer currNodeLevel, Integer up2TreeLevel) {
   
       TreeNode node = (TreeNode)parent.getLastPathComponent();
       if (currNodeLevel >= up2TreeLevel) {
       	return;
       }
       if (node.getChildCount() >= 0) {
           for ( @SuppressWarnings("rawtypes") Enumeration e=node.children(); e.hasMoreElements(); ) {
               TreeNode n = (TreeNode) e.nextElement();
               TreePath path = parent.pathByAddingChild(n);
               optionTreeExpand(path, expand, currNodeLevel+1, up2TreeLevel);
           }
       }    
       // Expansion or collapse must be done bottom-up
       if (expand) {
       	jTreeOptions.expandPath(parent);
       } else {
       	jTreeOptions.collapsePath(parent);
       }
   }
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
private void toggleRemoveSelection(TreePath path) {
    Stack stack = new Stack();
    TreePath parent = path.getParentPath();
    while (parent != null && !isPathSelected(parent)) {
        stack.push(parent);
        parent = parent.getParentPath();
    }
    if (parent != null) {
        stack.push(parent);
    } else {
        super.removeSelectionPaths(new TreePath[]{path});
        return;
    }

    while (!stack.isEmpty()) {
        TreePath temp = (TreePath) stack.pop();
        TreePath peekPath = stack.isEmpty() ? path : (TreePath) stack.peek();
        Object node = temp.getLastPathComponent();
        Object peekNode = peekPath.getLastPathComponent();
        int childCount = model.getChildCount(node);
        for (int i = 0; i < childCount; i++) {
            Object childNode = model.getChild(node, i);
            if (childNode != peekNode) {
                super.addSelectionPaths(new TreePath[]{temp.pathByAddingChild(childNode)});
            }
        }
    }
    super.removeSelectionPaths(new TreePath[]{parent});
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
/**
 * Returns a TreePath to the element at <code>position</code>.
 */
protected TreePath getPathForIndex(int position, Object root,
        Element rootElement) {
    TreePath path = new TreePath(root);
    Element child = rootElement.getElement(rootElement.getElementIndex(
            position));

    path = path.pathByAddingChild(rootElement);
    path = path.pathByAddingChild(child);
    while (!child.isLeaf()) {
        child = child.getElement(child.getElementIndex(position));
        path = path.pathByAddingChild(child);
    }
    return path;
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
/** Checks give TreePath for the last node, and if it ends with a node with just one child,
 * it keeps expanding further.
 * Current implementation expands through the first child that is not leaf. To more correctly
 * fulfil expected semantics in case maxChildToExpand is > 1, it should expand all paths through
 * all children.
 *
 * @param tree
 * @param path
 * @param maxChildToExpand
 */
public static void autoExpand(JTree tree, TreePath path, int maxLines, int maxChildToExpand, boolean dontExpandToLeafs) {
    TreeModel model = tree.getModel();
    Object node = path.getLastPathComponent();
    TreePath newPath = path;

    int currentLines = 0;

    while (currentLines++ < maxLines &&
            !model.isLeaf(node) &&
            (model.getChildCount(node) > 0) &&
            (model.getChildCount(node) <= maxChildToExpand)) {
        for (int i = 0; i < model.getChildCount(node); i++) {
            node = tree.getModel().getChild(node, i);

            if (!model.isLeaf(node)) {
                if (dontExpandToLeafs && hasOnlyLeafs(tree, node)) {
                    break;
                }

                newPath = newPath.pathByAddingChild(node); // if the leaf is added the path will not expand

                break; // from for
            }
        }
    }

    tree.expandPath(newPath);
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
private TreePath getSimilarPath(TreePath oldPath) {
    if (oldPath == null || oldPath.getPathCount() < 1) return null;

    TreeModel currentModel = getModel();
    Object currentRoot = currentModel.getRoot();
    if (!currentRoot.equals(oldPath.getPathComponent(0))) return null;

    TreePath p = new TreePath(currentRoot);
    Object[] op = oldPath.getPath();
    Object n = currentRoot;

    for (int i = 1; i < op.length; i++) {
        Object nn = null;

        for (int ii = 0; ii < currentModel.getChildCount(n); ii++) {
            Object c = currentModel.getChild(n, ii);
            if (c.equals(op[i])) {
                nn = c;
                break;
            }
        }

        if (nn == null) return null;

        n = nn;
        p = p.pathByAddingChild(n);
    }

    return p;
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
private void expandAll(final JTree tree, final TreePath parent) {
  final TreeNode node = (TreeNode) parent.getLastPathComponent();
  if (node.getChildCount() >= 0) {
    for (@SuppressWarnings("rawtypes")
    final Enumeration e = node.children(); e.hasMoreElements();) {
      final TreeNode n = (TreeNode) e.nextElement();
      final TreePath path = parent.pathByAddingChild(n);
      this.expandAll(tree, path);
    }
  }
  tree.expandPath(parent);
  // tree.collapsePath(parent);
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
public void selectTreeNode(int offset) {
    TreeNodeAdapter root = (TreeNodeAdapter)tree.getModel().getRoot();
    
    int from = root.getStart();
    int to = root.getEnd();
    // sanity check:
    if (offset < from || offset >= to) {
        // retain the selection path as it is
        return;
    }
    TreePath p = new TreePath(root);
    boolean cont = true;
    OUT: while (cont) {
        cont = false;
        Enumeration chE = root.children();
        while (chE.hasMoreElements()) {
            TreeNodeAdapter ch = (TreeNodeAdapter)chE.nextElement();
            if (offset < ch.getStart()) {
                break OUT;
            }
            if (offset < ch.getEnd()) {
                root = ch;
                p = p.pathByAddingChild(ch);
                cont = true;
                break;
            }
        }
    };
    tree.scrollPathToVisible(p);
    tree.setSelectionPath(p);
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
public static void expandAll(Tree tree, TreePath parent, boolean expand) {
    TreeNode node = (TreeNode) parent.getLastPathComponent();
    if (node.getChildCount() >= 0) {
        for (Enumeration e = node.children() ; e.hasMoreElements() ; ) {
            TreeNode n = (TreeNode) e.nextElement();
            TreePath path = parent.pathByAddingChild(n);
            expandAll(tree, path, expand);
        }
    }
    if (expand) {
        tree.expandPath(parent);
    } else {
        tree.collapsePath(parent);
    }
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
private static void expandTreeRecursively(JTree tree, TreePath parent) {
    tree.expandPath(parent);
    TreeNode node = (TreeNode) parent.getLastPathComponent();
    if (node.getChildCount() >= 0) {
        for (Enumeration e = node.children(); e.hasMoreElements(); ) {
            TreeNode n = (TreeNode) e.nextElement();
            TreePath path = parent.pathByAddingChild(n);
            expandTreeRecursively(tree, path);
        }
    }
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
/**
 * Constructs new path from a path and index's subnode of it last node.
 *
 * @param path a path indicating a node to get a child of.
 * @param index a child node index.
 * @return a number of children.
 */
public TreePath getChildPath(TreePath path, int index) {
    if (path != null) {
        return (path.
                pathByAddingChild(getChild(path.
                        getLastPathComponent(), index)));
    } else {
        throw (new NoSuchPathException());
    }
}
 

import javax.swing.tree.TreePath; //导入方法依赖的package包/类
/** Creates TreePath leading to the specified operator. */
public TreePath getPathTo(Operator operator) {
	if (operator.getParent() == null) {
		return new TreePath(operator);
	} else {
		TreePath pathToParent;
		if (operator.getParent().getNumberOfSubprocesses() == 1) {
			pathToParent = getPathTo(operator.getParent());
		} else {
			pathToParent = getPathTo(operator.getExecutionUnit());
		}
		return pathToParent.pathByAddingChild(operator);
	}
}