/** Returns the {@link Treechildren} associated with this * {@link Treerow}. * In other words, it is {@link Treeitem#getTreechildren} of * {@link #getParent}. * @since 2.4.1 * @see Treechildren#getLinkedTreerow */ public Treechildren getLinkedTreechildren() { final Component parent = getParent(); return parent != null ? ((Treeitem) parent).getTreechildren() : null; }
/** Returns the number of child {@link Treeitem} * including all descendants. The same as {@link #getItems}.size(). * <p>Note: the performance is no good. */ public int getItemCount() { int sz = 0; for (Iterator it = getChildren().iterator(); it.hasNext(); ++sz) { final Treeitem item = (Treeitem) it.next(); final Treechildren tchs = item.getTreechildren(); if (tchs != null) sz += tchs.getItemCount(); } return sz; }
/** Called by {@link Treeitem} when is added to a tree. */ /*package*/ void onTreeitemAdded(Treeitem item) { fixNewChild(item); onTreechildrenAdded(item.getTreechildren()); }
/** * Unload the tree item * <p>To load the tree item, with * {@link Tree#renderItem(Treeitem)}, {@link Tree#renderItem(Treeitem, Object)}, or {@link Tree#renderItems(java.util.Set)} * * @since 3.0.4 */ public void unload() { if (isLoaded()) { //Clean its children if (getTreechildren() != null) getTreechildren().getChildren().clear(); //Set the load status to unloaded setLoaded(false); //Change the "+/-" sign icon setOpen(false); } }
/** Called by {@link Treeitem} when is removed from a tree. */ /*package*/ void onTreeitemRemoved(Treeitem item) { boolean fixSel = false; if (item.isSelected()) { _selItems.remove(item); fixSel = _sel == item; if (fixSel && !_multiple) _sel = null; } onTreechildrenRemoved(item.getTreechildren()); if (fixSel) fixSelected(); }
/** Sorts the treechildren. * @since 5.0.6 */ @SuppressWarnings("unchecked") private static void sort0(Treechildren treechildren, Comparator cmpr) { if (treechildren == null) return; Components.sort(treechildren.getChildren(), cmpr); for (Iterator it = treechildren.getChildren().iterator(); it.hasNext();) { Treeitem item = (Treeitem) it.next(); sort0(item.getTreechildren(), cmpr); } }
/** @param parent either a Tree or Treeitem instance. */ private static Treechildren treechildrenOf(Component parent) { Treechildren tc = (parent instanceof Tree) ? ((Tree) parent).getTreechildren() : ((Treeitem) parent).getTreechildren(); if (tc == null) { tc = new Treechildren(); tc.setParent(parent); } return tc; }
private static boolean shallVisitTree(Tree tree, Component child) { final Treeitem item = (Treeitem) child; int count = item.isOpen() && item.getTreechildren() != null ? item.getTreechildren().getVisibleItemCount() : 0; Integer visited = (Integer) tree.getAttribute(Attributes.VISITED_ITEM_COUNT); final Paginal pgi = tree.getPaginal(); final int ofs = pgi.getActivePage() * pgi.getPageSize(); int visit = visited != null ? visited.intValue() + 1 : 1; boolean shoulbBeVisited = ofs < visit + count; if (visited == null) visited = new Integer(shoulbBeVisited ? 1 : count + 1); else visited = new Integer(visited.intValue() + (shoulbBeVisited ? 1 : count + 1)); Integer total = (Integer) tree.getAttribute(Attributes.VISITED_ITEM_TOTAL); if (total == null) total = new Integer(count + 1); else total = new Integer(total.intValue() + count + 1); tree.setAttribute(Attributes.VISITED_ITEM_COUNT, visited); tree.setAttribute(Attributes.VISITED_ITEM_TOTAL, total); return shoulbBeVisited; }
/** * Return the Tree or Treeitem component by a path, or null if corresponding * Treeitem is not instantiated (i.e., rendered) yet. It returns this tree * if the given node is the root node. (i.e., {@link TreeModel#getRoot}). * @since 6.0.0 */ protected Component getChildByPath(int[] path) { if (path.length == 0) return this; // return Tree Treeitem item = getChildTreeitem(getTreechildren(), path[0]); for (int j = 1; j < path.length && item != null; j++) item = getChildTreeitem(item.getTreechildren(), path[j]); return item; }
if (ti.getTreechildren() != null) { children = ti.getTreechildren().getChildren(); } else { if (i != path.length - 1) {
} else if (item.isRealVisible()) { count++; Treechildren chdrn = item.getTreechildren(); if (inclusive && item.isOpen() && chdrn != null) { count += chdrn.getVisibleItemCount();
final Treeitem item = (Treeitem) cmp; if (item.isRealVisible()) { int count = item.isOpen() && item.getTreechildren() != null ? item.getTreechildren().getVisibleItemCount() : 0; boolean shoulbBeVisited = data[1] < data[2] + 1 + count; data[2] += (shoulbBeVisited ? 1 : count + 1);
public void render(Component comp, Writer out) throws IOException { final Treeitem self = (Treeitem) comp; final SmartWriter wh = new SmartWriter(out); final Tree tree = self.getTree(); if ("paging".equals(tree.getMold())) { if (self.isVisible() && ZulFns.shallVisitTree(tree, self)) { if (ZulFns.shallRenderTree(tree)) wh.write(self.getTreerow()); if (self.isOpen()) wh.write(self.getTreechildren()); } } else { wh.write(self.getTreerow()).write(self.getTreechildren()); } } }
private void renderChangedItem(Treeitem item, Object node) { /* * After modified the node in tree model, if node is leaf, * its treechildren is needed to be dropped. */ if (_model != null) { Treechildren tc = item.getTreechildren(); if (_model.isLeaf(node)) { if (tc != null) tc.detach(); //just in case } else { if (tc == null) { tc = new Treechildren(); tc.setParent(item); } } final Renderer renderer = new Renderer(); try { renderer.renderChangedItem(item, node, item.getIndex()); //re-render } catch (Throwable ex) { renderer.doCatch(ex); } finally { renderer.doFinally(); } } }
if (item.getTreerow() != null) // just in case item.getTreerow().detach(); Treechildren tc = item.getTreechildren(); _renderer.render(item, node, index); Object newTreeitem = item.getAttribute(Attributes.MODEL_RENDERAS);
/** Note: it doesn't call render doCatch/doFinally */ private void renderItem0(Renderer renderer, Treeitem item, Object node) throws Throwable { if (item.isLoaded()) //all direct children are loaded return; /* * After modified the node in tree model, if node is leaf, * its treechildren is needed to be dropped. */ Treechildren tc = item.getTreechildren(); if (_model.isLeaf(node)) { if (tc != null) tc.detach(); //just in case //no children to render //Note item already rendered, so no need: //renderer.render(item, node); } else { if (tc != null) tc.getChildren().clear(); //just in case else { tc = new Treechildren(); tc.setParent(item); } renderChildren(renderer, tc, node); } Object v = item.getAttribute(Attributes.MODEL_RENDERAS); if (v != null) //a new item is created to replace the existent one (item = (Treeitem) v).setOpen(false); item.setLoaded(true); }
protected void redrawChildren(Writer out) throws IOException { Tree tree = getTree(); if (!tree.inPagingMold()) { super.redrawChildren(out); } else if (isRealVisible() && shallVisitTree(tree, this)) { if (shallRenderTree(tree)) { ComponentCtrl child = getTreerow(); if (child != null) child.redraw(out); } boolean close = !isOpen(); ComponentCtrl child = getTreechildren(); if (child != null) { if (close) ((Component) child).setAttribute(Attributes.SHALL_RENDER_ITEM, Boolean.TRUE); child.redraw(out); if (close) ((Component) child).removeAttribute(Attributes.SHALL_RENDER_ITEM); } } }
if (!isLeaf && ti.getTreechildren() == null) { Treechildren tc = new Treechildren(); tc.setParent(ti);