/** * Returns whether the given node is visible, e.g. all it's parents are expanded. * * @param node * The node to inspect * @return true if the node is visible, false otherwise */ private boolean isNodeVisible(Object node) { if (node == null) { return false; } Object parent = getParentNode(node); while (parent != null) { if (isNodeExpanded(parent) == false) { return false; } parent = getParentNode(parent); } return true; }
/** * Sets whether the root of the tree should be visible. * * @param rootLess * whether the root should be visible */ public void setRootLess(boolean rootLess) { if (this.rootLess != rootLess) { this.rootLess = rootLess; invalidateAll(); // if the tree is in rootless mode, make sure the root node is // expanded if (rootLess == true && getModelObject() != null) { getTreeState().expandNode(getModelObject().getRoot()); } } }
/** * Convenience method that updates changed portions on tree. You can call this method during * Ajax response, where calling {@link #updateTree(AjaxRequestTarget)} * would be appropriate, but you don't have the AjaxRequestTarget instance. However, it is also * safe to call this method outside Ajax response. */ public final void updateTree() { Optional<AjaxRequestTarget> target = getRequestCycle().find(AjaxRequestTarget.class); if (target.isPresent() == false) { throw new WicketRuntimeException( "No AjaxRequestTarget available to execute updateTree(ART target)"); } updateTree(target.get()); }
/** * Initialize the component. */ private void init() { setVersioned(false); // we need id when we are replacing the whole tree setOutputMarkupId(true); // create container for tree items itemContainer = new TreeItemContainer("i"); add(itemContainer); checkModel(); }
if (parentItem != null && isNodeVisible(parentNode)) int nodeChildCount = getChildCount(parentNode); for (int i = 0; wasLeaf && i < nodeChildCount; i++) wasLeaf = eventChildren.contains(getChildAt(parentNode, i)); boolean addingToHiddedRoot = parentItem.getParentItem() == null && isRootLess(); Object grandparentNode = getParentNode(parentNode); boolean addingToHiddedRootSon = grandparentNode != null && getParentNode(grandparentNode) == null && isRootLess(); invalidateNodeWithChildren(grandparentNode); invalidateNode(parentNode, true); getTreeState().expandNode(parentNode); if (isNodeExpanded(parentNode)) for (int i = 0; i < eventChildren.size(); ++i) TreeItem item = newTreeItem(parentItem, eventChildren.get(i), childLevel); itemContainer.add(item); markTheLastButOneChildDirty(parentItem, item);
@Override public void onClick(AjaxRequestTarget target) { MenuTreeNode selected = getSelected(); MenuTreeNode parent = (MenuTreeNode) tree.getParentNode(selected); boolean editing = tg.isItemEdited(new Model<MenuTreeNode>(selected)); int index = parent.getChildren().indexOf(selected); treeModel.nodeDeleted(tree, selected); parent.getEntry().getChildren().remove(selected.getEntry()); if (index > parent.getChildren().size() - 1) { --index; } MenuTreeNode newSelected = (MenuTreeNode) ((index >= 0) ? parent.getChildren().get(index) : parent); if (newSelected.equals(treeModel.getRoot()) == false) { tree.getTreeState().selectNode(newSelected, true); tg.setItemEdit(new Model<MenuTreeNode>(newSelected), editing); } tree.updateTree(target); }
List<Object> selection = new ArrayList<Object>(getTreeState().getSelectedNodes()); List<Object> removed = Arrays.asList(removalEvent.getChildren()); for (Object selectedNode : selection) getTreeState().selectNode(selectedNode, false); if (parentItem != null && isNodeVisible(parentNode)) if (isNodeExpanded(parentNode)) if (itemToDelete != null) markTheLastButOneChildDirty(parentItem, itemToDelete); visitItemChildren(itemToDelete, new IItemCallback() removeItem(itemToDelete); invalidateNode(parentNode, true);
onBeforeAttach(); checkModel(); clearAllItem(); rebuildDirty(); Object rootNode = getModelObject().getRoot(); if (rootNode != null) if (isRootLess()) rootItem = newTreeItem(null, rootNode, -1); rootItem = newTreeItem(null, rootNode, 0); buildItemChildren(rootItem);
@Override public void onClick(AjaxRequestTarget target) { ChildEntry entry = new ChildEntry(getSelected().getEntry()); entry.setTitle(getString("newEntry")); getSelected().getEntry().getChildren().add(entry); MenuTreeNode node = new MenuTreeNode(entry); treeModel.nodeInserted(tree, getSelected(), node); tree.getTreeState().selectNode(node, true); tree.updateTree(target); }
tg.setClickRowToDeselect(true); tg.setSelectToEdit(false); tree.setRootLess(true); tg.setContentHeight(34, SizeUnit.EM); tree.getTreeState().expandAll(); tree.getTreeState().setAllowSelectMultiple(false);
checkModel(); addComponent(target, this); String js = getElementsDeleteJavaScript(); buildItemChildren(item); addComponent(target, item); updated();
/** * @see MarkupContainer#onDetach() */ @Override public void onDetach() { attached = false; super.onDetach(); if (getTreeState() instanceof IDetachable) { ((IDetachable)getTreeState()).detach(); } }
public Object getParent(AbstractTree tree, Object node) { return tree.getParentNode(node); }
/** * Returns whether the given node is expanded. * * @param node * The node to inspect * @return true if the node is expanded, false otherwise */ protected final boolean isNodeExpanded(Object node) { // In root less mode the root node is always expanded if (isRootLess() && rootItem != null && rootItem.getModelObject().equals(node)) { return true; } return getTreeState().isNodeExpanded(node); }
protected void configureGrid(TreeGrid<NodePickerTreeModel, JcrTreeNode, String> grid) { grid.getTree().setRootLess(true); grid.setClickRowToSelect(true); grid.setContentHeight(18, SizeUnit.EM); }
/** * Builds the children for given TreeItem. It recursively traverses children of it's TreeNode * and creates TreeItem for every visible TreeNode. * * @param item * The parent tree item */ private void buildItemChildren(TreeItem item) { List<TreeItem> items; // if the node is expanded if (isNodeExpanded(item.getModelObject())) { // build the items for children of the items' treenode. items = buildTreeItems(item, nodeChildren(item.getModelObject()), item.getLevel() + 1); } else { // it's not expanded, just set children to an empty list items = new ArrayList<TreeItem>(0); } item.setChildren(items); }
/** * Builds (recursively) TreeItems for the given Iterator of TreeNodes. * * @param parent * @param nodes * The nodes to build tree items for * @param level * The current level * @return List with new tree items */ private List<TreeItem> buildTreeItems(TreeItem parent, Iterator<Object> nodes, int level) { List<TreeItem> result = new ArrayList<TreeItem>(); // for each node while (nodes.hasNext()) { Object node = nodes.next(); // create tree item TreeItem item = newTreeItem(parent, node, level); itemContainer.add(item); // builds it children (recursively) buildItemChildren(item); // add item to result result.add(item); } return result; }
/** * Rebuilds children of every item in dirtyItems that needs it. This method is called for * non-partial update. */ private void rebuildDirty() { // go through dirty items for (TreeItem item : dirtyItems) { // item children need to be rebuilt if (item.getChildren() == null) { buildItemChildren(item); } } }
@Override public void onClick(AjaxRequestTarget target) { MenuTreeNode selected = getSelected(); int index = getIndex(selected); if (index > 0) { boolean editing = tg.isItemEdited(new Model<MenuTreeNode>(selected)); MenuTreeNode parent = (MenuTreeNode) tree.getParentNode(selected); treeModel.nodeDeleted(tree, selected); parent.getEntry().getChildren().remove(selected.getEntry()); parent.getEntry().getChildren().add(index - 1, (ChildEntry) selected.getEntry()); treeModel.nodeInserted(tree, parent, selected); tree.getTreeState().selectNode(selected, true); tg.setItemEdit(new Model<MenuTreeNode>(selected), editing); tree.updateTree(target); } target.add(links); }
@Override public void onClick(AjaxRequestTarget target) { MenuTreeNode parent = (MenuTreeNode) treeModel.getRoot(); ChildEntry entry = new ChildEntry(parent.getEntry()); entry.setTitle(getString("newEntry")); parent.getEntry().getChildren().add(entry); MenuTreeNode node = new MenuTreeNode(entry); treeModel.nodeInserted(tree, parent, node); tree.getTreeState().selectNode(node, true); tree.updateTree(target); } });