filesystemmodel.java

来自「这个小软件( RealEditor )是同学一起编写的」· Java 代码 · 共 365 行

package com.ecust.swing;

//FileSystemModel.java
//TreeModel implementation using File objects as tree nodes.
//package com.deitel.advjhtp1.mvc.tree.filesystem;

//Java core packages
import java.io.*;
import java.util.*;

//Java extension packages
//import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;

public class FileSystemModel implements TreeModel {

    // hierarchy root
    private File root;
    
    // TreeModelListeners
    private Vector< TreeModelListener > listeners = new Vector< TreeModelListener >();
    
    // FileSystemModel constructor
    public FileSystemModel( File rootDirectory ) {
      root = rootDirectory;
    }   
    
    // get hierarchy root (root directory)
    public Object getRoot() {
       return root;
    }
    
    // get parent's child at given index
    public Object getChild( Object parent, int index ) {      
       // get parent File object
       File directory = ( File ) parent;
       
       // get list of files in parent directory
       String[] children = directory.list();
             
       
       
       
       if ( children.length > 1 ) {
           
           String s = "";
           int j = 0;
           int count = 0;
           
           out:
           for ( int i = 0; i < children.length; i++ ) {
                              
               if ( new File( directory.getAbsolutePath() + "/" + children[ i ] ).isDirectory() ) {
                   count++;
                   
                   while ( new File( directory.getAbsolutePath() + "/" + children[ j ] ).isDirectory() ) {
                       if ( j == children.length - 1 )
                           break out;
                       
                       j++;                    
                   }
                   
                   if ( !new File( directory.getAbsolutePath() + "/" + children[ j ] ).isDirectory() &&
                           j < i ) {
                       s = children[ j ];
                       children[ j ] = children[ i ];
                       children[ i ] = s;
                   }
               }
               
           }
                      
           String[] subChildren = new String[ children.length - count ];
           
           for ( int i = count, t = 0; i < children.length; i++, t++ ) {
              
                  
              subChildren[ t ] = children[ i ];
              
           }
           
           
           
           Arrays.sort( 
                   subChildren, 
                   new Comparator< String >() {
                       
                       public int compare( String s1, String s2 ) {
                           
                           String extension1 = "";
                           
                           String extension2 = "";
                                                      
                           if ( s1.lastIndexOf( "." ) != -1 ) {
                               extension1 = s1.substring( s1.lastIndexOf( "." ) );
                           } 
                                                        
                           if ( s2.lastIndexOf( "." ) != -1 ) {
                               extension2 = s2.substring( s2.lastIndexOf( "." ) );
                           } 
                                                          
                           return extension1.compareToIgnoreCase( extension2 );
                               
                       }
                       
                   }
                   
           );
           
           ArrayList< String > extensions =
               new ArrayList< String >();
           
           for ( int i = 0; i < subChildren.length; i++ ) {
               
               if ( subChildren[ i ].lastIndexOf( "." ) != -1 ) {
                   String extension = 
                       subChildren[ i ].substring( subChildren[ i ].lastIndexOf( "." ) );
                   
                   extensions.add( extension );
                   
               } else {
                   extensions.add( " " );
               }
               
                             
           }
           
           
           
           
           String extension = "+";
           ArrayList< Integer > indexs =
               new ArrayList< Integer >();
           
           for ( int i = 0; i < extensions.size(); i++ ) {
               
               if ( extension.compareToIgnoreCase( extensions.get( i ) ) != 0 ) {
                   extension = extensions.get( i );
                   indexs.add( i );
               }
               
           }
           
           
           
           for ( int i = 0; i < indexs.size(); i++ ) {
               
               String[] tmpArray;
               if ( i != indexs.size() - 1 ) {
                   tmpArray = 
                       new String[ indexs.get( i + 1 ) - indexs.get( i ) ];
               } else {
                   tmpArray = 
                       new String[ extensions.size() - 1 - indexs.get( i ) ];
               }
               
               for ( int t = 0; t < tmpArray.length; t++ ) {
                   tmpArray[ t ] = subChildren[ t + indexs.get( i ) ];
               }
               
               Arrays.sort( tmpArray, new Comparator< String >() {
                           public int compare( String s1, String s2 ) {
                               String filename1 = "";
                               String filename2 = "";
                               
                               if ( s1.lastIndexOf( "." ) != -1 ) {
                                   filename1 = 
                                       s1.substring( 0, s1.lastIndexOf( "." ) );                                  
                               } else {
                                   filename1 = s1;
                               }
                               
                               if ( s2.lastIndexOf( "." ) != -1 ) {
                                   filename2 = 
                                       s2.substring( 0, s2.lastIndexOf( "." ) );                                  
                               } else {
                                   filename2 = s2;
                               }
                               
                               
                               return filename1.compareToIgnoreCase( filename2 );
                           }                          
                       }                     
               );
               
               for ( int t = 0; t < tmpArray.length; t++ ) {
                   subChildren[ t + indexs.get( i ) ]  = tmpArray[ t ];
               }
               
           }
           
           
           
                                 
           for ( int i = count, t = 0; i < children.length; i++, t++ ) {
               
               
               children[ i ] = subChildren[ t ];
               
            }
                                 
       }
              
       // return File at given index and override toString
       // method to return only the File's name
       return new TreeFile( directory, children[ index ] );
    }
    
