Java TreeModelEvent.getChildIndices方法代码示例

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
/**
 * Compute real table row indices of nodes that are affected by the event.
 *
 * @param e Event description.
 * @return Indices of rows in the table where the nodes (affected by the
 * event) are displayed, or null if they are not available.
 */
private int[] computeRowIndices(TreeModelEvent e) {
    int[] rowIndices;
    int parentRow = getLayout().getRowForPath(e.getTreePath());
    if (e.getChildren() != null) {
        rowIndices = new int[e.getChildren().length];
        for (int i = 0; i < e.getChildren().length; i++) {
            TreePath childPath =
                    e.getTreePath().pathByAddingChild(e.getChildren()[i]);
            int index = getLayout().getRowForPath(childPath);
            rowIndices[i] = index < 0
                    // child node is not shown yet, compute child row from
                    // parent row and index of the child
                    ? parentRow + e.getChildIndices()[i] + 1
                    : index;
        }
    } else {
        rowIndices = null;
    }
    return rowIndices;
}
 

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
/**
 * <p>Invoked after nodes have been removed from the tree.  Note that
 * if a subtree is removed from the tree, this method may only be
 * invoked once for the root of the removed subtree, not once for
 * each individual set of siblings removed.</p>
 *
 * <p>e.path() returns the former parent of the deleted nodes.</p>
 *
 * <p>e.childIndices() returns the indices the nodes had before they were deleted in ascending order.</p>
 */
public void treeNodesRemoved(TreeModelEvent e) {
    if(e != null) {
        int                  changedIndexs[];
        int                  maxCounter;
        TreePath             parentPath = SwingUtilities2.getTreePath(e, getModel());
        FHTreeStateNode      changedParentNode = getNodeForPath
                                   (parentPath, false, false);

        changedIndexs = e.getChildIndices();
        // PENDING(scott): make sure that changedIndexs are sorted in
        // ascending order.
        if(changedParentNode != null && changedIndexs != null &&
           (maxCounter = changedIndexs.length) > 0) {
            Object[]           children = e.getChildren();
            boolean            isVisible =
                (changedParentNode.isVisible() &&
                 changedParentNode.isExpanded());

            for(int counter = maxCounter - 1; counter >= 0; counter--) {
                changedParentNode.removeChildAtModelIndex
                                 (changedIndexs[counter], isVisible);
            }
            if(isVisible) {
                if(treeSelectionModel != null)
                    treeSelectionModel.resetRowSelection();
                if (treeModel.getChildCount(changedParentNode.
                                            getUserObject()) == 0 &&
                              changedParentNode.isLeaf()) {
                    // Node has become a leaf, collapse it.
                    changedParentNode.collapse(false);
                }
                visibleNodesChanged();
            }
            else if(changedParentNode.isVisible())
                visibleNodesChanged();
        }
    }
}
 

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
/**
 * <p>Invoked after a node (or a set of siblings) has changed in some
 * way. The node(s) have not changed locations in the tree or
 * altered their children arrays, but other attributes have
 * changed and may affect presentation. Example: the name of a
 * file has changed, but it is in the same location in the file
 * system.</p>
 *
 * <p>e.path() returns the path the parent of the changed node(s).</p>
 *
 * <p>e.childIndices() returns the index(es) of the changed node(s).</p>
 */
public void treeNodesChanged(TreeModelEvent e) {
    if(e != null) {
        int                 changedIndexs[];
        FHTreeStateNode     changedParent = getNodeForPath
                              (SwingUtilities2.getTreePath(e, getModel()), false, false);
        int                 maxCounter;

        changedIndexs = e.getChildIndices();
        /* Only need to update the children if the node has been
           expanded once. */
        // PENDING(scott): make sure childIndexs is sorted!
        if (changedParent != null) {
            if (changedIndexs != null &&
                (maxCounter = changedIndexs.length) > 0) {
                Object       parentValue = changedParent.getUserObject();

                for(int counter = 0; counter < maxCounter; counter++) {
                    FHTreeStateNode    child = changedParent.
                             getChildAtModelIndex(changedIndexs[counter]);

                    if(child != null) {
                        child.setUserObject(treeModel.getChild(parentValue,
                                                 changedIndexs[counter]));
                    }
                }
                if(changedParent.isVisible() && changedParent.isExpanded())
                    visibleNodesChanged();
            }
            // Null for root indicates it changed.
            else if (changedParent == root && changedParent.isVisible() &&
                     changedParent.isExpanded()) {
                visibleNodesChanged();
            }
        }
    }
}
 

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
@Override
public void treeNodesInserted(TreeModelEvent e)
{
	int[] indices = e.getChildIndices();
	Arrays.sort(indices);
	fireTableRowsInserted(indices[0], indices[indices.length - 1]);
}
 

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
@Override
public void treeNodesRemoved(TreeModelEvent e)
{
	int[] indices = e.getChildIndices();
	Arrays.sort(indices);
	fireTableRowsDeleted(indices[0], indices[indices.length - 1]);
}
 

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
@Override
public void treeNodesChanged(TreeModelEvent e)
{
	int[] indices = e.getChildIndices();
	Arrays.sort(indices);
	fireTableRowsUpdated(indices[0], indices[indices.length - 1]);
}
 

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
/**
 * <p>Invoked after nodes have been inserted into the tree.</p>
 *
 * <p>e.path() returns the parent of the new nodes
 * <p>e.childIndices() returns the indices of the new nodes in
 * ascending order.
 */
