Java Code Examples for javax.swing.tree.TreeNode#getChildAt()

@RequiredUIAccess
@Override
public void apply() throws ConfigurationException {
  boolean modifiedSdks = false;
  for (int i = 0; i < myRoot.getChildCount(); i++) {
    final TreeNode groupNode = myRoot.getChildAt(i);

    for (int k = 0; k < groupNode.getChildCount(); k++) {
      final MyNode sdkNode = (MyNode)groupNode.getChildAt(k);
      final NamedConfigurable configurable = sdkNode.getConfigurable();
      if (configurable.isModified()) {
        configurable.apply();
        modifiedSdks = true;
      }
    }
  }

  if (mySdksModel.isModified() || modifiedSdks) mySdksModel.apply(this);
}
 

public void testLazyFilterGet() throws Exception {
    LazyChildren lch = new LazyChildren();
    AbstractNode a = new AbstractNode(lch);
    FilterNode fnode = new FilterNode(a);
    
    TreeNode ta = Visualizer.findVisualizer(fnode);
    
    assertEquals("Child check", "c", ta.getChildAt(2).toString());
    assertEquals("Counter should be 1", 1, lch.cnt);

    VisualizerNode vn = (VisualizerNode)ta.getChildAt(2);
    String msg = ((VisualizerNode)ta).getChildren().dumpIndexes(vn);
    if (msg.indexOf("'c'") == -1) {
        fail("Missing note about visualizer node 'c': " + msg);
    }
}
 

private boolean areSiblingsFullyChecked() {
    TreeNode parent = getParent();

    for (int i = 0; i < parent.getChildCount(); i++) {
        TreeNode node = parent.getChildAt(i);

        if (node == this) {
            continue;
        }

        if (!(node instanceof CheckTreeNode) || (((CheckTreeNode) node).getCheckState() != STATE_CHECKED)) {
            return false;
        }
    }

    return true;
}
 

private boolean areSiblingsUnchecked() {
    TreeNode parent = getParent();

    for (int i = 0; i < parent.getChildCount(); i++) {
        TreeNode node = parent.getChildAt(i);

        if (node == this) {
            continue;
        }

        if (!(node instanceof CheckTreeNode) || (((CheckTreeNode) node).getCheckState() != STATE_UNCHECKED)) {
            return false;
        }
    }

    return true;
}
 

private boolean showAll(TreePath root, TreePath sub, boolean expand) {
	TreeNode node = (TreeNode)sub.getLastPathComponent();
	
	for (int i = 0; i < node.getChildCount(); ++i) {
		TreeNode child = node.getChildAt(i);
		if (child.isLeaf())
			continue;
		
		if (showAll(root, sub.pathByAddingChild(child), expand))
			return true;
	}
	
	if (root == sub)
		return false;
	
	return expand ? tree.isCollapsed(sub) : tree.isExpanded(sub);
}
 

@Override
public void treeExpanded(final TreeExpansionEvent event) {
	final TreePath treePath = event.getPath();

	final Object expandedTreePathObject = treePath.getLastPathComponent();
	if (!(expandedTreePathObject instanceof TreeNode)) {
		return;
	}

	final TreeNode expandedTreeNode = (TreeNode) expandedTreePathObject;
	if (expandedTreeNode.getChildCount() == 1) {
		final TreeNode descendantTreeNode = expandedTreeNode.getChildAt(0);

		if (descendantTreeNode.isLeaf()) {
			return;
		}

		final TreePath nextTreePath = treePath.pathByAddingChild(descendantTreeNode);
		tree.expandPath(nextTreePath);
	}
}
 

/**
 * 复制相似路径节点键值对.
 * @param treeNode
 * @return 
 */
public String copySimilarPathKeyValue(TreeNode treeNode){
    String str = "";
    String key = Kit.pstr(treeNode.toString())[1];
    TreeNode node = treeNode.getParent();
    if(node==null) return "";
    node = node.getParent();
    if(node == null) return "";
    int count = node.getChildCount();
    int size = 0;
    for(int i = 0; i < count; i++){
        TreeNode child = node.getChildAt(i);
        if(child==null) continue;
        size = child.getChildCount();
        for(int i2 = 0; i2 < size; i2++){
            TreeNode tmp = child.getChildAt(i2);
            if(tmp==null)continue;
            String arr[] = Kit.pstr(tmp.toString());
            if(key!=null && key.equals(arr[1])){
                str += arr[2] + "\n";
            }
        }
    }
    return str;
}
 

protected static DefaultMutableTreeNode findNode(TreeNode node,
		Object userObject) {
	if (node instanceof DefaultMutableTreeNode) {
		Object obj = ((DefaultMutableTreeNode) node).getUserObject();
		if (obj == null && userObject == null)
			return (DefaultMutableTreeNode) node;
		if (obj.equals(userObject))
			return (DefaultMutableTreeNode) node;
	}
	for (int a = 0; a < node.getChildCount(); a++) {
		TreeNode child = node.getChildAt(a);
		DefaultMutableTreeNode hit = findNode(child, userObject);
		if (hit != null)
			return hit;
	}
	return null;
}
 

