Implemented hidden nodes, Expanded state inconsistent?!

Question

Hi Guys, I have a rather complex JTree problem.
I have implemented my own custom tree and nodes, with a custom model that allows hidden nodes. My nodes have an isVisible() method that is used in the model to see whether to return this node (in the getChildCount and getChild methods). This works great, and means that I can apply a filter to the tree, and it will immediately filter out a certain type of node (without having to add/remove nodes).
I have a bit of a problem when some nodes are expanded however. If I expand a node, then change the filters so that node is invisible, the node that takes it's place becomes expanded. This would be fine, but the expansion of the node does not fire an event (and in my program this causes problems!).
I've written the code below to give a very simple example. Just run the code, expand the 'Red' node you can see, then press 'Toggle Red'. The red node then disappears, but the blue node that takes it's place is then expanded (this is what I need to stop, or at least make that expansion of the blue node fire an event).
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Enumeration;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeNode;
import com.talgentra.tallyman.util.properties.ApplicationProperties;
import com.talgentra.tallyman.util.properties.VersionProperties;
public class TreeTest extends JFrame {
     private boolean showRed = true;
     private boolean showBlue = true;
     private int expansionEvents = 0;
     private JTree tree = new JTree();
     public static void main(String[] args) throws Exception {
          VersionProperties.create(null);
          ApplicationProperties.createConfigurationInstance();
          new TreeTest();
     public TreeTest() throws Exception {
          this.setSize(200,200);
          this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
          this.getContentPane().setLayout(new BorderLayout());
          // set up toggle button
          JButton toggle = new JButton("Toggle Red");
          toggle.addActionListener(new ActionListener() {
               public void actionPerformed(ActionEvent e) {
                    showRed = !showRed;
                    tree.updateUI();
          // set up tree
          ColorNode root = new BlueNode();
          ColorNode r1 = new RedNode();
          ColorNode r11 = new RedNode();
          ColorNode r21 = new RedNode();
          ColorNode b2 = new BlueNode();
          ColorNode b12 = new BlueNode();
          ColorNode b22 = new BlueNode();
          root.add(r1);
          root.add(b2);
          r1.add(r11);
          r1.add(b12);
          b2.add(r21);
          b2.add(b22);
          tree.setModel(new MyTreeModel(root));
          tree.addTreeExpansionListener( new TreeExpansionListener() {
               public void treeExpanded(TreeExpansionEvent event) {
                    System.out.println("TreeExpansionEvents fired: " + expansionEvents);
               public void treeCollapsed(TreeExpansionEvent event) {}
          this.getContentPane().add(toggle, BorderLayout.NORTH);
          this.getContentPane().add(new JScrollPane(tree), BorderLayout.CENTER);
          this.show();
     abstract class ColorNode extends DefaultMutableTreeNode {
          public ColorNode(Object o) {
               super(o);
          public abstract boolean isVisible();
     class RedNode extends ColorNode {
          public RedNode() {
               super("Red");
          public boolean isVisible() {
               return showRed;
     class BlueNode extends ColorNode {
          public BlueNode() {
               super("Blue");
          public boolean isVisible() {
               return showBlue;
     class MyTreeModel extends DefaultTreeModel {
          public MyTreeModel(TreeNode root) {
               super(root);
          public int getChildCount(Object parent) {
               int childCount = 0;
               for ( Enumeration e = ((TreeNode)parent).children(); e.hasMoreElements();) {
                    Object o = (Object) e.nextElement();
                    if (o instanceof ColorNode) {
                         ColorNode node = (ColorNode) o;
                         if ( node.isVisible() ) {
                              childCount++;
                    } else {
                         childCount++;
               return childCount;
          public Object getChild(Object parent, int index) {
               DefaultMutableTreeNode node = (DefaultMutableTreeNode) parent;
               DefaultMutableTreeNode child = null;
               int count = 0;
               for (int i=0; i<node.getChildCount(); i++) {
                    // if this is not a ColorNode, or is a VISIBLE ColorNode then include it
                    if (!(node.getChildAt(i) instanceof ColorNode) || ((ColorNode) node.getChildAt(i)).isVisible()) {
                              if ( count == index ) {
                                   child = (DefaultMutableTreeNode) node.getChildAt(i);
                                   break;
                              } else {
                                   count++;
               return child;
}

Answer 1

As always :) , I agree with Denis.
This is what I've been doing in the mean time. The problem is that I get the opposite behavior. Re-added nodes are collapsed by default.import javax.swing.*;
import javax.swing.tree.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.util.*;
public class TreeTest extends JPanel {
     private static class Property {
          public static final Property PROPERTY_RED = new Property("red");
          public static final Property PROPERTY_BLUE = new Property("blue");
          private String theText;
          private boolean theState;
          private Property(String aText) {
               theText = aText;
               theState = true;
          public String toString() {
               return theText;
          public void toggleState() {
               theState = !theState;
          public boolean getState() {
               return theState;
     private class ColorNode implements TreeNode {
          private ColorNode theParent;
          private Property theProperty;
          private Vector theChildren;
          private int[] theIndices;
          public ColorNode(Property aProperty) {
               theParent = null;
               theProperty = aProperty;
               theChildren = new Vector();
               theIndices = new int[]{};
          public void add(ColorNode aChild) {
               theChildren.add(aChild);
               aChild.theParent = this;
               update();
          public String toString() {
               return theProperty.toString();
          private boolean isVisible() {
               return theProperty.getState();
          public int getChildCount() {
               return theIndices.length;
          public boolean getAllowsChildren() {
               return true;
          public boolean isLeaf() {
               return theIndices.length == 0;
          public Enumeration children() {
               Vector vector = new Vector();
               for (int i = 0; i < theIndices.length; i++) {
                    vector.add(theChildren.elementAt(theIndices));
               return vector.elements();
          public TreeNode getParent() {
               return theParent;
          public TreeNode getChildAt(int childIndex) {
               return (TreeNode)theChildren.elementAt(theIndices[childIndex]);
          public int getIndex(TreeNode node) {
               for (int i = 0; i < theIndices.length; i++) {
                    if (theChildren.elementAt(theIndices[i]) == node) return theIndices[i];
               return -1;
          private int getChange(Property aChangedProperty) {
               if (theProperty != aChangedProperty) return 0;
               if (theProperty.getState()) {
                    return 1;
               } else {
                    return -1;
          public void update(Property aChangedProperty) {
               Vector removedIndices = new Vector();
               Vector removedObjects = new Vector();
               for (int i = 0; i < theIndices.length; i++) {
                    ColorNode colorNode = (ColorNode)theChildren.elementAt(theIndices[i]);
                    if (colorNode.getChange(aChangedProperty) == -1) {
                         removedIndices.add(new Integer(theIndices[i]));
                         removedObjects.add(colorNode);
               theTreeModel.nodesWereRemoved(this,
                                                  getIndexArray(removedIndices),
                                                  (Object[])removedObjects.toArray(new Object[removedObjects.size()]));
               Vector vect = new Vector();
               Vector added = new Vector();
               for (int i = 0; i < theChildren.size(); i++) {
                    ColorNode colorNode = (ColorNode)theChildren.elementAt(i);
                    if (colorNode.isVisible()) {
                         vect.add(new Integer(i));
                         if (colorNode.getChange(aChangedProperty) == 1) {
                              added.add(new Integer(i));
                         colorNode.update(aChangedProperty);
               theIndices = getIndexArray(vect);
               theTreeModel.nodesWereInserted(this, getIndexArray(added));
          private int[] getIndexArray(Vector someIndices) {
               int[] indexArray = new int[someIndices.size()];
               for (int i = 0; i < someIndices.size(); i++) {
                    indexArray[i] = ((Integer)someIndices.elementAt(i)).intValue();
               return indexArray;
          public void update() {
               Vector vect = new Vector();
               for (int i = 0; i < theChildren.size(); i++) {
                    ColorNode colorNode = (ColorNode)theChildren.elementAt(i);
                    if (colorNode.isVisible()) {
                         vect.add(new Integer(i));
               theIndices = getIndexArray(vect);
     private class ToggleStateAction extends AbstractAction {
          private Property theProperty;
          public ToggleStateAction(Property aProperty) {
               super("Toggle " + aProperty.toString());
               theProperty = aProperty;
          public void actionPerformed(ActionEvent e) {
               theProperty.toggleState();
               ((ColorNode)theTreeModel.getRoot()).update(theProperty);
     private DefaultTreeModel theTreeModel;
     private JTree theTree;
     public TreeTest() throws Exception {
          super(new BorderLayout());
          ColorNode root = new ColorNode(Property.PROPERTY_BLUE);
          ColorNode r1 = new ColorNode(Property.PROPERTY_RED);
          ColorNode r11 = new ColorNode(Property.PROPERTY_RED);
          ColorNode r21 = new ColorNode(Property.PROPERTY_RED);
          ColorNode b2 = new ColorNode(Property.PROPERTY_BLUE);
          ColorNode b12 = new ColorNode(Property.PROPERTY_BLUE);
          ColorNode b22 = new ColorNode(Property.PROPERTY_BLUE);
          root.add(r1);
          root.add(b2);
          r1.add(r11);
          r1.add(b12);
          b2.add(r21);
          b2.add(b22);
          root.update();
          theTreeModel = new DefaultTreeModel(root);
          theTree = new JTree(theTreeModel);
          add(new JScrollPane(theTree), BorderLayout.CENTER);
          JToolBar toolBar = new JToolBar();
          toolBar.setFloatable(false);
          toolBar.add(new ToggleStateAction(Property.PROPERTY_RED));
          toolBar.add(new ToggleStateAction(Property.PROPERTY_BLUE));
          add(toolBar, BorderLayout.NORTH);
     public static void main(String[] args) throws Exception {
          final JFrame frame = new JFrame("Test Tree");
          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          frame.setContentPane(new TreeTest());
          SwingUtilities.invokeLater(new Runnable() {
               public void run() {
                    frame.setSize(200, 200);
                    frame.show();