public void treeNodesInserted(TreeModelEvent e) {
    if(e != null) {
        int                 changedIndexs[];
        FHTreeStateNode     changedParent = getNodeForPath
                              (SwingUtilities2.getTreePath(e, getModel()), false, false);
        int                 maxCounter;

        changedIndexs = e.getChildIndices();
        /* Only need to update the children if the node has been
           expanded once. */
        // PENDING(scott): make sure childIndexs is sorted!
        if(changedParent != null && changedIndexs != null &&
           (maxCounter = changedIndexs.length) > 0) {
            boolean          isVisible =
                (changedParent.isVisible() &&
                 changedParent.isExpanded());

            for(int counter = 0; counter < maxCounter; counter++) {
                changedParent.childInsertedAtModelIndex
                    (changedIndexs[counter], isVisible);
            }
            if(isVisible && treeSelectionModel != null)
                treeSelectionModel.resetRowSelection();
            if(changedParent.isVisible())
                this.visibleNodesChanged();
        }
    }
}
 

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
public void treeNodesInserted(TreeModelEvent treeModelEvent) {
    cnt++;
    indexes = treeModelEvent.getChildIndices();
}
 

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
public void treeNodesRemoved(TreeModelEvent treeModelEvent) {
    cnt++;
    indexes = treeModelEvent.getChildIndices();
}
 

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
/**
 * Invoked after nodes have been inserted into the tree.
 *
 * <p><code>e.path</code> returns the parent of the new nodes.
 * <p><code>e.childIndices</code> returns the indices of the new nodes in
 * ascending order.
 *
 * @param e the <code>TreeModelEvent</code> of interest
 */
public void treeNodesInserted(TreeModelEvent e) {
    if(e != null) {
        int               changedIndexs[];
        TreeStateNode     changedParentNode;

        changedIndexs = e.getChildIndices();
        changedParentNode = getNodeForPath(SwingUtilities2.getTreePath(e, getModel()), false, false);
        /* Only need to update the children if the node has been
           expanded once. */
        // PENDING(scott): make sure childIndexs is sorted!
        if(changedParentNode != null && changedIndexs != null &&
           changedIndexs.length > 0) {
            if(changedParentNode.hasBeenExpanded()) {
                boolean            makeVisible;
                int                counter;
                Object             changedParent;
                TreeStateNode      newNode;
                int                oldChildCount = changedParentNode.
                                      getChildCount();

                changedParent = changedParentNode.getValue();
                makeVisible = ((changedParentNode == root &&
                                !rootVisible) ||
                               (changedParentNode.getRow() != -1 &&
                                changedParentNode.isExpanded()));
                for(counter = 0;counter < changedIndexs.length;counter++)
                {
                    newNode = this.createNodeAt(changedParentNode,
                                                changedIndexs[counter]);
                }
                if(oldChildCount == 0) {
                    // Update the size of the parent.
                    changedParentNode.updatePreferredSize();
                }
                if(treeSelectionModel != null)
                    treeSelectionModel.resetRowSelection();
                /* Update the y origins from the index of the parent
                   to the end of the visible rows. */
                if(!isFixedRowHeight() && (makeVisible ||
                                           (oldChildCount == 0 &&
                                    changedParentNode.isVisible()))) {
                    if(changedParentNode == root)
                        this.updateYLocationsFrom(0);
                    else
                        this.updateYLocationsFrom(changedParentNode.
                                                  getRow());
                    this.visibleNodesChanged();
                }
                else if(makeVisible)
                    this.visibleNodesChanged();
            }
            else if(treeModel.getChildCount(changedParentNode.getValue())
                    - changedIndexs.length == 0) {
                changedParentNode.updatePreferredSize();
                if(!isFixedRowHeight() && changedParentNode.isVisible())
                    updateYLocationsFrom(changedParentNode.getRow());
            }
        }
    }
}
 

import javax.swing.event.TreeModelEvent; //导入方法依赖的package包/类
/**
 * Invoked after a node (or a set of siblings) has changed in some
 * way. The node(s) have not changed locations in the tree or
 * altered their children arrays, but other attributes have
 * changed and may affect presentation. Example: the name of a
 * file has changed, but it is in the same location in the file
 * system.
 *
 * <p><code>e.path</code> returns the path the parent of the
 * changed node(s).
 *
 * <p><code>e.childIndices</code> returns the index(es) of the
 * changed node(s).
 *
 * @param e the <code>TreeModelEvent</code> of interest
 */
public void treeNodesChanged(TreeModelEvent e) {
    if(e != null) {
        int               changedIndexs[];
        TreeStateNode     changedNode;

        changedIndexs = e.getChildIndices();
        changedNode = getNodeForPath(SwingUtilities2.getTreePath(e, getModel()), false, false);
        if(changedNode != null) {
            Object            changedValue = changedNode.getValue();

            /* Update the size of the changed node, as well as all the
               child indexs that are passed in. */
            changedNode.updatePreferredSize();
            if(changedNode.hasBeenExpanded() && changedIndexs != null) {
                int                counter;
                TreeStateNode      changedChildNode;

                for(counter = 0; counter < changedIndexs.length;
                    counter++) {
                    changedChildNode = (TreeStateNode)changedNode
                                .getChildAt(changedIndexs[counter]);
                    /* Reset the user object. */
                    changedChildNode.setUserObject
                                (treeModel.getChild(changedValue,
                                                 changedIndexs[counter]));
                    changedChildNode.updatePreferredSize();
                }
            }
            else if (changedNode == root) {
                // Null indicies for root indicates it changed.
                changedNode.updatePreferredSize();
            }
            if(!isFixedRowHeight()) {
                int          aRow = changedNode.getRow();

                if(aRow != -1)
                    this.updateYLocationsFrom(aRow);
            }
            this.visibleNodesChanged();
        }
    }
}