public int getPreferredHeight() {
if (getStateRoot() == null) {
return 0;
}
if (isFixedRowHeight()) {
return getRowCount() * getRowHeight();
}
VariableHeightStateNode root = (VariableHeightStateNode) getStateRoot();
return root.getTotalChildrenHeight() + (isRootVisible() ? root.getHeight() : 0);
}
public Rectangle getBounds(final TreePath path, final Rectangle placeIn) {
if (!isRoot(path) && !isVisible(path)) {
return null;
}
if (isFixedRowHeight()) {
return getFixedHeightBoundsImpl(path, placeIn);
}
if (getNodeDimensions() == null) {
return new Rectangle();
}
if (isRoot(path)) {
Rectangle result =
getNodeDimensions(
getStateRoot().getModelNode(),
isRootVisible() ? 0 : -1,
0,
getStateRoot().isExpanded(),
placeIn);
result.y = 0;
return result;
}
VariableHeightStateNode parentNode =
(VariableHeightStateNode) getStateNodeForPath(path.getParentPath());
StateNode node = parentNode.getChild(path.getLastPathComponent());
Rectangle result =
getNodeDimensions(
path.getLastPathComponent(),
getRowForPath(path),
getPathDepth(path),
node != null && node.isExpanded(),
placeIn);
result.y = 0;
Object currentModelNode = path.getLastPathComponent();
while (parentNode != null) {
if (!parentNode.isRoot() || isRootVisible()) {
result.y += parentNode.getHeight();
}
if (parentNode.isExpanded()) {
int modelIndex = parentNode.getModelIndexOfChild(currentModelNode);
for (int i = 0; i < modelIndex; i++) {
result.y += parentNode.getChildrenHeights()[i];
}
}
currentModelNode = parentNode.getModelNode();
parentNode = (VariableHeightStateNode) parentNode.getParent();
}
return result;
}
public int getRowForPath(final TreePath path) {
if (!isVisible(path)) {
return -1;
}
VariableHeightStateNode correspondingNode = (VariableHeightStateNode) getStateNodeForPath(path);
if (correspondingNode != null) {
return correspondingNode.getRow();
}
VariableHeightStateNode parent =
(VariableHeightStateNode) getStateNodeForPath(path.getParentPath());
int modelIndex = parent.getModelIndexOfChild(path.getLastPathComponent());
int rowIncrement = 0;
for (int i = 0; i < modelIndex; i++) {
rowIncrement++;
Object modelNode = parent.getModelChildNode(i);
StateNode childNode = parent.getChild(modelNode);
if (childNode != null) {
rowIncrement += childNode.getTotalChildrenCount();
}
}
return parent.getRow() + rowIncrement + 1;
}
protected void validateData() {
super.validateData();
if (getParent() == null) {
row = isRootVisible() ? 0 : -1;
}
Rectangle bounds =
getNodeDimensions(getModelNode(), row, getPathDepth(getModelPath()), isExpanded(), null);
height = bounds != null ? bounds.height : 0;
if (!isExpanded()) {
totalChildrenCount = 0;
totalChildrenHeight = 0;
if (childrenHeights == null || childrenHeights.length != 0) {
childrenHeights = new int[0];
}
return;
}
int modelChildCount = getModelChildCount();
int childRow = row;
totalChildrenCount = 0;
totalChildrenHeight = 0;
if (childrenHeights == null || childrenHeights.length != modelChildCount) {
childrenHeights = new int[modelChildCount];
}
for (int i = 0; i < modelChildCount; i++) {
Object modelChild = getModelChildNode(i);
VariableHeightStateNode stateChild = (VariableHeightStateNode) getChild(modelChild);
childRow++;
if (stateChild != null) {
stateChild.row = childRow;
childrenHeights[i] = stateChild.getHeight() + stateChild.getTotalChildrenHeight();
totalChildrenCount += stateChild.getTotalChildrenCount();
childRow += stateChild.getTotalChildrenCount();
} else {
bounds =
getNodeDimensions(
modelChild, childRow, getPathDepth(getModelPath()) + 1, false, bounds);
childrenHeights[i] = bounds != null ? bounds.height : 0;
}
totalChildrenCount++;
totalChildrenHeight += childrenHeights[i];
}
}
public TreePath getPathClosestTo(final int x, final int y) {
if (getStateRoot() == null) {
return null;
}
if (isFixedRowHeight()) {
return getFixedHeightPathClosestToImpl(x, y);
}
if (!getStateRoot().isExpanded()) {
return isRootVisible() ? getStateRoot().getModelPath() : null;
}
int cummulativeHeight = 0;
VariableHeightStateNode currentParent = (VariableHeightStateNode) getStateRoot();
if (isRootVisible()) {
if (currentParent.getHeight() > y) {
return currentParent.getModelPath();
}
cummulativeHeight += currentParent.getHeight();
}
while (true) {
int modelChildCount = currentParent.getModelChildCount();
if (modelChildCount == 0) {
return currentParent.getModelPath();
}
for (int i = 0; i < modelChildCount; i++) {
if (cummulativeHeight + currentParent.getChildrenHeights()[i] > y
|| i + 1 == modelChildCount) {
Object modelChild = currentParent.getModelChildNode(i);
VariableHeightStateNode childNode =
(VariableHeightStateNode) currentParent.getChild(modelChild);
if (childNode != null) {
currentParent = childNode;
if (cummulativeHeight + currentParent.getHeight() > y || !currentParent.isExpanded()) {
return currentParent.getModelPath();
}
cummulativeHeight += currentParent.getHeight();
break;
}
return currentParent.getModelPath().pathByAddingChild(modelChild);
}
cummulativeHeight += currentParent.getChildrenHeights()[i];
}
}
}
public TreePath getPathForRow(final int row) {
if (row < 0 || row >= getRowCount()) {
return null;
}
if (isRootVisible() && row == 0) {
return getStateRoot().getModelPath();
}
VariableHeightStateNode parent = (VariableHeightStateNode) getStateRoot();
while (true) {
if (parent.getChildCount() == 0) {
int modelIndex = row - parent.getRow() - 1;
Object modelChild = parent.getModelChildNode(modelIndex);
return parent.getModelPath().pathByAddingChild(modelChild);
}
for (int i = 0; i < parent.getChildCount(); i++) {
VariableHeightStateNode childNode = (VariableHeightStateNode) parent.get(i);
if (childNode.getRow() == row) {
return childNode.getModelPath();
}
if (childNode.getRow() > row) {
int modelChildIndex = parent.getModelIndexOfChild(childNode.getModelNode());
int modelIndex = modelChildIndex - (childNode.getRow() - row);
Object modelChild = parent.getModelChildNode(modelIndex);
return parent.getModelPath().pathByAddingChild(modelChild);
}
if (childNode.getRow() < row
&& childNode.getRow() + childNode.getTotalChildrenCount() >= row) {
parent = childNode;
break;
}
if (i == parent.getChildCount() - 1) {
int modelChildIndex = parent.getModelIndexOfChild(childNode.getModelNode());
int modelIndex =
modelChildIndex + row - (childNode.getRow() + childNode.getTotalChildrenCount());
Object modelChild = parent.getModelChildNode(modelIndex);
return parent.getModelPath().pathByAddingChild(modelChild);
}
}
}
}
