hostfilesystemview.java

将用户指定的数据保存成一个iso文件

/*
 * HostFileSystemView.java
 *
 * Created on November 21, 2002, 9:16 AM
 */

package jcdwriter.ui;

import javax.swing.*;
import javax.swing.tree.*;
import java.io.File;
import java.net.InetAddress;
import java.awt.Cursor;
import java.util.*;
import java.awt.Toolkit;
import java.awt.Image;
import java.awt.datatransfer.StringSelection;
import java.awt.dnd.*;
import java.awt.Point;
import jcdwriter.model.*;
/**
 *
 * @author  Ram Mallapp
 */
public class HostFileSystemView extends javax.swing.JPanel implements javax.swing.event.TreeWillExpandListener, javax.swing.event.TreeExpansionListener, java.awt.dnd.DragGestureListener{
    
    /** Creates new form HostFileSystemView */
    public HostFileSystemView() {
        DefaultTreeCellRenderer treeCellRenderer;
        
        initComponents();
        initializeFileSystemRoots();
        treeCellRenderer = (DefaultTreeCellRenderer)directoryTree.getCellRenderer();
        // get default icons from JTree to use in fileList before changing.
        dirIcon = treeCellRenderer.getClosedIcon();
        fileIcon = treeCellRenderer.getLeafIcon();
        dragCursorImage = Toolkit.getDefaultToolkit().getImage(this.getClass().getResource("/jcdwriter/images/drag_icon.png"));
        dragCursor = Toolkit.getDefaultToolkit().createCustomCursor(dragCursorImage, new Point(0, 0), "MyCursor");
        
        // now change the icons for the directory tree.
        treeCellRenderer.setLeafIcon(treeCellRenderer.getClosedIcon());
        
        //set default model and icons for the fileList.
        fileList.setModel(new DefaultListModel());
        ((DefaultListCellRenderer)fileList.getCellRenderer()).setIcon(fileIcon);
        
        directoryTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
        
        dragSource = DragSource.getDefaultDragSource();
        
        // component, action, listener
        dragSource.createDefaultDragGestureRecognizer(directoryTree, DnDConstants.ACTION_COPY_OR_MOVE, this );
        dragSource.createDefaultDragGestureRecognizer(fileList, DnDConstants.ACTION_COPY_OR_MOVE, this );
    }
    
    private void initializeFileSystemRoots(){
        DefaultMutableTreeNode branchNode, rootNode = null;
        String rootName;
        
        File fileSystemRoots[] = File.listRoots();
        try {
            rootName = InetAddress.getLocalHost().getHostName();
        }
        catch(java.net.UnknownHostException uhe) {
            rootName = "Root";
        };
        rootNode = new DefaultMutableTreeNode(rootName);
        for(int i = 0; i < fileSystemRoots.length; i++) {
            branchNode = new DefaultMutableTreeNode((fileSystemRoots[i].getPath()).replace('\\', '/'));
            branchNode.add(new DefaultMutableTreeNode("Loading..."));
            rootNode.add(branchNode);
        }
        ((DefaultTreeModel)directoryTree.getModel()).setRoot(rootNode);
        
        /*Remove the transfer handler so that it does not do its own copy/paste.
         This was causing exception when nothing in the JTree is selected.*/
        directoryTree.setTransferHandler(null);
        
    }
    
