/** * @see MarkupContainer#remove(Component) */ @Override public TreeItemContainer remove(Component component) { // when a treeItem is removed, remove reference to it from // nodeToItemMAp if (component instanceof TreeItem) { nodeToItemMap.remove(((TreeItem)component).getModelObject()); } super.remove(component); return this; }
/** * Marks the last but one visible child node of the given item as dirty, if give child is the * last item of parent. * * We need this to refresh the previous visible item in case the inserted / deleted item was * last. The reason is that the line shape of previous item changes from L to |- . * * @param parent * @param child */ private void markTheLastButOneChildDirty(TreeItem parent, TreeItem child) { if (parent.getChildren().indexOf(child) == parent.getChildren().size() - 1) { // go through the children backwards, start at the last but one // item for (int i = parent.getChildren().size() - 2; i >= 0; --i) { TreeItem item = parent.getChildren().get(i); // invalidate the node and it's children, so that they are // redrawn invalidateNodeWithChildren(item.getModelObject()); } } }
/** * Returns parent node of given node. * * @param node * @return parent node */ public Object getParentNode(Object node) { TreeItem item = nodeToItemMap.get(node); if (item == null) { return null; } else { TreeItem parent = item.getParentItem(); return parent == null ? null : parent.getModelObject(); } }
invalidateNode(rootItem.getModelObject(), true);
@Override protected void onDetach() { super.onDetach(); Object object = getModelObject(); if (object instanceof IDetachable) { ((IDetachable)object).detach(); } if (isRenderChildren()) { // visit every child visitItemChildren(this, new IItemCallback() { @Override public void visitItem(TreeItem item) { item.detach(); } }); } // children are rendered, clear the flag setRenderChildren(false); }
/** * 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); }
/** * 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); }
@Override public void visitItem(TreeItem item) { invalidateNode(item.getModelObject(), false); } });