treefeld.java

JAVA－explorer

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

public class TreeFeld
  extends JPanel
  implements TreeSelectionListener , TreeExpansionListener {
  // Ansicht des Baumes (View/Controller)
  JTree treeView ;
  // Rollfeld fuer den Baum
  JScrollPane scrollpane ;
  Explorer ex ; // Referenz auf das Explorer-Fenster

  // Konstruktor
  public TreeFeld( Explorer exPar ) {
    this.ex = exPar ; // Referenz auf das Explorer-Fenster, der Explorer fuehrt das FocusDirectory mit

    // Instanzierung der Baumkomponente mit dem Datenmodell (an oberstem Knoten angeh刵gt)
    //treeView=new JTree(top);
    DirTree verzTree = new DirTree() ;
    // DirTree verzTree=new DirTree(System.getProperty("user.dir").substring(0,3));
    treeView = verzTree.getTree() ;

    // Einfuegen des Baumes ins Rollfeld
    setLayout( new BorderLayout() ) ;
    scrollpane = new JScrollPane( treeView ) ;
    add( scrollpane , BorderLayout.CENTER ) ;

    treeView.getSelectionModel().setSelectionMode( TreeSelectionModel.SINGLE_TREE_SELECTION ) ;
    treeView.addTreeSelectionListener( this ) ;
    treeView.addTreeExpansionListener( this ) ;
    treeView.putClientProperty( "JTree.lineStyle" , "Angled" ) ;
    treeView.setShowsRootHandles( true ) ;
    // treeView.setUI(TreeUI
    treeView.setSelectionRow( 0 ) ;
    ex.setTableDir( "\\" ) ;
  }

  /**
   * Setzen des TreeFeld auf ein Laufwerk<BR>
   * wird von {@link ToolLeiste#actionPerformed} &uuml;ber {@link Explorer#setRoot} aufgerufen
   */
  public void setRoot( String rootName ) {
    DirTree verzTree = new DirTree( rootName ) ;
    treeView = verzTree.getTree() ;
    // Entfernen des alten Baumes  removeAll entfernt alle angeh鋘gten Components von JPanel
    removeAll() ;

    // Einfuegen des Baumes ins Rollfeld
    setLayout( new BorderLayout() ) ;
    scrollpane = new JScrollPane( treeView ) ;
    add( scrollpane , BorderLayout.CENTER ) ;
    // treeView.validate();
    // treeView.reload();
    // treeView.setSelectionRow(0);

    treeView.getSelectionModel().setSelectionMode( TreeSelectionModel.SINGLE_TREE_SELECTION ) ;
    treeView.addTreeSelectionListener( this ) ;
    treeView.putClientProperty( "JTree.lineStyle" , "Angled" ) ;
    treeView.setShowsRootHandles( true ) ;
    // treeView.setUI(TreeUI
    // treeView.setSelectionRow(0);
    ex.setTableDir( rootName ) ;
  } // end method setRoot

  public void setSubDir( String neuDir ) {
    ex.setTitle( "Wechsel zu " + neuDir ) ;
    TreeNode focusNode = ex.getFocusNode() ;
    if ( focusNode.getChildCount() > 0 ) {
      for ( int i = 0 ; i < focusNode.getChildCount() ; i++ ) {
        if ( ( focusNode.getChildAt( i ).toString() ).equals( neuDir ) ) {
          treeView.getSelectionModel().setSelectionMode( TreeSelectionModel.SINGLE_TREE_SELECTION ) ;
          TreeNode nod = focusNode.getChildAt( i ) ;
          DefaultMutableTreeNode dfNod = ( DefaultMutableTreeNode ) nod ;
          TreePath trPth = new TreePath( dfNod.getPath() ) ;
          treeView.makeVisible( trPth ) ;
          treeView.expandPath( trPth ) ;
          treeView.scrollPathToVisible( trPth ) ;
          treeView.setSelectionPath( trPth ) ;
        }
      }
    }
  }

  /**
   * TreeSelectionListener implementieren
   * @param e
   */
  public void valueChanged( TreeSelectionEvent e ) {
    HNode node = ( HNode ) treeView.getLastSelectedPathComponent() ;
    if ( node == null ) {
      return ;
    }
    System.out.print( "SubTree " ) ;
    if ( node.getChildCount() < 1 ) {
      System.out.println( "einlesen" ) ;
      DirTree.addSubTree( node , node.getString() , 0 ) ;
      treeView.validate() ;
    }
    else {
      System.out.println( "nicht einlesen" ) ;
    }
    ex.setFocusNode( ( DefaultMutableTreeNode ) node ) ;
    Object[] pathStrArr = node.getUserObjectPath() ;
    String pathStr = node.getString() ;
    if ( ! ( pathStr == null ) ) {
      ex.setTitle( pathStr ) ;
    }
    if ( ! ( pathStr == null ) ) {
      ex.setTableDir( pathStr ) ;
    }
  }//end method

  public void treeCollapsed(TreeExpansionEvent event){;}

  public void treeExpanded(TreeExpansionEvent event){
System.out.println( "treeExpanded" );
    HNode node = ( HNode ) treeView.getLastSelectedPathComponent() ;
System.out.println( node.getString() );
    if ( node == null ) {
System.out.println( "return" ) ;
      return ;
    }
    //System.out.print( "SubTree " ) ;
    //if ( node.getChildCount() < 1 ) {
      //System.out.println( "einlesen" ) ;

      System.out.println( "SubTree einlesen" ) ;
      DirTree.addSubTree( node , node.getString() , -1 ) ;
treeView.updateUI();
      treeView.validate() ;
    //}
    //else {
      //System.out.println( "nicht einlesen" ) ;
    //}
  }//end method
}
// **********************************************

