javafx.scene.control.TreeItem#getChildren ( )源码实例Demo

/**
 * Cleanup the tree.
 */
@FxThread
private void cleanup(@NotNull TreeItem<ResourceElement> treeItem) {

    var element = treeItem.getValue();
    if (element instanceof FileResourceElement || element instanceof LoadingResourceElement) {
        return;
    }

    var children = treeItem.getChildren();

    for (int i = children.size() - 1; i >= 0; i--) {
        cleanup(children.get(i));
    }

    if (children.isEmpty() && treeItem.getParent() != null) {
        var parent = treeItem.getParent();
        var parentChildren = parent.getChildren();
        parentChildren.remove(treeItem);
    }
}
 

private void removeForNode(final TreeItem<SVNode> treeItem) {
    if (treeItem != null) {
        final List<TreeItem<SVNode>> treeItemChildren = treeItem.getChildren();
        if (treeItemChildren != null) {
            /**
             * Do not use directly the list as it will suffer concurrent
             * modifications
             */
            @SuppressWarnings("unchecked") final TreeItem<SVNode> children[] = treeItemChildren.toArray(new TreeItem[treeItemChildren.size()]);
            for (int i = 0; i < children.length; i++) {
                removeForNode(children[i]);
            }
        }

        // This does not seem to delete the TreeItem from the tree -- only
        // moves
        // it up a level visually
        /**
         * I don't know why this protection is needed
         */
        if (treeItem.getParent() != null) {
            treeItem.getParent().getChildren().remove(treeItem);
        }
        treeViewData.remove(treeItem.getValue());
    }
}
 

protected TreeItem<FileInformation> getChild(TreeItem<FileInformation> item, String name) {
    if (item == null) {
        return null;
    }
    for (TreeItem<FileInformation> child : item.getChildren()) {
        if (name.equals(child.getValue().getFileName())) {
            return child;
        }
    }
    FileInformation childInfo = new FileInformation();
    childInfo.setFileName(name);
    final TreeItem<FileInformation> childItem = new TreeItem(childInfo);
    childItem.setExpanded(true);
    childInfo.getSelectedProperty().addListener(new ChangeListener<Boolean>() {
        @Override
        public void changed(ObservableValue<? extends Boolean> ov,
                Boolean oldItem, Boolean newItem) {
            if (!isSettingValues) {
                treeItemSelected(childItem, newItem);
            }
        }
    });
    item.getChildren().add(childItem);
    return childItem;
}
 

/**
 Checks if the given start TreeItem contains the searching {@link TreeItem} as a descendant. Checks are done recursively.
 
 @param startItem where to start searching
 @param searchingFor TreeItem to look for
 @return if startItem has the descendant searchingFor
 */
public static boolean hasDescendant(@NotNull TreeItem<?> startItem, @NotNull TreeItem<?> searchingFor) {
	if (startItem.equals(searchingFor)) {
		return true;
	}
	if (startItem.getChildren().size() == 0) {
		return false;
	}
	for (TreeItem<?> item : startItem.getChildren()) {
		boolean contains = hasDescendant(item, searchingFor);
		if (contains) {
			return true;
		}
		
	}
	
	return false;
}
 

/**
 * Fill the tree item.
 *
 * @param item the tree item.
 */
@FxThread
private void fill(@NotNull final TreeItem<VirtualResourceElement<?>> item) {

    final VirtualResourceElement<?> element = item.getValue();
    if(!element.hasChildren()) {
        return;
    }

    final ObservableList<TreeItem<VirtualResourceElement<?>>> items = item.getChildren();

    final Array<VirtualResourceElement<?>> children = element.getChildren();
    children.sort(NAME_COMPARATOR);
    children.forEach(child -> items.add(new TreeItem<>(child)));

    items.forEach(this::fill);
}
 

@SuppressWarnings("unchecked")
private String getTreeTableItemText(TreeTableView<?> treeTableView, TreeItem<?> lastPathComponent) {
    @SuppressWarnings("rawtypes")
    TreeTableColumn treeTableColumn = treeTableView.getTreeColumn();
    if (treeTableColumn == null) {
        treeTableColumn = treeTableView.getColumns().get(0);
    }
    ObservableValue<?> cellObservableValue = treeTableColumn.getCellObservableValue(lastPathComponent);
    String original = cellObservableValue.getValue().toString();
    String itemText = original;
    int suffixIndex = 0;
    TreeItem<?> parent = lastPathComponent.getParent();
    if (parent == null)
        return itemText;
    ObservableList<?> children = parent.getChildren();
    for (int i = 0; i < children.indexOf(lastPathComponent); i++) {
        TreeItem<?> child = (TreeItem<?>) children.get(i);
        cellObservableValue = treeTableColumn.getCellObservableValue(child);
        String current = cellObservableValue.getValue().toString();
        if (current.equals(original)) {
            itemText = String.format("%s(%d)", original, ++suffixIndex);
        }
    }
    return itemText;
}
 

