/** Sent to completely rebuild the visible tree. All nodes are collapsed. */ private void rebuild(boolean clearSelection) { Object rootUO; treePathMapping.clear(); if (treeModel != null && (rootUO = treeModel.getRoot()) != null) { root = createNodeForValue(rootUO, 0); root.path = new TreePath(rootUO); addMapping(root); if (isRootVisible()) { rowCount = 1; root.row = 0; } else { rowCount = 0; root.row = -1; } root.expand(); } else { root = null; rowCount = 0; } if (clearSelection && treeSelectionModel != null) { treeSelectionModel.clearSelection(); } this.visibleNodesChanged(); }
/** * Creates a new node to represent <code>userObject</code>. This does NOT check to ensure there * isn't already a child node to manage <code>userObject</code>. */ protected FHTreeStateNode createChildFor(Object userObject) { int newChildIndex = treeModel.getIndexOfChild(getUserObject(), userObject); if (newChildIndex < 0) return null; FHTreeStateNode aNode; FHTreeStateNode child = createNodeForValue(userObject, newChildIndex); int childRow; if (isVisible()) { childRow = getRowToModelIndex(newChildIndex); } else { childRow = -1; } child.row = childRow; for (int counter = 0, maxCounter = getChildCount(); counter < maxCounter; counter++) { aNode = (FHTreeStateNode) getChildAt(counter); if (aNode.childIndex > newChildIndex) { insert(child, counter); return child; } } add(child); return child; }
/** * Sets the receivers row to <code>nextRow</code> and recursively updates all the children of * the receivers rows. The index the next row is to be placed as is returned. */ protected int setRowAndChildren(int nextRow) { row = nextRow; if (!isExpanded()) return row + 1; int lastRow = row + 1; int lastModelIndex = 0; FHTreeStateNode child; int maxCounter = getChildCount(); for (int counter = 0; counter < maxCounter; counter++) { child = (FHTreeStateNode) getChildAt(counter); lastRow += (child.childIndex - lastModelIndex); lastModelIndex = child.childIndex + 1; if (child.isExpanded) { lastRow = child.setRowAndChildren(lastRow); } else { child.row = lastRow++; } } return lastRow + childCount - lastModelIndex; }
// This can be rather expensive, but is needed for the collapse // case this is resulting from a remove (although I could fix // that by having instances of FHTreeStateNode hold a ref to // the number of children). I prefer this though, making determing // the row of a particular node fast is very nice! protected void resetChildrenRowsFrom(int newRow, int childIndex, int modelIndex) { int lastRow = newRow; int lastModelIndex = modelIndex; FHTreeStateNode node; int maxCounter = getChildCount(); for (int counter = childIndex; counter < maxCounter; counter++) { node = (FHTreeStateNode) getChildAt(counter); lastRow += (node.childIndex - lastModelIndex); lastModelIndex = node.childIndex + 1; if (node.isExpanded) { lastRow = node.setRowAndChildren(lastRow); } else { node.row = lastRow++; } } lastRow += childCount - lastModelIndex; node = (FHTreeStateNode) getParent(); if (node != null) { node.resetChildrenRowsFrom(lastRow, node.getIndex(this) + 1, this.childIndex + 1); } else { // This is the root, reset total ROWCOUNT! rowCount = lastRow; } }