javax.swing.event.TreeModelListener Java Examples

/**
 * 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 fireQueryChanged( final Object query ) {
  if ( query == null ) {
    return;
  }

  final ArrayList<ReportQueryNode> nodes = new ArrayList<ReportQueryNode>();
  findAllQueryNodes( query, nodes, getDataFactoryElement() );

  final TreeModelListener[] treeModelListeners = getListeners();
  for ( int n = 0; n < nodes.size(); n++ ) {
    final ReportQueryNode queryNode = nodes.get( n );
    final TreePath path = getPathForNode( queryNode.getDataFactory() );
    final TreePath queryPath = path.pathByAddingChild( queryNode );

    final TreeModelEvent treeEvent = new TreeModelEvent( this, queryPath );
    for ( int i = treeModelListeners.length - 1; i >= 0; i -= 1 ) {
      final TreeModelListener listener = treeModelListeners[ i ];
      listener.treeStructureChanged( treeEvent );
    }
  }
}
 

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();
}
 

private void fireTreeNodesChanged(Operator operator) {
	TreeModelEvent e = makeChangeEvent(operator);
	if (e.getChildIndices() != null && e.getChildIndices()[0] != -1) { // otherwise the
		// operator is in
		// the state of
		// being removed and
		// has
		// triggered an
		// update while
		// dying.
		for (TreeModelListener l : listenerList.getListeners(TreeModelListener.class)) {
			try {
				l.treeNodesChanged(e);
			} catch (Exception ex) {
				//ignore
			}
		}
	}
}
 

public void fireNodeAdded(final GTreeNode parentNode, final GTreeNode newNode) {
	if (!eventsEnabled) {
		return;
	}
	SystemUtilities.assertThisIsTheSwingThread(
		"GTreeModel.fireNodeAdded() must be " + "called from the AWT thread");

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

	int index = parent.getIndexOfChild(newNode);
	if (index < 0) {
		// the index will be -1 if filtered out
		return;
	}
	TreeModelEvent event = new TreeModelEvent(this, parent.getTreePath(), new int[] { index },
		new Object[] { newNode });
	for (TreeModelListener listener : listeners) {
		listener.treeNodesInserted(event);
	}
}
 

public void valueForPathChanged(final TreePath path, final Object value) {
    if (path.getLastPathComponent() instanceof Product) {
        final Product product = (Product) path.getLastPathComponent();
        
        switch (product.getStatus()) {
        case NOT_INSTALLED:
            product.setStatus(Status.TO_BE_INSTALLED);
            updateRequirements(product);
            break;
        case TO_BE_INSTALLED:
            product.setStatus(Status.NOT_INSTALLED);
            break;
        case INSTALLED:
            product.setStatus(Status.TO_BE_UNINSTALLED);
            break;
        case TO_BE_UNINSTALLED:
            product.setStatus(Status.INSTALLED);
            break;
        }
    }
    
    final TreeModelListener[] clone;
    synchronized (listeners) {
        clone = listeners.toArray(new TreeModelListener[0]);
    }
    
    final TreeModelEvent event = new TreeModelEvent(this, path);
    for (TreeModelListener listener: clone) {
        listener.treeNodesChanged(event);
    }
}
 

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

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

private void fireTreeStructureChanged(ExecutionUnit unit) {
	TreePath path = getPathTo(unit).getParentPath();
	TreeModelEvent e = new TreeModelEvent(this, path);
	for (TreeModelListener l : listenerList.getListeners(TreeModelListener.class)) {
		try {
			l.treeStructureChanged(e);
		} catch (Exception ex) {
			//ignore
		}
	}
}
 

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

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

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);
		}
	}
 

/**
 * 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);
    }
}
 

protected void fireStructureChangedEvent(TreeModelEvent event)
{
	for (TreeModelListener listener : listeners)
	{
		listener.treeStructureChanged(event);
	}
}
 

public void fireNodeStructureChanged(final GTreeNode changedNode) {
	if (!eventsEnabled || isFiringNodeStructureChanged) {
		return;
	}
	try {
		isFiringNodeStructureChanged = true;
		SystemUtilities.assertThisIsTheSwingThread(
			"GTreeModel.fireNodeStructuredChanged() must be " + "called from the AWT thread");

		GTreeNode node = convertToViewNode(changedNode);
		if (node == null) {
			return;
		}
		if (node != changedNode) {
			node.setChildren(null);
			return;	// the previous call will generate the proper event, so bail
		}

		TreeModelEvent event = new TreeModelEvent(this, node.getTreePath());
		for (TreeModelListener listener : listeners) {
			listener.treeStructureChanged(event);
		}
	}
	finally {
		isFiringNodeStructureChanged = false;
	}
}
 

public void valueForPathChanged(TreePath path, Object newValue) {
    Object oldValue = path.getLastPathComponent();
    renameEntry((String)oldValue, (String)newValue);
    TreeModelEvent ev = new TreeModelEvent(this, path.getParentPath().pathByAddingChild(newValue));
    for(TreeModelListener l : listeners) {
        l.treeNodesChanged(ev);
    }
}
 

private void updateFilteredModel() {
    DefaultMutableTreeNode sourceRoot = (DefaultMutableTreeNode) super.getRoot();
    DefaultMutableTreeNode targetRoot = (DefaultMutableTreeNode) sourceRoot.clone();
    wrapNodes(sourceRoot, separator);
    fragmentedKeyModel = new DefaultTreeModel(targetRoot);
    Object[] listeners = listenerList.getListenerList();
    for (int i = listeners.length - 2; i >= 0; i -= 2) {
        if (listeners[i] == TreeModelListener.class) {
            fragmentedKeyModel.addTreeModelListener((TreeModelListener) listeners[i + 1]);
        }
    }
    fireSeparatorChanged();
}
 

protected void fireTreeStructureChanged( Object oldRoot ) {
    TreeModelEvent event = new TreeModelEvent(this, new Object[]{oldRoot});
    EventListener[] listeners = listenerList.getListeners(TreeModelListener.class);
    for( int i = 0; i < listeners.length; i++ )
        ((TreeModelListener) listeners[i]).treeStructureChanged(event);
}
 

public void addTreeModelListener(TreeModelListener l) {
  listeners.add(TreeModelListener.class, l);
}
 

public void removeTreeModelListener(TreeModelListener l) {
    // Do nothing...
}
 

@Override
public void removeTreeModelListener(TreeModelListener listener)
{
	eventListenerList.remove(TreeModelListener.class, listener);
}
 

@Override
public void removeTreeModelListener(TreeModelListener treeModelListener) {
}
 

@Override
public void addTreeModelListener(TreeModelListener l) {
    listeners.add(l);
}
 

@Override
public void addTreeModelListener(TreeModelListener treeModelListener) {
}
 

public void addTreeModelListener(TreeModelListener listener) {
}
 

/**
 * Removes a {@link javax.swing.event.TreeModelListener} from the list of
 * listeners registered with this model.
 */
@Override
public void removeTreeModelListener(TreeModelListener l) {
  listenerList.remove(TreeModelListener.class, l);
}
 

protected TreeModelListener[] getListeners() {
  return eventListenerList.getListeners( TreeModelListener.class );
}
 

protected void fireTreeNodeChanged(TreePath treePath) {
    TreeModelEvent event = new TreeModelEvent(this, treePath);
    for (TreeModelListener treeModelListener : treeModelListeners.keySet()) {
        treeModelListener.treeNodesChanged(event);
    }
}
 

public void addTreeModelListener( final TreeModelListener l ) {
  listenerList.add( TreeModelListener.class, l );
}
 

@Override
public void removeTreeModelListener(TreeModelListener treeModelListener) {
}
 

@Override
public void removeTreeModelListener(TreeModelListener treeModelListener) {
}
 

@Override
public void removeTreeModelListener(TreeModelListener treeModelListener) {
}