javax.swing.event.TreeModelListener#treeStructureChanged()源码实例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;

        }
    }
}
 

/**
 * Update tree if it was refreshed or an entry was changed.
 *
 * @param entry the changed entry
 * @param changed whether the entry was changed or just refreshed
 * @since 8.1.2
 */
private void updateEntry(Entry entry, boolean changed) {
	RepositoryTreeUtil treeUtil = new RepositoryTreeUtil();
	TreeModelEvent e = makeChangeEvent(entry);
	if (parentTree != null) {
		treeUtil.saveExpansionState(parentTree);
		if (!changed) {
			//Fix for UI glitches if children of a refreshed folder are selected during a refresh
			treeUtil.retainRootSelections(parentTree);
		}
	}
	for (TreeModelListener l : listeners.getListeners(TreeModelListener.class)) {
		if (changed) {
			l.treeNodesChanged(e);
		}
		l.treeStructureChanged(e);
	}
	if (parentTree != null) {
		treeUtil.restoreExpansionState(parentTree);
	}
}
 

public void removeItem(final StorageItem item) {
  if (item instanceof ClassItem) {
    final PackageItem packageItem = ((ClassItem) item).getPackage();
    if (packageItem != null) {
      packageItem.removeClass((ClassItem) item);
      if (packageItem.getChildCount(packageItem) == 0) {
        this.items.remove(packageItem);
      }
    }
  }
  else {
    if (item instanceof PackageItem) {
      this.items.remove(item);
    }
  }

  for (final TreeModelListener l : this.treeModelListeners) {
    l.treeStructureChanged(new TreeModelEvent(this, new TreePath(this)));
  }
}
 

/**
 * The only event raised by this model is TreeStructureChanged with the root
 * as path, i.e. the whole tree has changed.
 */
protected void fireTreeStructureChanged(Person oldRoot) {
    int len = treeModelListeners.size();
    TreeModelEvent e = new TreeModelEvent(this, new Object[] { oldRoot });
    for (TreeModelListener tml : treeModelListeners) {
        tml.treeStructureChanged(e);
    }
}
 

void fireChildrenChange(LookTreeNode source) {
    logger.log(Level.FINER, "fireChildrenChange: {0}", source);
    if (listeners.isEmpty()) {
        return;
    }
    // XXX this is crude, could try to actually compute added/removed children...
    TreePath path = (source == root) ? null : findPath(source.getParent());
    TreeModelEvent ev = new TreeModelEvent(this, path, null, null);
    for (TreeModelListener l : listeners) {
        logger.log(Level.FINER, "firing: {0} to {1}", new Object[] {ev, l});
        l.treeStructureChanged(ev);
    }
}
 

public void refreshAll ()
{
    nodeMap.clear();

    TreeModelEvent modelEvent = new TreeModelEvent(
            this,
            new Object[]{score});

    for (TreeModelListener listener : listeners) {
        listener.treeStructureChanged(modelEvent);
    }
}
 

/**
 * Informs all listeners, that the tree's contents have changed.
 */
private void fireTreeModelChanged() {
  for ( int i = 0; i < listeners.size(); i++ ) {
    final TreeModelListener l = listeners.get( i );
    l.treeStructureChanged( new TreeModelEvent( this, new TreePath( root ) ) );
  }
}
 

public void refreshAll ()
{
    nodeMap.clear();

    TreeModelEvent modelEvent = new TreeModelEvent(this, new Object[]{book});

    for (TreeModelListener listener : listeners) {
        listener.treeStructureChanged(modelEvent);
    }
}
 

public void refreshPath (TreePath path)
{
    TreeModelEvent modelEvent = new TreeModelEvent(this, path);

    for (TreeModelListener listener : listeners) {
        listener.treeStructureChanged(modelEvent);
    }
}
 

public void fireTreeDataChanged() {
  final TreeModelListener[] treeModelListeners = getListeners();
  final TreeModelEvent treeEvent = new TreeModelEvent( this, new TreePath( getRoot() ) );
  //    for (int i = treeModelListeners.length - 1; i >= 0; i -= 1)
  for ( int i = 0; i < treeModelListeners.length; i++ ) {
    final TreeModelListener listener = treeModelListeners[ i ];
    listener.treeStructureChanged( treeEvent );
  }

  refreshExpressionsCache();
}
 

public void fireTreeDataChanged( final Object source ) {
  final TreeModelListener[] treeModelListeners = eventListenerList.getListeners( TreeModelListener.class );
  final TreeModelEvent treeEvent = new TreeModelEvent( this, TreeSelectionHelper.getPathForNode( this, source ) );
  for ( int i = treeModelListeners.length - 1; i >= 0; i -= 1 ) {
    final TreeModelListener listener = treeModelListeners[ i ];
    listener.treeStructureChanged( treeEvent );
  }
}
 

public void refreshPath (TreePath path)
{
    TreeModelEvent modelEvent = new TreeModelEvent(this, path);

    for (TreeModelListener listener : listeners) {
        listener.treeStructureChanged(modelEvent);
    }
}
 

@Override
public void onMindMapStructureChanged(@Nonnull final MindMapModelEvent event) {
  clear();
  final TreeModelEvent treeEvent = new TreeModelEvent(this, event.getPath());
  for (final TreeModelListener l : this.treeListeners) {
    l.treeStructureChanged(treeEvent);
  }
}
 

public final void update() {
    this.list = swf.getAS3Packs();
    TreeModelEvent event = new TreeModelEvent(this, new TreePath(root));
    for (TreeModelListener listener : listeners) {
        listener.treeStructureChanged(event);
    }
}
 

private void fireTreeStructureChanged(TreeModelEvent e) {
    for (TreeModelListener listener : listeners) {
        listener.treeStructureChanged(e);
    }
}
 

private void swingFireRootChanged() {
	TreeModelEvent event = new TreeModelEvent(this, (TreePath) null);
	for (TreeModelListener listener : listeners) {
		listener.treeStructureChanged(event);
	}
}
 

public void fireTreeStructureChanged() {
    TreeModelEvent treeModelEvent = new TreeModelEvent(this, getPath(root));
    for (TreeModelListener listener : listeners) {
        listener.treeStructureChanged(treeModelEvent);
    }
}
 

protected void fireStructureChanged(Object node) {
	TreeModelEvent e = new TreeModelEvent(this, findPath(node));
	for (TreeModelListener l : listeners) {
		l.treeStructureChanged(e);
	}
}
 

@Override
public void libraryChanged(LibraryNode node) {
    final TreeModelEvent treeModelEvent = new TreeModelEvent(this, new TreePath(node.getPath()));
    for (TreeModelListener l : listeners)
        l.treeStructureChanged(treeModelEvent);
}
 

public void removeAll() {
  this.items.clear();
  for (TreeModelListener p_listener : this.treeModelListeners) {
    p_listener.treeStructureChanged(new TreeModelEvent(this, new TreePath(this)));
  }
}