下面列出了javax.swing.tree.DefaultMutableTreeNode#breadthFirstEnumeration ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
protected DefaultMutableTreeNode findNode (DefaultMutableTreeNode node, String name)
// ---------------------------------------------------------------------------------//
{
Enumeration<TreeNode> children = node.breadthFirstEnumeration ();
if (children != null)
{
while (children.hasMoreElements ())
{
DefaultMutableTreeNode childNode =
(DefaultMutableTreeNode) children.nextElement ();
if (childNode.getUserObject ().toString ().indexOf (name) > 0)
return childNode;
}
}
return null;
}
public void replaceDisk (FormattedDisk disk)
// ---------------------------------------------------------------------------------//
{
// first check currently selected disk
FileNode fn = (FileNode) getSelectedObject ();
if (fn != null && fn.replaceDisk (disk))
return;
// find the old disk and replace it
DefaultMutableTreeNode rootNode = getRootNode ();
Enumeration<TreeNode> children = rootNode.breadthFirstEnumeration ();
while (children.hasMoreElements ())
{
DefaultMutableTreeNode node = (DefaultMutableTreeNode) children.nextElement ();
fn = (FileNode) node.getUserObject ();
if (fn.replaceDisk (disk))
break;
}
}
@Test
public void getPath() {
final T tree = newTree(5, new Random(123));
final DefaultMutableTreeNode stree = newSwingTree(5, new Random(123));
final Iterator<T> treeIt = tree.breadthFirstIterator();
final Enumeration<?> streeIt = stree.breadthFirstEnumeration();
while (treeIt.hasNext()) {
final T node = treeIt.next();
final DefaultMutableTreeNode snode = (DefaultMutableTreeNode)streeIt.nextElement();
Assert.assertEquals(
node.pathElements().map(t -> t.value()),
ISeq.of(snode.getUserObjectPath())
);
}
}
@Test(dataProvider = "nodeQueryMethods")
public void nodeQueryMethod(final QueryMethod method) {
final Iterator<T> tree = newTree(5, new Random(123))
.breadthFirstIterator();
final Enumeration<?> swing = newSwingTree(5, new Random(123))
.breadthFirstEnumeration();
while (tree.hasNext()) {
final T node1 = tree.next();
final DefaultMutableTreeNode node2 = (DefaultMutableTreeNode)swing.nextElement();
final Iterator<T> tree1 = node1.breadthFirstIterator();
final Enumeration<?> swing1 = node2.breadthFirstEnumeration();
while (tree1.hasNext()) {
final T node21 = tree1.next();
final DefaultMutableTreeNode node22 = (DefaultMutableTreeNode)swing1.nextElement();
assertEqualNodes(
Try(() -> method._method1.apply(node1, node21)),
Try(() -> method._method2.apply(node2, node22))
);
}
}
}
private void expandTree(JTree tree) {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getModel()
.getRoot();
Enumeration e = root.breadthFirstEnumeration();
while (e.hasMoreElements()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.nextElement();
if (node.isLeaf()) {
continue;
}
int row = tree.getRowForPath(new TreePath(node.getPath()));
tree.expandRow(row);
}
}
private List<DefaultMutableTreeNode> collectSubtreeNodes(final DefaultMutableTreeNode node) {
final List<DefaultMutableTreeNode> nodes = new ArrayList<DefaultMutableTreeNode>();
for (final Enumeration<?> e = node.breadthFirstEnumeration(); e.hasMoreElements();) {
nodes.add((DefaultMutableTreeNode) e.nextElement());
}
return nodes;
}
private static Multimap<Integer, DefaultMutableTreeNode> getNodesByLevel(
final DefaultMutableTreeNode root) {
final Multimap<Integer, DefaultMutableTreeNode> nodesByLevel = HashMultimap.create();
for (final Enumeration<?> e = root.breadthFirstEnumeration(); e.hasMoreElements();) {
final DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.nextElement();
nodesByLevel.put(node.getLevel(), node);
}
return nodesByLevel;
}
public static void collapseFirstHierarchy(JTree tree) {
TreeModel model = tree.getModel();
DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
// // Java 9:
// Collections.list(root.breadthFirstEnumeration()).stream()
// .filter(DefaultMutableTreeNode.class::isInstance)
// .map(DefaultMutableTreeNode.class::cast)
// .takeWhile(node -> node.getLevel() <= 1)
// .dropWhile(DefaultMutableTreeNode::isRoot)
// .dropWhile(DefaultMutableTreeNode::isLeaf)
// .map(DefaultMutableTreeNode::getPath)
// .map(TreePath::new)
// .forEach(tree::collapsePath);
// Java 9: Enumeration<TreeNode> e = root.breadthFirstEnumeration();
Enumeration<?> e = root.breadthFirstEnumeration();
while (e.hasMoreElements()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.nextElement();
boolean isOverFirstLevel = node.getLevel() > 1;
if (isOverFirstLevel) { // Collapse only nodes in the first hierarchy
return;
} else if (node.isLeaf() || node.isRoot()) {
continue;
}
collapseNode(tree, node);
}
}
private void updateAllChildrenUserObject(DefaultMutableTreeNode root, boolean match) {
Enumeration<?> breadth = root.breadthFirstEnumeration();
while (breadth.hasMoreElements()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) breadth.nextElement();
if (Objects.equals(root, node)) {
continue;
}
FilterableNode uo = (FilterableNode) node.getUserObject();
uo.status = match;
}
}
@Test
public void breathFirstIterator() {
final T tree = newTree(5, new Random(123));
final DefaultMutableTreeNode stree = newSwingTree(5, new Random(123));
final Iterator<T> treeIt = tree.breadthFirstIterator();
final Enumeration<?> streeIt = stree.breadthFirstEnumeration();
while (treeIt.hasNext()) {
final T node = treeIt.next();
final DefaultMutableTreeNode snode = (DefaultMutableTreeNode)streeIt.nextElement();
Assert.assertEquals(node.value(), snode.getUserObject());
}
}
public static void nodesChanged(DefaultTreeModel rightTreeModel) {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) rightTreeModel.getRoot();
Enumeration enumeration = root.breadthFirstEnumeration();
while (enumeration.hasMoreElements()) {
DefaultMutableTreeNode defaultMutableTreeNode = (DefaultMutableTreeNode) enumeration.nextElement();
rightTreeModel.nodeChanged(defaultMutableTreeNode);
}
}