// import javax.swing.*;
// import javax.swing.tree.*;


// public class DirTree extends JTree{
class DirTree {
  JTree dirTree ;
  HNode top ;
  //int iDeep = 0 ;

  /**
   * Konstruktor
   */
  public DirTree() {
    String t = System.getProperty( "user.dir" ).substring( 0 , 3 ) ; //Laufwerksbuchstabe, Doppelpunkt und Backslash
    top = subTree( t , 0 ) ; // noch betriebssystem-unspezifische Loesung finden
    top.setString( t ) ;
    dirTree = new JTree( top ) ;
    //ex.setFocusNode( top ) ; ???
  }

  /**
   * Konstruktor
   * @param root
   */
  public DirTree( String root ) { // mit Angabe der root
    top = subTree( root , 0 ) ;
    top.setString( root ) ;
    dirTree = new JTree( top ) ;
    //ex.setFocusNode( top ) ; ???
    // top.reLoad();
  }

  /**
   *
   * @param sRoot
   * @param fName
   * @return
   */
  static synchronized HNode subTree( String fName , int iDeep ) {
    //iDeep++ ;
    System.out.println( fName ) ;
    //ex.setTitle( fName ) ; ??? evtl. sp鋞er wieder einbauen
    File sRoot = new File( fName ) ;
    HNode retHNode ;
    if ( sRoot.getName().equals( "" ) ) {
      retHNode = new HNode( fName ) ;
    }
    else {
      retHNode = new HNode( sRoot.getName() ) ;
    }
    retHNode.setString( fName ) ;
    // sRoot muss stets ein Directory sein
    if ( sRoot.isDirectory() ) {
      addSubTree( retHNode , fName , iDeep ) ;
    }
    //iDeep-- ;
    return retHNode ;
  } //end method subTree

  /**
   *
   * @param paHNode
   * @param pRoot
   */
  public static synchronized void addSubTree( HNode paHNode , String pFileName , int iDeep ) {
    iDeep++ ;
    if ( iDeep < 3 ) {
//alles L鰏chen
      //removeChildren( paHNode ) ;
      paHNode.removeAllChildren();

      File[] fListe = ( new File( pFileName ) ).listFiles() ;
      if ( fListe.length > 0 ) {
        fListe = noHiddenFiles( fListe ) ; // Entfernen aller Hidden-Files aus dem Array
        // Sortieren
        for ( int lauf = 0 ; lauf <= fListe.length ; lauf++ ) {
          for ( int pos = 0 ; pos < fListe.length - 1 ; pos++ ) {
            if ( fListe[ pos ].compareTo( fListe[ pos + 1 ] ) > 0 ) {
              File puffer = fListe[ pos ] ;
              fListe[ pos ] = fListe[ pos + 1 ] ;
              fListe[ pos + 1 ] = puffer ;
            }
          }
        }

        for ( int i = 0 ; i < fListe.length ; i++ ) {
          if ( fListe[ i ].isDirectory() ) {
            HNode toe = subTree( dirCat( pFileName , fListe[ i ].getName() ) , iDeep ) ;
            // System.out.println(fName+"\\"+fListe[i].getName());
            toe.setString( dirCat( pFileName , fListe[ i ].getName() ) ) ;
            toe.setUserObject( fListe[ i ].getName() ) ;
            paHNode.add( ( DefaultMutableTreeNode ) toe ) ;
          }
        }
      }
    }
  } //end method

  /**
   *
   * @param paHNode
   */
  public static void removeChildren( HNode paHNode ) {
    while ( paHNode.getChildCount() > 0 ) {
      paHNode.remove( 0 ) ;
    }
  }//end method

  /**
   * Erzeugen eines File-Arrays ohne Hidden-Files aus dem Parameter-File-Array
   */
  public static File[] noHiddenFiles( File[] parFileArr ) {
    int anz = 0 ;
    File[] retFileArr ;
    for ( int i = 0 ; i < parFileArr.length ; i++ ) {
      if ( !parFileArr[ i ].isHidden() ) {
        anz++ ;
      }
    }

    retFileArr = new File[ anz ] ;

    int retFileArrPtr = 0 ;
    for ( int i = 0 ; i < parFileArr.length ; i++ ) {
      if ( !parFileArr[ i ].isHidden() ) {
        retFileArr[ retFileArrPtr ] = parFileArr[ i ] ;
        retFileArrPtr++ ;
      }
    }

    return retFileArr ;
  } // end method noHiddenFiles

  /**
   *
   * @return
   */
  public JTree getTree() {
    return dirTree ;
  }

  /**
   * Verketten (concatenate) zweier Dir-Namen unter Beachtung evtl. vorhandener Backslash磗
   * @param s1
   * @param s2
   * @return
   */
  public static String dirCat( String s1 , String s2 ) {
    String t = new String( s1 ) ;
    // System.out.println("Trenner "+t.substring(t.length()-1));
    if ( ! ( t.substring( t.length() - 1 ).equals( "\\" ) ) ) {
      t += "\\" ;
    }
    return t + s2 ;
  }
} //end class

// **********************************************

class HNode
  extends DefaultMutableTreeNode {
  String str = "" ;
  public HNode( String s ) {
    super( s ) ;
    str = s ;
  }

  public String getString() {
    return str ;
  }

  public void setString( String s ) {
    str = s ;
  }
} //end class HNode