    private void initComponents() {
        dirAndFilesSplitPane = new javax.swing.JSplitPane();
        dirTreeScrollPane = new javax.swing.JScrollPane();
        directoryTree = new javax.swing.JTree();
        fileListScrollPane = new javax.swing.JScrollPane();
        fileList = new javax.swing.JList();
        
        setLayout(new java.awt.BorderLayout());
        
        dirAndFilesSplitPane.setDividerSize(5);
        dirAndFilesSplitPane.setMaximumSize(null);
        dirAndFilesSplitPane.setMinimumSize(new java.awt.Dimension(150, 100));
        dirAndFilesSplitPane.setPreferredSize(new java.awt.Dimension(300, 150));
        dirTreeScrollPane.setMaximumSize(null);
        dirTreeScrollPane.setMinimumSize(new java.awt.Dimension(150, 150));
        directoryTree.setMaximumSize(null);
        directoryTree.setMinimumSize(null);
        directoryTree.setPreferredSize(null);
        directoryTree.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyReleased(java.awt.event.KeyEvent evt) {
                directoryTreeKeyReleased(evt);
            }
        });
        
        directoryTree.addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
            public void mouseDragged(java.awt.event.MouseEvent evt) {
                directoryTreeMouseDragged(evt);
            }
        });
        
        directoryTree.addTreeSelectionListener(new javax.swing.event.TreeSelectionListener() {
            public void valueChanged(javax.swing.event.TreeSelectionEvent evt) {
                directoryTreeValueChanged(evt);
            }
        });
        
        directoryTree.addTreeWillExpandListener(new javax.swing.event.TreeWillExpandListener() {
            public void treeWillExpand(javax.swing.event.TreeExpansionEvent evt)
            throws javax.swing.tree.ExpandVetoException {
                directoryTreeTreeWillExpand(evt);
            }
            public void treeWillCollapse(javax.swing.event.TreeExpansionEvent evt)
            throws javax.swing.tree.ExpandVetoException {
            }
        });
        
        dirTreeScrollPane.setViewportView(directoryTree);
        
        dirAndFilesSplitPane.setLeftComponent(dirTreeScrollPane);
        
        fileListScrollPane.setMaximumSize(null);
        fileListScrollPane.setMinimumSize(new java.awt.Dimension(10, 10));
        fileListScrollPane.setViewportView(fileList);
        
        dirAndFilesSplitPane.setRightComponent(fileListScrollPane);
        
        add(dirAndFilesSplitPane, java.awt.BorderLayout.CENTER);
        
    }
    
    private void directoryTreeMouseDragged(java.awt.event.MouseEvent evt) {
        int i = 1 + 2;        // Add your handling code here:
    }
    
    private void directoryTreeKeyReleased(java.awt.event.KeyEvent evt) {
        if ((evt.getModifiers() == java.awt.event.KeyEvent.CTRL_MASK) && (evt.getKeyCode() == java.awt.event.KeyEvent.VK_C)) {
            copySelectionToClipboard();
        }
        else {
            if (evt.getKeyCode() == java.awt.event.KeyEvent.VK_F5) {//See if user is trying to refresh directory contents.
                TreePath aPath = (TreePath) directoryTree.getSelectionPath();
                DefaultMutableTreeNode selNode = getSelectedNode();
                if (aPath != null)  {
                    populateDirectoryPath(aPath);
                    refreshFileListForPath(aPath);
                    ((DefaultTreeModel)directoryTree.getModel()).reload(selNode);
                }
            }
        }
    }
    
    private DefaultMutableTreeNode getSelectedNode(){
        if (directoryTree.getSelectionPath() == null)
            return null;
        else
            return (DefaultMutableTreeNode) directoryTree.getSelectionPath().getLastPathComponent();
    }
    
    private void copySelectionToClipboard(){
        TreePath[]     selectedPaths;
        StringBuffer   selPathsBuffer = new StringBuffer();
        selectedPaths = directoryTree.getSelectionPaths();
        if (selectedPaths != null) {
            for(int i=0; i < selectedPaths.length; i++){
                selPathsBuffer.append(pathToString(selectedPaths[i].getPath()));
                selPathsBuffer.append(clipboardDelimiter);
            }
        }
        saveStringToClipboard(selPathsBuffer.toString());
    }
    
    private void saveStringToClipboard(String aString){
        getClipboard().setContents(new StringSelection(aString), null);
    }
    
    private void directoryTreeValueChanged(javax.swing.event.TreeSelectionEvent evt) {
        try {
            refreshFileListForPath(evt.getPath());
        }
        catch (Exception e) {
            System.out.println("Exception in directoryTreeValueChanged.");
        }
    }
    
    private void directoryTreeTreeWillExpand(javax.swing.event.TreeExpansionEvent evt) throws javax.swing.tree.ExpandVetoException {
        setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
        populateDirectoryPath(evt.getPath());
        setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
    }
    
    private void refreshFileListForPath(TreePath path){
        DefaultMutableTreeNode selectedDirNode;
        File selectedDir;
        File[] dirContents;
        ListModel listModel;
        Vector aVector = new Vector();
        Iterator anIterator;
        
        try {
            selectedDirNode = (DefaultMutableTreeNode)path.getLastPathComponent();
            selectedDir = new File(pathToString(path.getPath()));
            dirContents = selectedDir.listFiles();
            listModel = fileList.getModel();
            ((DefaultListModel)listModel).clear();
            if (dirContents != null){
                for(int i=0; i < dirContents.length; i++) {
                    if(dirContents[i].isDirectory() == false) {
                        aVector.add(dirContents[i].getName());
                    }
                }
            }
            Collections.sort(aVector);
            anIterator = aVector.iterator();
            while(anIterator.hasNext()){
                ((DefaultListModel)listModel).addElement(anIterator.next());
            }
        }
        catch(Exception e) {
            System.out.println(e);
        }
        finally {
        }
    }
    
    private void populateDirectoryPath(TreePath path){
        /*Empty all children (if any) at the last node in the given path and reload actual contents (directories)*/
        ArrayList dirContents;
        DefaultMutableTreeNode nodeToPopulate;
        File dirToExapand;
        
        try {
            nodeToPopulate = (DefaultMutableTreeNode)path.getLastPathComponent();
            dirToExapand = new File(pathToString(path.getPath()));
            dirContents = contentNodesForDir(dirToExapand);
            nodeToPopulate.removeAllChildren();
            for(int i=0; i < dirContents.size(); i++) {
                nodeToPopulate.add((DefaultMutableTreeNode)dirContents.get(i));
            }
        }
        catch(Exception e) {
            System.out.println(e);
        }
        finally {
        }
    }
    
    private ArrayList contentNodesForDir(File dir) {
        ArrayList list = new ArrayList();
        DefaultMutableTreeNode node;
        
        File contents[] = dir.listFiles();
        if (contents != null) {
            for(int i = 0; i < contents.length; i++) {
                if(contents[i].isDirectory() && !(contents[i].isHidden())) {
                    node = new DefaultMutableTreeNode(contents[i].getName());
                    node.add(new DefaultMutableTreeNode("Loading..."));
                    list.add(node);
                }
            }
        }
        return list;
    }
    
    private String pathToString(Object path[]) {
        StringBuffer s = new StringBuffer();
        for(int i = 1; i < path.length; i++) {
            s.append(path[i]);
            if(i > 1 && i < path.length) s.append(pathSeparator);
        }
        return s.toString();
    }
    public java.awt.datatransfer.Clipboard getClipboard() {
        return Clipboard.defaultInstance();
    }
    
    public void treeCollapsed(javax.swing.event.TreeExpansionEvent treeExpansionEvent) {
    }
    
    public void treeExpanded(javax.swing.event.TreeExpansionEvent treeExpansionEvent) {
    }
    
    public void treeWillCollapse(javax.swing.event.TreeExpansionEvent treeExpansionEvent) throws javax.swing.tree.ExpandVetoException {
    }
    
    public void treeWillExpand(javax.swing.event.TreeExpansionEvent treeExpansionEvent) throws javax.swing.tree.ExpandVetoException {
    }
    
    public void dragGestureRecognized(java.awt.dnd.DragGestureEvent dragGestureEvent) {
        Point dragOrigin = dragGestureEvent.getDragOrigin();
        StringBuffer draggedPaths = new StringBuffer();
        String aPathStr = null, draggedPathString = null;
        TreePath draggedPath;
        
        if (dragGestureEvent.getComponent() == directoryTree) {
            draggedPath = (TreePath)(((JTree)(dragGestureEvent.getComponent())).getPathForLocation((int)dragOrigin.getX(), (int)dragOrigin.getY()));
            if(draggedPath != null) draggedPaths.append(pathToString(draggedPath.getPath()));
        }
        else {
            Object[] selections = ((JList)dragGestureEvent.getComponent()).getSelectedValues();
            TreePath selectedTreePath;
            
            selectedTreePath = directoryTree.getSelectionPath();
            draggedPathString = pathToString(selectedTreePath.getPath());
            for (int i=0; i < selections.length; i++) {
                draggedPaths.append(draggedPathString);
                draggedPaths.append(selections[i]);
                draggedPaths.append(clipboardDelimiter);
            }
        }
        saveStringToClipboard(draggedPaths.toString());
        //        System.out.println(draggedPaths.toString());
        dragGestureEvent.startDrag(dragCursor, new StringSelection(aPathStr));
    }
    
    private javax.swing.JScrollPane dirTreeScrollPane;
    private javax.swing.JScrollPane fileListScrollPane;
    private javax.swing.JSplitPane dirAndFilesSplitPane;
    private javax.swing.JList fileList;
    private javax.swing.JTree directoryTree;
    private java.lang.String pathSeparator = "/";
    private javax.swing.Icon  dirIcon;
    private javax.swing.Icon  fileIcon;
    private String clipboardDelimiter = "|";
    private DragSource dragSource;
    private DragGestureListener dgListener;
    private DragSourceListener dsListener;
    private Image              dragCursorImage;
    private Cursor             dragCursor;
}