private boolean areSiblingsUnchecked() {
    TreeNode parent = getParent();

    for (int i = 0; i < parent.getChildCount(); i++) {
        TreeNode node = parent.getChildAt(i);

        if (node == this) {
            continue;
        }

        if (!(node instanceof CheckTreeNode) || (((CheckTreeNode) node).getCheckState() != STATE_UNCHECKED)) {
            return false;
        }
    }

    return true;
}
 

private boolean areSiblingsFullyChecked() {
    TreeNode parent = getParent();

    for (int i = 0; i < parent.getChildCount(); i++) {
        TreeNode node = parent.getChildAt(i);

        if (node == this) {
            continue;
        }

        if (!(node instanceof CheckTreeNode) || (((CheckTreeNode) node).getCheckState() != STATE_CHECKED)) {
            return false;
        }
    }

    return true;
}
 

protected void saveMenus(TreeNode e) {
  if (e instanceof MenuEditor)
    getProjectLibrary().activityBag.addActivity(((MenuEditor) e).getMenu());
  for (int i = 0; i < e.getChildCount(); i++)
    if (e.getChildAt(i) instanceof MenuEditor)
      saveMenus(e.getChildAt(i));
}
 

private void expandAll(JTree tree, TreePath path) {
	TreeNode node = (TreeNode) path.getLastPathComponent();
	for (int i = 0; i < node.getChildCount(); i++) {
		TreeNode child = node.getChildAt(i);
		expandAll(tree, path.pathByAddingChild(child));
	}
	tree.expandPath(path);
}
 

public static void getExpandedPaths(JTree tree, TreePath path, List<TreePath> list) {
	if (tree.isExpanded(path)) {
		list.add(path);

		TreeNode node = (TreeNode) path.getLastPathComponent();
		for (int i = node.getChildCount() - 1; i >= 0; i--) {
			TreeNode n = node.getChildAt(i);
			TreePath child = path.pathByAddingChild(n);
			getExpandedPaths(tree, child, list);
		}
	}
}
 

private static TreeNode getFirstChildOfType(TreeNode parent, final Class type) {
  final int childCount = parent.getChildCount();
  for (int idx = 0; idx < childCount; idx++) {
    final TreeNode child = parent.getChildAt(idx);
    if (type.isAssignableFrom(child.getClass())) {
      return child;
    }
    final TreeNode firstChildOfType = getFirstChildOfType(child, type);
    if (firstChildOfType != null) {
      return firstChildOfType;
    }
  }
  return null;
}
 

private static String getPosition(IOSTreeNode node) {
    int count = 0;
    TreeNode parent = node.getParent();
    String nodeName = node.getAttribute("tag");
    for (int i = 0; i < parent.getChildCount(); i++) {
        IOSTreeNode currNode = (IOSTreeNode) parent.getChildAt(i);
        if (currNode.getAttribute("tag").equals(nodeName)) {
            count++;
            if (currNode.equals(node)) {
                return nodeName + "[" + count + "]";
            }
        }
    }
    return nodeName;
}
 

private static String getPosition(AndroidTreeNode node) {
    int count = 0;
    TreeNode parent = node.getParent();
    String nodeName = node.getClassName();
    for (int i = 0; i < parent.getChildCount(); i++) {
        AndroidTreeNode currNode = (AndroidTreeNode) parent.getChildAt(i);
        if (currNode.getClassName().equals(nodeName)) {
            count++;
            if (currNode.equals(node)) {
                return nodeName + "[" + count + "]";
            }
        }
    }
    return nodeName;
}
 

private List<StoreEntryNode> getSelectedNodes(TreeNode node) {
    List<StoreEntryNode> ret = new LinkedList<StoreEntryNode>();
    int count = node.getChildCount();
    for (int i = 0; i < count; i++) {
        TreeNode child = node.getChildAt(i);
        if(child instanceof StoreEntryNode) {
            StoreEntryNode sen = (StoreEntryNode) child;
            if(sen.isSelected()) {
                ret.add(sen);
            }
        }
        ret.addAll(getSelectedNodes(child));
    }
    return ret;
}
 

public TreeNode getChildAt(TreeNode parent, int index) {
    return parent.getChildAt(index);
}
 

/**
 * Returns the child of <code>parent</code> at index <code>index</code> in the parent's child array.
 * <code>parent</code> must be a node previously obtained from this data source. This should not return
 * <code>null</code> if <code>index</code> is a valid index for <code>parent</code> (that is <code>index >= 0 && index
 * < getChildCount(parent</code>)).
 *
 * @param parent a node in the tree, obtained from this data source
 * @param index  the index from where to read the child.
 * @return the child of <code>parent</code> at index <code>index</code>
 */
public Object getChild( final Object parent, final int index ) {
  final TreeNode node = (TreeNode) parent;
  return node.getChildAt( index );
}
 

/**
 * Support the subscript operator for TreeNode.
 *
 * @param self  a TreeNode
 * @param index the index of the child node to get
 * @return the child node at the given index
 * @since 1.6.4
 */
public static TreeNode getAt(TreeNode self, int index) {
    return self.getChildAt(index);
}