javax.swing.event.TreeModelListener#treeNodesRemoved()源码实例Demo

/**
 * Generate events specific to the user actions and trigger the internal
 * management of the tree.
 *
 * @param parent the parent node of the changed nodes (rename, add, remove)
 * @param indices the indexes of the changed nodes
 * @param nodes the affected nodes; the nodes which are changed
 * @param action the action related to the node: rename, add, remove
 */
public void fireTreeStructureChanged(CustomTreeNode parent, int[] indices, Object[] nodes, TreeActions action) {
    TreeModelEvent eventInsRem = new TreeModelEvent(this, parent.getPath(), indices, nodes);
    TreeModelEvent eventStructChange = new TreeModelEvent(this, new Object[]{parent});

    for (TreeModelListener lis : treeModelListeners) {
        switch (action) {
            case NODE_RENAMED:
                lis.treeNodesChanged(eventInsRem);
                break;

            case NODE_INSERTED:
                lis.treeNodesInserted(eventInsRem);
                break;

            case NODE_REMOVED:
                lis.treeNodesRemoved(eventInsRem);
                break;

            case TREE_STRUCTURE_CHANGED:
                lis.treeStructureChanged(eventStructChange);
                break;

        }
    }
}
 

public void fireExpressionRemoved( final Expression parameter ) {
  final TreePath pathForNode = new TreePath( new Object[] { getRoot(), getReportFunctionNode() } );
  final TreeModelListener[] treeModelListeners = getListeners();
  final int index = findExpressionInCache( parameter );
  if ( index == -1 ) {
    return;
  }

  final TreeModelEvent treeEvent = new TreeModelEvent( this, pathForNode,
    new int[] { index }, new Object[] { parameter } );
  for ( int i = treeModelListeners.length - 1; i >= 0; i -= 1 ) {
    final TreeModelListener listener = treeModelListeners[ i ];
    listener.treeNodesRemoved( treeEvent );
  }

  refreshExpressionsCache();
}
 

public void fireParameterRemoved( final ParameterDefinitionEntry parameter ) {
  final TreePath pathForNode = new TreePath( new Object[] { getRoot(), getReportParametersNode() } );
  final TreeModelListener[] treeModelListeners = getListeners();
  final int index = findParameterInCache( parameter );
  if ( index == -1 ) {
    return;
  }

  final TreeModelEvent treeEvent = new TreeModelEvent( this, pathForNode,
    new int[] { index }, new Object[] { parameter } );
  for ( int i = treeModelListeners.length - 1; i >= 0; i -= 1 ) {
    final TreeModelListener listener = treeModelListeners[ i ];
    listener.treeNodesRemoved( treeEvent );
  }

  refreshParameterCache();
}
 

public void fireNodeRemoved(GTreeNode parentNode, GTreeNode removedNode, int index) {

		SystemUtilities.assertThisIsTheSwingThread(
			"GTreeModel.fireNodeRemoved() must be " + "called from the AWT thread");

		GTreeNode parent = convertToViewNode(parentNode);
		if (parent == null) {  // will be null if filtered out
			return;
		}

		// if filtered, remove filtered node
		if (parent != parentNode) {
			index = removeFromFiltered(parent, removedNode);
			return;  // the above call will generate the event for the filtered node
		}

		if (index < 0) {  // will be -1 if filtered out
			return;
		}

		TreeModelEvent event = new TreeModelEvent(this, parent.getTreePath(), new int[] { index },
			new Object[] { removedNode });

		for (TreeModelListener listener : listeners) {
			listener.treeNodesRemoved(event);
		}
	}
 

private void fireTreeNodesRemoved(Operator operator, int oldIndex) {
	TreePath path = getPathTo(operator).getParentPath();
	TreeModelEvent e = new TreeModelEvent(this, path, new int[] { oldIndex }, new Object[] { operator });
	for (TreeModelListener l : listenerList.getListeners(TreeModelListener.class)) {
		try {
			l.treeNodesRemoved(e);
		} catch (Exception ex) {
			//ignore
		}
	}
}
 

public boolean deleteNode(@Nonnull final NodeFileOrFolder node, final boolean notifyListeners) {
  final NodeFileOrFolder parentNode = node.getNodeParent();
  if (parentNode != null) {
    final TreeModelEvent event = new TreeModelEvent(this, parentNode.makeTreePath(), new int[]{node.getIndexAtParent()}, new Object[]{node});
    if (parentNode.deleteChild(node)) {
      if (notifyListeners) {
        for (final TreeModelListener l : this.listeners) {
          l.treeNodesRemoved(event);
        }
      }
      return true;
    }
  }
  return false;
}
 

protected void fireNodeRemovedEvent(TreeModelEvent event)
{
	for (TreeModelListener listener : listeners)
	{
		listener.treeNodesRemoved(event);
	}
}
 

protected void fireTreeNodesRemoved(Object source, Object[] path,
		int[] childIndices, Object[] children)
{
	TreeModelEvent event = new TreeModelEvent(source, path, childIndices,
			children);
	for (TreeModelListener listener : getTreeModelListeners())
	{
		listener.treeNodesRemoved(event);
	}
}
 

protected void fireTreeNodesRemoved(Layer parentLayer) {
    TreeModelEvent event = createTreeModelEvent(parentLayer);
    if (event == null) {
        return;
    }
    for (TreeModelListener treeModelListener : treeModelListeners.keySet()) {
        treeModelListener.treeNodesRemoved(event);
    }
}
 

/**
 * Notifies all added listeners that some nodes were removed.
 *
 * @param event the event object specifying removed nodes
 */
@Override
public void treeNodesRemoved(@Nonnull TreeModelEvent event) {
  for (TreeModelListener listener : myListeners) {
    listener.treeNodesRemoved(event);
  }
}
 

public void fireTreeNodeRemoved(final String nodeName, final byte type, int index) {
    TreeModelEvent ev = createEventForNode(nodeName, type, index);
    for(TreeModelListener l : listeners) {
        l.treeNodesRemoved(ev);
    }
}
 

private void fireTreeNodesRemoved(TreeModelEvent e) {
    for (TreeModelListener listener : listeners) {
        listener.treeNodesRemoved(e);
    }
}
 

private void fireTreeNodesRemoved(TreeModelEvent treeModelEvent) {
    for (TreeModelListener listener : listeners) {
        listener.treeNodesRemoved(treeModelEvent);
    }
}
 

public void fireNodesRemoved(TreeModelEvent e){
    for(TreeModelListener l : listeners) l.treeNodesRemoved(e);
}