public void checkSelection(TreeItem<FileInformation> item) {
    try {
        if (item == null || item.getValue() == null) {
            return;
        }
        FileInformation info = item.getValue();
        if (info.isSelected() && "file".equals(info.getFileType())) {
            selected.add(info.getFileName());
        }
        List<TreeItem<FileInformation>> children = item.getChildren();
        if (children == null || children.isEmpty()) {
            return;
        }
        for (TreeItem<FileInformation> child : children) {
            checkSelection(child);
        }
    } catch (Exception e) {
        logger.error(e.toString());
    }
}
 

protected void addNode(TreeItem<Text> node, GeographyCode parent, GeographyCode child) {
    if (node == null || parent == null || child == null) {
        return;
    }
    if (node.getValue().getUserData() != null) {
        long current = (long) (node.getValue().getUserData());
        if (current == parent.getGcid()) {
            Text childNode = new Text(child.getName());
            childNode.setOnMouseClicked((MouseEvent event) -> {
                userController.codeSelected(child);
            });
            childNode.setUserData(child.getGcid());
            TreeItem<Text> codeItem = new TreeItem(childNode);
            node.getChildren().add(codeItem);
            node.setExpanded(true);
            return;
        }
    }
    if (node.isLeaf()) {
        return;
    }
    for (TreeItem<Text> subNode : node.getChildren()) {
        addNode(subNode, parent, child);
    }
}
 

public void setSelection(TreeItem<ConditionNode> item) {
    try {
        if (item == null || !(item instanceof CheckBoxTreeItem)) {
            return;
        }
        CheckBoxTreeItem<ConditionNode> citem = (CheckBoxTreeItem<ConditionNode>) item;
        ConditionNode node = item.getValue();
        if (selectedTitles.contains(node.getTitle())) {
            citem.setSelected(true);
            return;
        } else if (item.isLeaf()) {
            return;
        }
        for (TreeItem<ConditionNode> child : item.getChildren()) {
            setSelection(child);
        }
    } catch (Exception e) {
        logger.debug(e.toString());
    }
}
 

private TreeItem<IconNode> findIconNode(TreeItem<IconNode> node, String value) {
    final IconNode iconNode = node.getValue();
    if (iconNode.iconExists(value)) {
        return node;
    } else {
        for (TreeItem<IconNode> child : node.getChildren()) {
            final TreeItem<IconNode> result = findIconNode(child, value);
            if (result != null) {
                return result;
            }
        }
        return null;
    }

}
 

private void dumpTree(TreeItem<AlarmTreeItem<?>> item)
{
	final ObservableList<TreeItem<AlarmTreeItem<?>>> children = item.getChildren();
	System.out.printf("item: %s , has %d children.\n", item.getValue().getName(), children.size());
	for (final TreeItem<AlarmTreeItem<?>> child : children)
	{
		System.out.println(child.getValue().getName());
		dumpTree(child);
	}
}
 

private ArrayList<ModFunc> findUnfilteredFunctions() {
    ObservableList<TreeItem<ModFunc>> filteredTreeModules = rootProperty.get().getChildren();
    ArrayList<ModFunc> funs = new ArrayList<>();
    for (TreeItem<ModFunc> treeItem : filteredTreeModules) {
        for (TreeItem<ModFunc> modFunc : treeItem.getChildren()) {
            if(!modFunc.getValue().isModuleInfo()) {
                funs.add(modFunc.getValue());
            }
        }
    }
    return funs;
}
 

private void assertTreeDoesntContain(final TreeItem<FileInfo> item, final Path file)
{
    final Path dir = item.getValue().file.toPath();
    logger.log(Level.FINE, () -> "Does " + dir + " still contain " + file + "?");
    if (! file.startsWith(dir))
    {
        logger.log(Level.FINE, "Can't!");
        return;
    }

    final int dir_len = dir.getNameCount();
    final File sub = new File(item.getValue().file, file.getName(dir_len).toString());
    for (TreeItem<FileInfo> child : item.getChildren())
        if (sub.equals(child.getValue().file))
        {
            // Found file or sub path to it..
            if (sub.isDirectory())
                assertTreeDoesntContain(child, file);
            else
            {   // Found the file still listed as a child of 'item',
                // so refresh 'item'
                logger.log(Level.FINE, () -> "Forcing refresh of " + dir + " to hide " + sub);
                Platform.runLater(() -> ((FileTreeItem)item).forceRefresh());
            }
            return;
        }

    logger.log(Level.FINE, "Not found, all good");
}
 

