How to expand a JTree depending on a property

Question

Hi I have a JTree that needs to be expandAll if a property in the ini file is true. Can some tell me how I can do it or give me an example. If needed i can post my code. Here the addtreeDisplays() has to expandAll depending on a string(true ).
Can some help me out.
Thanks,
public class TreeDisplayPanel extends JPanel implements QMRequestListener,
                                                        TopologySelectionListener,
                                                                      PropertyChangeListener
    /** Creates new TreeDisplayPanel */
    //Key to get from property file
    String _treeKey = "tree.display.type";
    //default display
    public final static int TREE_DISPLAY = 0;
    public final static int STAR_DISPLAY = 1;
    public final static int BOTH_DISPLAY =2;
     Properties _displayProp = null;
    //Main panel where everything gets put on to be displayed
    public JPanel _mainDisplayPanel;
    //current default display
    private int treeDisplayPreference = STAR_DISPLAY;
    private MQETabbedPane _treeTabPane;
    private MQETabbedPane _viewTabPane;
    private String treeDisplayTitle;
     static private final String treeviewKey = "tree.view.text";
     static private final String starviewKey = "star.view.text";
     static private final String splitviewKey = "split.view.text";
     static private final String mergeviewKey = "merge.view.text";
     // Default tree displays.
     private HyperbolicTreePanel hyperbolicTreePanel = null;
     private NavigatorTreePanel navigatorTreePanel = null;
     // A store for any queue manager tree displays created
     // by the user. This will enable these trees to be
     // modified whenever the user invokes a expand/collapse
     // all action on a node or whenever the user changes
     // the leaf node expansion preference.
     private Vector<NavigatorTreePanel> qmgrTreeDisplays =
        new Vector<NavigatorTreePanel>();
     //HashMap of indexes correspond to indexes in tabbed paned that are merged, it contains
    //hashtables of components in those merged indexes
    HashMap _qmMergedIndexes = new HashMap();
    //Current listeners to this panel on node selections
    protected Vector<TopologySelectionListener> _tsListeners =
        new Vector<TopologySelectionListener>();
     private TopologyModel m_model = null;
     private TopologyModelNode m_nnode = null;
     private TopologyDisplayPanel tdp = null;
    public TreeDisplayPanel(TopologyModel model, Properties prop, String displayTitle) {
        super(new BorderLayout());
          m_model = model;
          _displayProp = prop;
          treeDisplayTitle = displayTitle;
        initComponent();
        initGui();
    private void initComponent()
          _mainDisplayPanel = ComponentFactory.getInstance().createTitledPanel(treeDisplayTitle);
          _mainDisplayPanel.setLayout(new BorderLayout());
          add(_mainDisplayPanel, BorderLayout.CENTER);
    private void initGui()
        if (_displayProp != null)
               // Get the current display preference.
               String defaultDisplay = Integer.toString(STAR_DISPLAY);
            treeDisplayPreference = Integer.parseInt(_displayProp.getProperty(_treeKey, defaultDisplay));
        try
            //Add according to your display property
            _treeTabPane = new MQETabbedPane();
            _viewTabPane = new MQETabbedPane(JTabbedPane.BOTTOM);
            _viewTabPane.addMouseListener(new MouseListener()
                public void mouseClicked(MouseEvent e)
                    final int tabNum = _viewTabPane.getUI().tabForCoordinate(_viewTabPane,e.getX(),e.getY());
                    //Only if the mouse click is a right mouse and tab number is not on overview pane or doc pane is the popup valid
                    if (SwingUtilities.isRightMouseButton(e) && tabNum > 1)
                        final String tabStr = _viewTabPane.getTitleAt(tabNum);
                        JPopupMenu popup = new JPopupMenu();
                        JMenuItem menuItem1 = new JMenuItem(new AbstractAction("Close " + tabStr)
                            public void actionPerformed(ActionEvent e)
                                //Remove it from our HashMap of merged panes if it exists
                                if (_qmMergedIndexes.containsKey(tabStr))
                                    _qmMergedIndexes.remove(tabStr);
                                        // Remove the Qmgr tree display.
                                        NavigatorTreePanel treePanel = (NavigatorTreePanel)_viewTabPane.getComponentAt(tabNum);
                                        ExpandingModelNode model = (ExpandingModelNode)treePanel.getNavigatorTreeModel();
                                        model.getNode().removeTreeModelListener(model);
                                        qmgrTreeDisplays.remove(treePanel);
                                _viewTabPane.removeTabAt(tabNum);
                              String mergeview = StringFactory.getString(mergeviewKey);
                        JMenu merge = new JMenu(mergeview);
                        merge.setEnabled(false);
                        int numTabs = _viewTabPane.getTabCount();
                        //System.out.println("Num of tabs " + numTabs);
                        //Only allow merging if you have more then 2 panes (1 - Overview, 2 - Qmgr, 3-Qmgr....
                        //Also if the current pane is not a merge pane already
                        if (numTabs > 3 && !_qmMergedIndexes.containsKey(tabStr))
                            //Do not enable this menu if the number of already merged Indexes - the number of tabs
                            //is greater then two (One Valid pane + Overview pane). The reason is because then there is
                            //no valid pane to merge with
                            if ((numTabs - _qmMergedIndexes.size()) > 3)
                                merge.setEnabled(true);
                                for (int i = 2; i<numTabs; i++)
                                    //Add only valid tabs and not already merged tabs
                                    if (i != tabNum && !_qmMergedIndexes.containsKey(_viewTabPane.getTitleAt(i)))
                                        //JMenuItem mergeItem = new JMenuItem(new AbstractAction(_viewTabPane.getTitleAt(i))
                                                  JMenuItem mergeItem = new JMenuItem(new AbstractAction(_viewTabPane.getToolTipTextAt(i))
                                            public void actionPerformed(ActionEvent e)
                                                try
                                                    //System.out.println("Action Name for " + e.getActionCommand());
                                                    //Work around for java bug in JTabbedPane
                                                    _viewTabPane.setSelectedIndex(0);
                                                    _viewTabPane.validate();
                                                    //End workaround
                                                    //Strip off the fully qualified name to contain only the name of the QM name
                                                                 String mergeTabName = m_model.getQMgrName(e.getActionCommand());
                                                                 JPanel splitPanel = new JPanel(new BorderLayout());
                                                    JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
                                                    splitPane.setBorder(null);
                                                    splitPane.setOneTouchExpandable(true);
                                                    int mergeTabIndex =  _viewTabPane.indexOfTab(mergeTabName);
                                                    String mergeTabString = _viewTabPane.getTitleAt(mergeTabIndex);
                                                                 Component mergeComp = _viewTabPane.getComponentAt(mergeTabIndex);
                                                    String mergeCompAddress = _viewTabPane.getToolTipTextAt(mergeTabIndex);
                                                                 splitPane.setLeftComponent(mergeComp);
                                                                 int currentTabIndex =  _viewTabPane.indexOfTab(tabStr);
                                                    Component currentComp = _viewTabPane.getComponentAt(currentTabIndex);
                                                                 String currentCompAddress = _viewTabPane.getToolTipTextAt(currentTabIndex);
                                                    splitPane.setRightComponent(currentComp);
                                                    splitPanel.add(splitPane, BorderLayout.CENTER);
                                                    String mergeName = mergeTabName + "/" + tabStr;
                                                                 String toolTipName = mergeCompAddress + " | " + currentCompAddress;
                                                    //_viewTabPane.addTab(mergeName, splitPanel);
                                                                 addTabToDisplay(mergeName, toolTipName, splitPanel);
                                                    splitPane.setDividerLocation(.5);
                                                    int mergeIndex = _viewTabPane.indexOfTab(mergeName);
                                                                  if (mergeIndex != -1)
                                                        //_viewTabPane.setToolTipTextAt(mergeIndex, mergeName);
                                                                      //_viewTabPane.setSelectedIndex(mergeIndex);
                                                        //Now lets update our ongoing vector/hashmap
                                                        //Create a hash map with the current merged view
                                                        Hashtable mergeViews = new Hashtable();
                                                        mergeViews.put(mergeCompAddress,mergeComp);
                                                        mergeViews.put(currentCompAddress,currentComp);
                                                        _qmMergedIndexes.put(mergeName, mergeViews);
                                                catch (Exception ex)
                                                    ex.printStackTrace();
                                        merge.add(mergeItem);
                              String splitKey = StringFactory.getString(splitviewKey);
                        JMenu splitMenu = new JMenu(splitKey);
                        splitMenu.setEnabled(false);
                        //Only allow to split if the current tab has a merged view
                        if (_qmMergedIndexes.containsKey(tabStr))
                            splitMenu.setEnabled(true);
                            Hashtable mergeHash = (Hashtable)_qmMergedIndexes.get(tabStr);
                            Enumeration enumeration = mergeHash.keys();
                            while (enumeration.hasMoreElements())
                                //Create a new menu item for each QM in View
                                String node = (String)enumeration.nextElement();
                                JMenuItem mergeItem = new JMenuItem(new AbstractAction(node)
                                    public void actionPerformed(ActionEvent e)
                                        //Work around for java bug in JTabbedPane
                                        _viewTabPane.setSelectedIndex(0);
                                        _viewTabPane.validate();
                                        //End workaround
                                        String splitTabName = e.getActionCommand();
                                        //Get the merge hash for this tab num
                                        Hashtable splitHash = (Hashtable)_qmMergedIndexes.get(tabStr);
                                        Enumeration enumeration = splitHash.keys();
                                        _viewTabPane.removeTabAt(tabNum);
                                                  int iIndexOfSplit = 0;
                                        while (enumeration.hasMoreElements())
                                            //Add new pane for the views in the hashtable
                                            String nodeAddress = (String)enumeration.nextElement();
                                                       String nodeName = m_model.getQMgrName(nodeAddress);
                                                       NavigatorTreePanel currentComp = (NavigatorTreePanel)splitHash.get(nodeAddress);
                                            addTabToDisplay(nodeName,nodeAddress,currentComp);
                                                       //Now if this tab this we just added is equal to the menu item of the split menu,
                                                       //store this so that we can give focus to it later
                                                       if (splitTabName.equals(nodeAddress))
                                                            iIndexOfSplit = _viewTabPane.getTabCount()-1;
                                        //Also remove it from our vector of merged tabs
                                        _qmMergedIndexes.remove(tabStr);
                                        //int mergeIndex = _viewTabPane.indexOfTab(splitTabName);
                                        //if (mergeIndex != -1)
                                                  if (iIndexOfSplit != -1)
                                            //_viewTabPane.setSelectedIndex(mergeIndex);
                                                       _viewTabPane.setSelectedIndex(iIndexOfSplit);
                                splitMenu.add(mergeItem);
                        popup.add(menuItem1);
                        popup.add(merge);
                        popup.add(splitMenu);
                        if (popup != null)
                            Point p = e.getPoint();
                            popup.show((Component)e.getSource(), (int)p.getX(), (int)p.getY());
                public void mouseEntered(MouseEvent e)
                public void mouseExited(MouseEvent e)
                public void mousePressed(MouseEvent e)
                public void mouseReleased(MouseEvent e)
               //Don't forget to add the tree's
               addTreeDisplays();
            _viewTabPane.addTab(StringFactory.getString("perspective.display.overview.tab"), _treeTabPane);
               _viewTabPane.addTab(StringFactory.getString("perspective.display.documentation.tab"), new DocDisplayPanel());
            _mainDisplayPanel.add(_viewTabPane, BorderLayout.CENTER);
        catch(Exception e)
            e.printStackTrace();
     private void addTabToDisplay(String nameStr, String toolStr, JComponent c)
          if (_viewTabPane == null)
               return;
          _viewTabPane.addTab(nameStr, c);
          int tabNum = _viewTabPane.getTabCount()-1;
          if (toolStr != null)
               _viewTabPane.setToolTipTextAt(tabNum, toolStr);
          _viewTabPane.setSelectedIndex(tabNum);
     private void addTreeDisplays()
          String starKey = StringFactory.getString(starviewKey);
          String treeKey = StringFactory.getString(treeviewKey);
          //navigatorTreePanel.expandTreePath(this, true);
          String test = MQEPreferencesDialog.getPreferenceValue("expand.leaf.startup");
          System.out.println("test{{{{{{{{{{"+test);
          //System.out.println("test{{{{{{{{{{"+m_nnode.);
          if (treeDisplayPreference == BOTH_DISPLAY)
               hyperbolicTreePanel = new HyperbolicTreePanel(m_model);
               hyperbolicTreePanel.addQMRequestListener(this);
               hyperbolicTreePanel.addTopologySelectionListener(this);
               //hyperbolicTreePanel.expandTreePath((TopologyModelNode)m_model.getRoot(), true);
               //hyperbolicTreePanel.expandTreePath(m_nnode, true);
               _treeTabPane.addTab("", IconFactory.getInstance().getIcon("staricon"), hyperbolicTreePanel, starKey);
               navigatorTreePanel = new NavigatorTreePanel(m_model);
               navigatorTreePanel.addQMRequestListener(this);
               navigatorTreePanel.addTopologySelectionListener(this);
               _treeTabPane.addTab("", IconFactory.getInstance().getIcon("treeicon"), navigatorTreePanel, treeKey);
          else if (treeDisplayPreference == TREE_DISPLAY)
               navigatorTreePanel = new NavigatorTreePanel(m_model);
               navigatorTreePanel.addQMRequestListener(this);
               navigatorTreePanel.addTopologySelectionListener(this);
               _treeTabPane.addTab("", IconFactory.getInstance().getIcon("treeicon"), navigatorTreePanel, treeKey);
          else
               hyperbolicTreePanel = new HyperbolicTreePanel(m_model);
               hyperbolicTreePanel.addQMRequestListener(this);
               hyperbolicTreePanel.addTopologySelectionListener(this);
               _treeTabPane.addTab("", IconFactory.getInstance().getIcon("staricon"), hyperbolicTreePanel, starKey);
    public void addTopologySelectionListener(TopologySelectionListener tsl)
        if (tsl != null)
            _tsListeners.add(tsl);
    public void removeTopologySelectionListener(TopologySelectionListener tsl)
        if (tsl != null)
            _tsListeners.remove(tsl);
    protected void fireTopologySelection(TopologyModelNode node)
        for (TopologySelectionListener tsl : _tsListeners)
            tsl.receiveTopologySelection(node);
   /* TopologySelectionListener methods                                     */
    public void receiveTopologySelection(TopologyModelNode node)
        //Since this panel can have multiple panels in it's current Tabbed display.
        //This class registers to each of the TopologyDisplayPanels as a listener for selections
        //This way no matter who is currently active, they will funnel the event to here and it this
        //panel will send the event on foward
        if (node != null)
            fireTopologySelection(node);
   /* QMRequestListener methods                                             */
    public void receiveQMRequest(TopologyModelNode node)
        //Check to see if this node is already in a Tab already
        System.out.println("Queue Manager request");
          boolean doesExist = false;
        int tabNum =0;
          //Fix for activity 00033248 TAB PANES FOR IDENTICAL QMANAGERS ON DIFF MACHINES
          //The only unique names are in the tooltips so lets just cycle through all the tabs
          //and search for this Queue Manager name.  Using indexOfTab in JTabbedPane will not
          //work here because it will return first location of a matching queue manager name, but
          //we could have multiple tabs open with same queue manager name.
          for (int i = 0; i < _viewTabPane.getTabCount();i++)
               String toolTipStr = _viewTabPane.getToolTipTextAt(i);
               //Using the string method for indexOf, covers us when we have a merged tab window
               if ((toolTipStr != null) && (toolTipStr.indexOf(((ResourceProxy)node).getAddress().trim()) != -1))
                    //We already have existing queue manager tab open
                    doesExist = true;
                    tabNum = i;
                    break;
          if ( !doesExist)
               //Create the tab
            NavigatorTreePanel treePanel = new NavigatorTreePanel(new ExpandingModelNode(node));
            treePanel.addTopologySelectionListener(this);
               // Add the tree panel to a container so that it can be accessed
               // for expand/collapse all and tree refresh actions.
               qmgrTreeDisplays.add(treePanel);
               //Fix for activity 00033248 TAB PANES FOR IDENTICAL QMANAGERS ON DIFF MACHINES
               addTabToDisplay(((ResourceProxy)node).getName().trim(), ((ResourceProxy)node).getAddress().trim(), treePanel);
            node.getModel().expandNode(node);
          else
               _viewTabPane.setSelectedIndex(tabNum);
   /* PropertyChangeListener methods                                        */
        public void propertyChange(PropertyChangeEvent evt){
          String propertyChanged = evt.getPropertyName();
          if (propertyChanged.equals(MQEDisplayPreferences.treeDisplayProperty)){
               int newPreference = ((Integer)evt.getNewValue()).intValue();
               changeTreeDisplays(newPreference);
          else if (propertyChanged.equals(MQEDisplayPreferences.expandLeafProperty)){
               // The enable leaf node preference has changed so update the MQE
               // tree displays according to the new preference setting.
               refreshTreeDisplays();
          else{
               // Ignore the property change event.
    * Changes the trees displayed by MQE according to
     * the preference set by the current user.
    * @param the new trees display preference.*/
     public void changeTreeDisplays(int preference)
          // Assign the new tree display preference.
          treeDisplayPreference = preference;
          // Recreate the tree display according
          // to the new preference.
          m_model.removeTreeModelListeners();
          _treeTabPane.removeAll();
          addTreeDisplays();
          refreshTreeDisplays();
    * Fully expands the Navigator display trees from the specified node.
    * @param the node from which each tree will be fully expanded.
     public void expandAll(TopologyModelNode node)
          node.expandAll();
          final TopologyModelNode fnode = node;
          Runnable doTask = new Runnable(){
               public void run(){
                    // Fire a tree structure changed notification for
                    // the StarTree, (1) because it will not display
                    // tree nodes correctly without it and (2) it appears
                    // to be the only tree interested in doing anything
                    // with it!
                    fnode.fireTreeStructureChanged(TopologyModel.STRUCTURE_CHANGE);
                    if (hyperbolicTreePanel != null)
                         hyperbolicTreePanel.expand(fnode);
                    if (navigatorTreePanel != null)
                         navigatorTreePanel.expand(fnode);
                    for (NavigatorTreePanel navTreePanel : qmgrTreeDisplays){
                         navTreePanel.expand(fnode);
          SwingUtilities.invokeLater(doTask);
    * Fully collapses the Navigator display trees from the specified node.
    * @param the node from which each tree will be fully collapsed.
     public void collapseAll(TopologyModelNode node)
          final TopologyModelNode fnode = node;
          Runnable doTask = new Runnable(){
               public void run(){
                    if (hyperbolicTreePanel != null)
                         hyperbolicTreePanel.collapse(fnode);
                    if (navigatorTreePanel != null)
                         navigatorTreePanel.collapse(fnode);
                    for (NavigatorTreePanel navTreePanel : qmgrTreeDisplays){
                         navTreePanel.collapse(fnode);
          SwingUtilities.invokeLater(doTask);
    * Will ensure that all tree nodes, starting from the root, are correctly displayed.
     public void refreshTreeDisplays()
          if (hyperbolicTreePanel != null){
               TopologyModel model = hyperbolicTreePanel.getTopologyModel();
               if (model != null){
                    hyperbolicTreePanel.expandTreePath((TopologyModelNode)model.getRoot(), true);
                    hyperbolicTreePanel.refreshTreeDisplay((TopologyModelNode)model.getRoot());
          if (navigatorTreePanel != null){
               TopologyModel model = navigatorTreePanel.getTopologyModel();
               if (model != null){
                    navigatorTreePanel.refreshTreeDisplay((TopologyModelNode)model.getRoot());
                    navigatorTreePanel.repaint();
          for (NavigatorTreePanel navTreePanel : qmgrTreeDisplays){
               ExpandingModelNode model = (ExpandingModelNode)navTreePanel.getNavigatorTreeModel();
               if (model != null){
                    navigatorTreePanel.expand((TopologyModelNode)model.getRoot());
                    navTreePanel.refreshTreeDisplay((TopologyModelNode)model.getRoot());
                    navTreePanel.repaint();
}

Answer 1

you really don't need to post all that code, few people will read it, or try to compile/run it.
just a tree in a scrollpane in a frame is all you need, then add the method/problem to the basic,
and post that so its only 20 to 30 lines long.
here's your basic tree/scrollpane/frame, with an expandAll()
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class Testing
  public void buildGUI()
    JTree tree = new JTree();
    expandAll(tree);
    JFrame f = new JFrame();
    f.getContentPane().add(new JScrollPane(tree));
    f.pack();
    f.setLocationRelativeTo(null);
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.setVisible(true);
  public void expandAll(JTree tree)
    int row = 0;
    while (row < tree.getRowCount())
      tree.expandRow(row);
      row++;
  public static void main(String[] args)
    SwingUtilities.invokeLater(new Runnable(){
      public void run(){
        new Testing().buildGUI();
}so, is your problem with the expandAll(), or with reading the properties file?