filesystemmodel.java

WAP ide 代码

package wapide;

import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.io.File;
import java.util.*;

/**
 * A custom tree model for displaying the file system tree.  This code was taken
 *  from the Pure JFC Swing book published by SAMS.  It still needs to be changed
 *  to provide a more professional view of the file tree.  At the moment the
 *  directories and files show their full qualified paths.  This does not look
 *  professional and will be modified in sub-sequent versions of thos class.
 *  Copyright (c) 2001
 *  @author Pure JFC Swing - to be modified by Mark Busman.
 *  @version 1.x - to be given a definite number when modified by Mark Busman.
 */

class FileSystemModel implements TreeModel {
    private String root;   // The root identifier
    private Vector listeners; // Declare the listeners vector

    /** Constructor - creates a new FileSystemModel object.
     *  with as starting point the home directory of the file system.*/
    public FileSystemModel() {
        // Get the home directory on your system.
        root = System.getProperty("user.home");

        // For Windows 95, root is set to C:\ ("usr.home"
        // retrieves C:\WIN95).
        // You may implement a snippet like this for other OS also
        // like Windows NT, Macintosh, and so on.
        if (System.getProperty("os.name").indexOf("Window") == 0) {
            File tempFile = new File(root);
            root = tempFile.getParent();
            //System.out.println(root);
            //root = "C:\\";
        }

        // Define the listeners vector.
        listeners = new Vector();
    }

    /** Constructor - creates a new FileSystemModel object.  This time with
     *  a defined starting point.
     *  @param String dir - Starting directory.
     */
    public FileSystemModel(String dir) {

        root = dir;

        // Define the listeners vector.
        listeners = new Vector();
    }

    /** Retrieves the root of the tree hierarchy.*/
    public Object getRoot() {
        return (new File(root));
    }

    /** Retrieves the members in a directory based on an index.
     *  @return Object file - A new file object with the current node path and node name.
     *  */
    public Object getChild(Object parent, int index) {
        File directory = (File) parent;
        String[] directoryMembers = directory.list();
        //System.out.println(directoryMembers[index]);
        return (new File(directory, directoryMembers[index]));
    }

    /** Retrieves the member count in a directory.
     *  @return int count - the Member count.
     */
    public int getChildCount(Object parent) {
        File fileSystemMember = (File) parent;
             // fileSystemMember is a directory or file.

        // If a file system member is a directory.
        if (fileSystemMember.isDirectory()) {
            String[] directoryMembers = fileSystemMember.list();

            // Get the count of members in the directory.
            return directoryMembers.length;
        }

        // If the file system member is a file.
        else {
            // Return the member count as zero.
            return 0;
        }
    }

    /** Returns the index of a given member in its directory.
     *  @return int MemberIndex
     */
    public int getIndexOfChild(Object parent, Object child) {
        File directory = (File) parent;
        File directoryMember = (File) child;
        String[] directoryMemberNames = directory.list();
        int result = -1;

        for (int i = 0; i<directoryMemberNames.length; ++i) {
            if ( directoryMember.getName().equals(
                                 directoryMemberNames[i] ) ) {
                result = i;
                break;
            }
        }
        // If no member with such name in the directory.
        return result;
    }

    /** Indicates whether a directory member is a tree leaf.
     *  @return boolean isLeaf
    */
    public boolean isLeaf(Object node) {
         return ((File) node).isFile();
    }

    /** Method to add a tree model listener.*/
    public void addTreeModelListener(TreeModelListener l) {
        if (l != null && !listeners.contains(l)) {
            listeners.addElement(l);
        }
    }

    /** Method to remove a tree model listener.*/
    public void removeTreeModelListener(TreeModelListener l) {
        if (l != null) {
            listeners.removeElement(l);
        }
    }

    /** A dumb method.*/
    public void valueForPathChanged(TreePath path, Object newValue) {
        // Does Nothing!
    }

    // Additional methods that fire events whenever the model is
    // subjected to change. Possible changes can be nodes
    // inserted, nodes removed, structure changed, and so on.
    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);
        }

    }
}