/**
 * Fill the node.
 */
@FxThread
private void fill(@NotNull TreeItem<ResourceElement> treeItem) {

    var element = treeItem.getValue();
    var extensionFilter = getExtensionFilter();

    if (!element.hasChildren(extensionFilter, isOnlyFolders())) {
        return;
    }

    var items = treeItem.getChildren();

    if (isLazyMode()) {
        items.add(new TreeItem<>(LoadingResourceElement.getInstance()));
    } else {

        var children = element.getChildren(extensionFilter, isOnlyFolders());
        if (children == null) {
            return;
        }

        children.sort(NAME_COMPARATOR);
        children.forEach(child -> items.add(new TreeItem<>(child)));

        items.forEach(this::fill);
    }
}
 

private void setCurrentNodePath(String value) {
    if (value == null) return;
    String[] parts = value.split(Pattern.quote(DELIMITER));
    TreeItem<ConfigNode> current = deviceTree.getRoot();
    for (String part : parts) {
        for (TreeItem child : current.getChildren()) {
            if (child.toString().equals(part)) {
                current = child;
            }
        }
    }
    deviceTree.getSelectionModel().select(current);
}
 

public void checkSelection(TreeItem<ConditionNode> item) {
    try {
        if (item == null || !(item instanceof CheckBoxTreeItem)) {
            return;
        }
        CheckBoxTreeItem<ConditionNode> citem = (CheckBoxTreeItem<ConditionNode>) item;
        ConditionNode node = item.getValue();
        if (citem.isSelected()) {
            if (finalConditions == null || finalConditions.isBlank()) {
                if (node.getCondition() == null || node.getCondition().isBlank()) {
                    finalConditions = "";
                } else {
                    finalConditions = " ( " + node.getCondition() + ") ";
                }
            } else {
                if (node.getCondition() != null && !node.getCondition().isBlank()) {
                    finalConditions += " OR ( " + node.getCondition() + " ) ";
                }
            }

            if (finalTitle == null || finalTitle.isBlank()) {
                finalTitle = "\"" + node.getTitle() + "\"";
            } else {
                finalTitle += " + \"" + node.getTitle() + "\"";
            }
            if (!selectedTitles.contains(node.getTitle())) {
                selectedTitles.add(node.getTitle());
            }
            return;
        } else if (item.isLeaf() || !citem.isIndeterminate()) {
            return;
        }
        for (TreeItem<ConditionNode> child : item.getChildren()) {
            checkSelection(child);
        }
    } catch (Exception e) {
        logger.debug(e.toString());
    }
}
 

private void recurseModFuncItems(TreeItem<ModFunc> item, HashSet<ModFunc> funcs) {
    if(item == null)
        return;
    if(item.getValue() == null || (!item.getValue().isModule() && !item.getValue().isModuleInfo()))
        funcs.add(item.getValue());

    for (TreeItem<ModFunc> childItem : item.getChildren()) {
        recurseModFuncItems(childItem, funcs);
    }
}
 

private void addAllParentTreeItem(TreeItem<Object> root, List<TreeItem<Object>> parentItems) {
    ObservableList<TreeItem<Object>> children = root.getChildren();
    for (TreeItem<Object> treeItem : children) {
        if (treeItem.getChildren().size() != 0) {
            parentItems.add(treeItem);
        } else {
            addAllParentTreeItem(treeItem, parentItems);
        }
    }
}
 

public void expandNone(TreeItem<ConditionNode> item) {
    try {
        if (item == null || item.isLeaf()) {
            return;
        }
        item.setExpanded(true);
        for (TreeItem<ConditionNode> child : item.getChildren()) {
            expandNode(child);
        }
    } catch (Exception e) {
        logger.debug(e.toString());
    }
}
 

private void signalDeletionRecursively(TreeItem<T> node, I initiator) {
    for(TreeItem<T> child: node.getChildren()) {
        signalDeletionRecursively(child, initiator);
    }
    reporter.reportDeletion(getPath(), getPath().relativize(getProjector().apply(node.getValue())), initiator);
}