    // get parent's number of children
    public int getChildCount( Object parent ) {
       // get parent File object
       File file = ( File ) parent;
       
       // get number of files in directory
       if ( file.isDirectory() ) {
          
          String[] fileList = file.list();
          
          if ( fileList != null )
             return file.list().length;
       }
       
       return 0; // childCount is 0 for files
    }
    
    // return true if node is a file, false if it is a directory
    public boolean isLeaf( Object node ) {
       File file = ( File ) node;
       return file.isFile();
    }
    
    // get numeric index of given child node
    public int getIndexOfChild( Object parent, Object child ) {
       // get parent File object
       File directory = ( File ) parent;
       
       // get child File object
       File file = ( File ) child;
       
       // get File list in directory
       String[] children = directory.list();
       
       // search File list for given child
       for ( int i = 0; i < children.length; i++ ) {
          
          if ( file.getName().equals( children[ i ] ) ) {
             
             // return matching File's index
             return i;
          }
       }
       
       return -1; // indicate child index not found
    
    } // end method getIndexOfChild
    
    // invoked by delegate if value of Object at given
    // TreePath changes
    public void valueForPathChanged( TreePath path, Object value ) {
       // get File object that was changed
       File oldFile = ( File ) path.getLastPathComponent();
       
       // get parent directory of changed File
       String fileParentPath = oldFile.getParent();
       
       // get value of newFileName entered by user
       String newFileName = ( String ) value;
       
       // create File object with newFileName for 
       // renaming oldFile
       File targetFile = new File( 
          fileParentPath, newFileName );
      
       // rename oldFile to targetFile
       oldFile.renameTo( targetFile );
       
       // get File object for parent directory
       File parent = new File( fileParentPath );
       
       // create int array for renamed File's index
       int[] changedChildrenIndices = 
          { getIndexOfChild( parent, targetFile) };
          
       // create Object array containing only renamed File
       Object[] changedChildren = { targetFile };
          
       // notify TreeModelListeners of node change
       fireTreeNodesChanged( path.getParentPath(), 
          changedChildrenIndices, changedChildren );      
    
    } // end method valueForPathChanged
    
    // notify TreeModelListeners that children of parent at
    // given TreePath with given indices were changed
    private void fireTreeNodesChanged( TreePath parentPath, 
       int[] indices, Object[] children ) {
       // create TreeModelEvent to indicate node change
       TreeModelEvent event = new TreeModelEvent( this,
          parentPath, indices, children );
          
       Iterator iterator = listeners.iterator();      
       TreeModelListener listener = null;         
       
       // send TreeModelEvent to each listener 
       while ( iterator.hasNext() ) {
          listener = ( TreeModelListener ) iterator.next();
          listener.treeNodesChanged( event );
       }      
    } // end method fireTreeNodesChanged
    
    // add given TreeModelListener 
    public void addTreeModelListener( TreeModelListener listener ) {
       listeners.add( listener );
    }
    
    // remove given TreeModelListener
    public void removeTreeModelListener( TreeModelListener listener ) {
       listeners.remove( listener );
    }
       
    // TreeFile is a File subclass that overrides method
    // toString to return only the File name. 
    private class TreeFile extends File {
    
       /**
         * 
         */
        private static final long serialVersionUID = 3718277224199379412L;
    
    // TreeFile constructor
       public TreeFile( File parent, String child ) {
          super( parent, child );
       }
    
       // override method toString to return only the File name
       // and not the full path
       public String toString() {
          return getName();
       }
    } // end inner class TreeFile
}

class Extension {
    
    private String extension = "";
    private int index = -1;
    
    public Extension( String extension, int index ) {
        this.extension = extension;
        this.index = index;
    }
    
    public String getExtension() {
        return extension;
    }
    
    public int getIndex() {
        return index;
    }
}