Getting the path of file selected in JTree item

[Bill Cappoli]

I'm working on creating a backup application. As part of it I'm displaying the file directory of the computer in a JTree. I have been able to get everything to appear in the JTree as t is supposed to. However, no matter what I try I cannot seem to get the path of the selected file. I want to use the path to than list the selected files in the GUI as pending backup. Below I have included the code for the class as it is now where it displays the file structure. Under that is the most recent attempt to read the path. Any ideas?

Thanks

 package com.bc.jbackup;

import java.io.File;
import java.util.Enumeration;
import java.util.Vector;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

public class FileDirectory implements TreeModel {
          private String root; // The root identifier
                  
          // Get a File object list of all of our drives
          File[] fRoots = File.listRoots();

          private Vector listeners; // Declare the listeners vector

          public FileDirectory() {

               root = System.getProperty("user.dir");

               File tempFile = new File(root);
                        
               // Root is going to start as a simple string
               root = "start";


               listeners = new Vector();
          }

          // Return our start string as root
          public Object getRoot() {
               return root;
          }

          public Object getChild(Object parent, int index) {
               // Check if this call is on our root string, if so, feed it an instance from the fRoots File object array
               if (parent instanceof String) { return fRoots[index]; }
               else {
                    // Otherwise process a branch as normal
                    File directory = (File) parent;
                    String[] directoryMembers = directory.list();
                    return (new File(directory, directoryMembers[index]));
               }
          }

          public int getChildCount(Object parent) {
               // Again, we are checking if this is a call with root string as parent, if so, give it the length of our File object array.
               if (parent instanceof String) { return fRoots.length; }
               else {
                    // Otherwise process as a normal file branch
                    File fileSystemMember = (File) parent;
                    if (fileSystemMember.isDirectory()) {
                         String[] directoryMembers = fileSystemMember.list();
                         return directoryMembers.length;
                    }

                    else {

                         return 0;
                    }
               }
          }

          public int getIndexOfChild(Object parent, Object child) {
               int result = -1;
               // Again check if parent is our root string, feed it the index from the fRoots array
               if (parent instanceof String) {
                    File theChild = (File) child;
                    for (int i = 0; i < fRoots.length; i++) {
                         if (child.equals(fRoots[i])) {
                              return i;
                         }
                    }
               }
               else {
                    File directory = (File) parent;
                    File directoryMember = (File) child;
                    String[] directoryMemberNames = directory.list();
                    

                    for (int i = 0; i < directoryMemberNames.length; ++i) {
                         if (directoryMember.getName().equals(directoryMemberNames[i])) {
                              result = i;
                              break;
                         }
                    } 
               }
               return result;
          }

          public boolean isLeaf(Object node) {
               // One last time checking if it is our root string node
               if (node instanceof String) { return false; }
               else {
                    return ((File) node).isFile();
               }
          }

          public void addTreeModelListener(TreeModelListener l) {
            if (l != null && !listeners.contains(l)) {
              listeners.addElement(l);
            }
          }

         public void removeTreeModelListener(TreeModelListener l) {
            if (l != null) {
              listeners.removeElement(l);
            }
          }

          public void valueForPathChanged(TreePath path, Object newValue) {
            // does nothing
          }

          public void fireTreeNodesInserted(TreeModelEvent e) {
            Enumeration listenerCount = listeners.elements();
            while (listenerCount.hasMoreElements()) {
              TreeModelListener listener = (TreeModelListener) listenerCount.nextElement();
              listener.treeNodesInserted(e);
            }
          }

          public void fireTreeNodesRemoved(TreeModelEvent e) {
            Enumeration listenerCount = listeners.elements();
            while (listenerCount.hasMoreElements()) {
              TreeModelListener listener = (TreeModelListener) listenerCount.nextElement();
              listener.treeNodesRemoved(e);
            }

          }

          public void fireTreeNodesChanged(TreeModelEvent e) {
            Enumeration listenerCount = listeners.elements();
            while (listenerCount.hasMoreElements()) {
              TreeModelListener listener = (TreeModelListener) listenerCount.nextElement();
              listener.treeNodesChanged(e);
            }

          }

          public void fireTreeStructureChanged(TreeModelEvent e) {
            Enumeration listenerCount = listeners.elements();
            while (listenerCount.hasMoreElements()) {
              TreeModelListener listener = (TreeModelListener) listenerCount.nextElement();
              listener.treeStructureChanged(e);
            }
          }
          
          
    }   

  public void valueChanged(TreeSelectionEvent e) {
                TreePath treepath = e.getPath();
                System.out.println("Java: " + treepath.getLastPathComponent());
                Object elements[] = treepath.getPath();
                for (int i = 0, n = elements.length; i < n; i++) {
                  System.out.print("->" + elements[i]);
                }
                System.out.println();
              }  

[Rob Spoor]

The model shouldn't care about its selection - that's part of the JTree. And that has a method called getSelectionPath() (or getSelectionPaths() for multiple selection).

[Bill Cappoli]

Rob Prime wrote:The model shouldn't care about its selection - that's part of the JTree. And that has a method called getSelectionPath() (or getSelectionPaths() for multiple selection).

Thanks for the tip. I ended up moving the selection listener outside of the TreeModel class and was able to grab it using this code in case anyone else has a similar problem:

  tree.addTreeSelectionListener(new TreeSelectionListener() {

        public void valueChanged(TreeSelectionEvent e) {

           TreePath tp = e.getNewLeadSelectionPath();
           if (tp != null)
              System.out.println("Selected:  "+tp.getLastPathComponent());
        }
     });