public void onChildRemoved(Component child) { if (child instanceof Treerow) { _treerow = null; } else if (child instanceof Treechildren) { if (isOpen()) addVisibleItemCount(-_treechildren.getVisibleItemCount()); _treechildren = null; } super.onChildRemoved(child); }
/*package*/ void addVisibleItemCount(int count) { if (count == 0) return; Component parent = getParent(); if (parent instanceof Treeitem) { if (((Treeitem) parent).isOpen()) ((Treeitem) parent).addVisibleItemCount(count); } else if (parent instanceof Tree) ((Tree) parent).addVisibleItemCount(count); _visibleItemCount += count; }
/*package*/ boolean isRealVisible() { if (!isVisible()) return false; Component comp = getParent(); if (comp == null) return true; if (!(comp instanceof Treeitem)) return comp.isVisible(); Treeitem item = (Treeitem) comp; return item.isOpen() && item.isRealVisible(); }
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; }
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; map.put(item, Boolean.TRUE); if (item.isOpen()) { if (!getVisibleItemsDFS(item.getChildren(), map, data)) { return false;
if (!ti.isOpen() && ti.getDesktop() != null) { ti.getChildren().clear(); ti.setRendered(false);
public boolean setVisible(boolean visible) { if (isVisible() != visible) { smartUpdate("visible", visible); int count = isOpen() && _treechildren != null ? _treechildren.getVisibleItemCount() + 1 : 1; if (visible) { boolean result = super.setVisible(visible); addVisibleItemCount(count); return result; } else { addVisibleItemCount(-count); return super.setVisible(visible); } } return visible; }
public Set<? extends Component> getAvailableAtClient() { if (!isCropper()) return null; final Tree tree = getTree(); final Component parent = getParent(); final Execution exe = Executions.getCurrent(); final String attrnm = VISIBLE_ITEM + tree.getUuid(); Map<Treeitem, Boolean> map = cast((Map) exe.getAttribute(attrnm)); if (map == null) { //Test very simple case first since getVisibleItems costly if (parent instanceof Treeitem) { for (Treeitem ti = (Treeitem) parent;;) { if (!ti.isOpen()) return Collections.emptySet(); Component gp = ti.getParent().getParent(); if (!(gp instanceof Treeitem)) break; ti = (Treeitem) gp; } } map = tree.getVisibleItems(); Executions.getCurrent().setAttribute(attrnm, map); } return map.keySet(); //yes, we return all visible items, not just direct children //in other words, we consider the whole tree as a single scope //See also bug 2814504 } }
if (!item.isLoaded() && newItem.isOpen()) Tree.this.renderChildren(this, tc, node); newItem.setLoaded(item.isLoaded());
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()); } } }
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); } } }
protected void renderProperties(org.zkoss.zk.ui.sys.ContentRenderer renderer) throws java.io.IOException { super.renderProperties(renderer); render(renderer, "selected", isSelected()); render(renderer, "disabled", isDisabled()); if (!isOpen()) renderer.render("open", false); if (!isSelectable()) renderer.render("checkable", false); render(renderer, "_loadedChildren", isLoaded()); render(renderer, "_loaded", isRendered() ? true : (getTree() != null ? getTree().getModel() == null : false)); if (_value instanceof String) render(renderer, "value", _value); }
tc.setParent(ti); if (ti.isOpen()) this.renderChildren(renderer, tc, childNode);