private int count(TreeItem<?> node) { if (node == null) { return 0; } int count = 1; if (node.getValue() == null || (node.getValue() != null && node.getValue() .getClass() .equals(RecursiveTreeObject.class))) { count = 0; } for (TreeItem<?> child : node.getChildren()) { count += count(child); } return count; } }
requireNonNull(doc); final TreeItem<DocumentProperty> branch = new TreeItem<>(doc); branch.expandedProperty().bindBidirectional(doc.expandedProperty()); .map(d -> (HasExpandedProperty) d) .map(this::branch) .forEachOrdered(branch.getChildren()::add); .forEach(val -> branch.getChildren() .removeIf(item -> val.equals(item.getValue())) ); .map(d -> (HasExpandedProperty) d) .map(this::branch) .forEachOrdered(branch.getChildren()::add); .map(d -> (DocumentProperty & HasExpandedProperty) d) .map(this::branch) .forEachOrdered(branch.getChildren()::add);
@Override protected boolean handleDisclosureNode(double x, double y) { final TreeItem<S> treeItem = getControl().getTreeTableRow().getTreeItem(); if (!treeItem.isLeaf()) { final Node disclosureNode = getControl().getTreeTableRow().getDisclosureNode(); if (disclosureNode != null) { if (disclosureNode.getBoundsInParent().contains(x + disclosureNode.getTranslateX(), y)) { if (treeItem != null) { treeItem.setExpanded(!treeItem.isExpanded()); } return true; } } } return false; } }
@Override public int getTreeItemLevel(TreeItem<?> node) { final TreeItem<?> root = getRoot(); if (node == null) { return -1; } if (node == root) { return 0; } int level = 0; TreeItem<?> parent = node.getParent(); while (parent != null) { level++; if (parent == root) { break; } // handle group nodes if (parent.getValue() != null && parent.getValue() instanceof RecursiveTreeObject && ((RecursiveTreeObject<?>) parent.getValue()).getGroupedColumn() != null) { level--; } parent = parent.getParent(); } return level; }
private static TreeItem<Object> createTreeItem(Contingency contingency) { TreeItem<Object> contingencyItem = new TreeItem<>(contingency); for (ContingencyElement element : contingency.getElements()) { contingencyItem.getChildren().add(new TreeItem<>(element)); } contingencyItem.setExpanded(true); return contingencyItem; }
TreeItem<String> rootItem = new TreeItem<String>("People"); rootItem.setExpanded(true); for (Person person : data) { TreeItem<String> personLeaf = new TreeItem<String>(person.getFirstName()); boolean found = false; for (TreeItem<String> statusNode : rootItem.getChildren()) { if (statusNode.getValue().equals((!person.getVip() ? "no " : "") + "VIP")) { statusNode.getChildren().add(personLeaf); found = true; break; TreeItem<String> statusNode = new TreeItem<String>((!person.getVip() ? "no " : "") + "VIP"); rootItem.getChildren().add(statusNode); statusNode.getChildren().add(personLeaf);
/** * Construct a tree model from the flat list which then can be set * as selectedCrumb node to be shown * @param crumbs */ public static <T> TreeItem<T> buildTreeModel(@SuppressWarnings("unchecked") T... crumbs){ TreeItem<T> subRoot = null; for (T crumb : crumbs) { TreeItem<T> currentNode = new TreeItem<>(crumb); if(subRoot == null){ subRoot = currentNode; }else{ subRoot.getChildren().add(currentNode); subRoot = currentNode; } } return subRoot; }
TreeItem<OutlineItem> createRec(OutlineItem i) { TreeItem<OutlineItem> l = new TreeItem<Outline.OutlineItem>(i); i.getChildren().addListener( ( Change<? extends OutlineItem> c) -> { List<TreeItem<OutlineItem>> list = new ArrayList<TreeItem<OutlineItem>>(i.getChildren().size()); for( OutlineItem ii : i.getChildren() ) { list.add(l.getChildren().stream().filter( t -> t.getValue() == ii).findFirst().orElse(new TreeItem<>(ii))); } l.getChildren().setAll(list); }); for( OutlineItem c : i.getChildren() ) { l.getChildren().add(createRec(c)); } return l; } }
private ChangeListener<String> setupSearchField(final JFXTreeTableView<TreeTableViewController.Person> tableView) { return (o, oldVal, newVal) -> tableView.setPredicate(personProp -> { final Person person = personProp.getValue(); return person.firstName.get().contains(newVal) || person.lastName.get().contains(newVal) || Integer.toString(person.age.get()).contains(newVal); }); }
private void collapseAll(TreeItem<DisplayWorkflowClassesModel> item) { item.setExpanded(false); for (TreeItem<DisplayWorkflowClassesModel> child : item.getChildren()) { collapseAll(child); } } }
sortOrder.addAll(getSortOrder()); List children = Arrays.asList(originalRoot.getChildren().toArray()); originalRoot.getChildren().clear(); originalRoot.getChildren().setAll(children);
private TreeItem<String> makeTemplateBranch(final String gestureName, final TreeItem<String> parent) { final TreeItem<String> item = new TreeItem<>(gestureName); item.setGraphic(ViewUtilities.iconSetter(Material.SHOW_CHART, IconDim.SMALL)); parent.getChildren().add(item); return item; }
private void selectNode(TreeItem<N> last, List<String> pathList) { last.setExpanded(true); if (!pathList.isEmpty()) { String name = pathList.remove(0); ObservableList<TreeItem<N>> children = last.getChildren(); if (children.size() == 1 && children.get(0).getValue() == null) { boolean found = false; for (TreeItem<N> item : children) { if (treeModel.getName(item.getValue()).equals(name)) { selectNode(item, pathList); found = true;
private TreeItem<N> createCollapsedFolderItem(D folder) { TreeItem<N> item = new TreeItem<>(folder); item.getChildren().setAll(new TreeItem<>()); // dummy leaf item.setExpanded(false); item.expandedProperty().addListener((observable, oldValue, newValue) -> { if (Boolean.TRUE.equals(newValue)) { context.getExecutor().submit(() -> refresh(item)); } }); return item; }
private void validate(TreeTableView<ValidationAndData> tableView){ final TreeItem<ValidationAndData> root = new TreeItem<>(); tableView.setRoot(root); tableView.setShowRoot(false); HashMap<Data,Data> child2parent = this.root.internal().getChildToParentMap(); List<ValidationError> validationErrors= new ArrayList<>(); for (Data data: this.root.internal().collectChildrenDeep()){ TreeItem<ValidationAndData> dataItem = new TreeItem<>(); dataItem.setExpanded(true); data.internal().validateFlat().forEach(validationError->{ validationErrors.add(validationError); TreeItem<ValidationAndData> error =new TreeItem<>(new ValidationAndData(validationError,data,data.internal().getDisplayText())); dataItem.getChildren().add(error); }); if (!dataItem.getChildren().isEmpty()){ dataItem.setValue(new ValidationAndData(null,data,data.internal().getPathFromRoot(child2parent).stream().map(d->d.internal().getDisplayText()).collect(Collectors.joining("/")))); root.getChildren().add(dataItem); } } tableView.getStyleClass().remove("error"); if (!validationErrors.isEmpty()){ tableView.getStyleClass().add("error"); } tableView.getSelectionModel().clearSelection(); dataEditor.reset(); isValid.set(validationErrors.isEmpty()); }
private void remove() { ObservableList<TreeItem<Object>> selectedItems = contingencyTree.getSelectionModel().getSelectedItems(); List<TreeItem<Object>> items = new ArrayList<>(selectedItems); for (TreeItem<Object> item : items) { if (item.getValue() instanceof Contingency) { item.getParent().getChildren().remove(item); } else { Contingency contingency = (Contingency) item.getParent().getValue(); if (contingency.getElements().size() == 1) { // remove the contingency to avoid empty contingencies item.getParent().getParent().getChildren().remove(item.getParent()); } else { ContingencyElement element = (ContingencyElement) item.getValue(); contingency.removeElement(element); item.getParent().getChildren().remove(item); } } } saved.set(false); }
private void initTreeView() { final TreeItem<String> root = new TreeItem<String>("Empty User"); root.setGraphic(ViewUtilities.iconSetter(Material.PERSON, IconDim.SMALL)); this.treeView.setRoot(root); this.treeView.getSelectionModel().selectedItemProperty().addListener((v, oldValue, newValue) -> { if (newValue != null && this.treeView.getTreeItemLevel(newValue) == 2) { this.drawSavedGestureOnCanvas(newValue.getParent(), newValue.getParent().getChildren().indexOf(newValue)); } }); }
private void refreshTreeItem(TreeItem<N> item) { if (item.getValue() instanceof Folder) { item.setExpanded(false); item.setExpanded(true); } }
private ObservableList<TreeItem<String>> buildChildren(TreeItem<String> treeItem) { ObservableList<TreeItem<String>> children = FXCollections.observableArrayList(); children.add(new TreeItem<>(Connections.get().getURL().getHost())); return children; }
public static void expandAll(TreeItem<?> item) { if (item != null && !item.isLeaf()) { item.setExpanded(true); for (final TreeItem<?> child : item.getChildren()) { expandAll(child); } } } }