filetree.java

JTree的视图展示：记录树的展开状况

package fileTree;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.File;
import java.util.Iterator;
import java.util.Set;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import javax.swing.JTree;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

/**
 * 测试类：资源管理器
 * @author hyj
 *
 */
public class FileTree extends JFrame {
	
	private JTextField jTextField1 = new JTextField();
	
	// 根路径
	private static String ROOTPATH = "F:\\"; 
	
	private JButton backButton = new JButton("Back");
	
	private JButton forwardButton = new JButton("Forward");
	
	private JButton upButton = new JButton("Up");

	private JTree jTree1;

	private JScrollPane jScrollPane1 = new JScrollPane();
	
	private TreeViewContainer viewContainer;
	
	// 记录Go Into操作的节点，在up时一直保持该节点处于展开状态
	private TreeNode goIntoNode;
	
	// 树的根节点
	private ExplorerTreeNode initRootNode;
	
	private TreeView view;
	
	/**
	 *
	 */
	public FileTree() {
		super("我的电脑");

		try {
//			UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
			jbInit();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

	/**
	 * 
	 * @throws Exception
	 */
	private void jbInit() throws Exception {
		// 初始化JTree
		initTree();

		// 初始化工具面板
		JPanel panel = buildToolPanel();
		
		Container container = getContentPane();
		
		container.add(panel, BorderLayout.NORTH);
		jScrollPane1.getViewport().add(jTree1);
		container.add(jScrollPane1, BorderLayout.CENTER);
		
		view = new TreeView(initRootNode, null);
		viewContainer = new TreeViewContainer();
		viewContainer.addView(0, view);
	}
	
	/**
	 * 构造树
	 */
	private void initTree() {

		initRootNode = new FileTreeNode(new File(ROOTPATH));
		//先展开根节点
		initRootNode.expand();
		
		jTree1 = new JTree(new DefaultTreeModel(initRootNode));
		jTree1.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
		
		jTree1.setRootVisible(false);
		jTree1.setShowsRootHandles(true);
		jTree1.addTreeExpansionListener(new FileTreeExpansionListener());
		jTree1.addMouseListener(new treeMouseListener());
		
		jTree1.setBorder(BorderFactory.createEtchedBorder());
		jTree1.setCellRenderer(new FileTreeCellRenderer());
	}
	
	/**
	 * 如果节点没有展开过，构造该节点的数据，展开节点
	 * @param node
	 */
	public void expandNode(TreeNode node) {
		((ExplorerTreeNode) node).expand();	
		// 通知监听器，树发生改变
		getTreeModel().nodeStructureChanged(node);
	}
	
	/**
	 * 通过更新Model，重新构造树
	 * @param treeNode : 当前树的根节点
	 */
	public void updateTreeModel(TreeView view){		
		DefaultTreeModel model = getTreeModel();
		TreeNode root = view.getRootNode();
		model.setRoot(root);

		// 展开根节点
		expandNode(root);
		
		// 点击up时，强制展开节点
		if(view.getForceExpandNode() != null){
			makeNodeVisible(view.getForceExpandNode());
		} else {		// back或forward时，展开原视图中状态为展开的节点
			Set set = view.getHasExpandedNode();
			for (Iterator iter = set.iterator(); iter.hasNext();) {
				jTree1.expandPath((TreePath) iter.next());
			}
		}

		setUpButtonEnable(root);
		jTextField1.setText(root.toString());
	}
	
	/**
	 * 右键弹出菜单
	 * @param x
	 * @param y
	 */
	private void showMenu(int x, int y) {
		JPopupMenu popup = new JPopupMenu();
		JMenuItem mi = new JMenuItem("Go Into");
		popup.add(mi);
		mi.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent e) {
				// 当前右键作用的节点
				TreeNode treeNode = (TreeNode) jTree1.getSelectionPath().getLastPathComponent();
				// 　如果有子节点
				if(!treeNode.isLeaf()){		
					view = new TreeView(treeNode);
					updateTreeModel(view);
					viewContainer.addView(view);			
					goIntoNode = treeNode;
					
					backButton.setEnabled(true);
					upButton.setEnabled(true);
					forwardButton.setEnabled(false);
				}	
			}

			});
		
		popup.show(jTree1, x, y);
	}
	
	/**
	 * 按钮事件监听器
	 * 
	 * @author Administrator
	 * 
	 */
	class BtnActionLister implements ActionListener{
		
		public void actionPerformed(ActionEvent e) {
			if(e.getSource() == backButton){		// back按钮事件处理			
				viewContainer.privious();
				
				if(viewContainer.isFirst()){
					backButton.setEnabled(false);
				}
				
				view = (TreeView) viewContainer.getView();
				// 更新树的根节点为上一个视图中的根节点
				updateTreeModel(view);
				
				forwardButton.setEnabled(true);
				
			} else if(e.getSource() == forwardButton){		// Forward按钮事件处理
				viewContainer.next();
				if(viewContainer.isLast()) {
					forwardButton.setEnabled(false);
				}
				
				view = (TreeView) viewContainer.getView();
				//	更新树的根节点为下一个视图中的根节点
				updateTreeModel(view);
				
				backButton.setEnabled(true);
			} else if (e.getSource() == upButton) {			// Up按钮事件处理
				
				// 当前视图的根节点
				DefaultMutableTreeNode rootNode = (DefaultMutableTreeNode) getTreeRootNode();
				view = new TreeView(rootNode.getParent(), goIntoNode);
				
				updateTreeModel(view);
				viewContainer.addView(view);			

				forwardButton.setEnabled(false);
				backButton.setEnabled(true);
			}
		}
	}
	
	/**
	 * 使节点可查看
	 */
	public void makeNodeVisible(TreeNode treeNode){
		TreePath path = getTreePath(treeNode);
		
		// 使指定路径标识的节点可查看
		jTree1.expandPath(path);
	}
	
	/**
	 * 通过TreeNode，得到该node对应的路径
	 * @param node
	 * @return
	 */
	public TreePath getTreePath(TreeNode node){
		// 向上构建节点的父节点一直到根节点（包括根节点），返回的数组包括从node到根节点的所有节点
		TreeNode[] nodes = getTreeModel().getPathToRoot(node);

		return new TreePath(nodes);
	}
	
	/**
	 * 返回树的模型
	 * @return
	 */
	public DefaultTreeModel getTreeModel(){
		return (DefaultTreeModel) jTree1.getModel();
	}
	
	/**
	 * 返回树的根节点
	 * @return
	 */
	public DefaultMutableTreeNode getTreeRootNode(){
		return (DefaultMutableTreeNode) getTreeModel().getRoot();
	}
	
	
	/**
	 * 如果参数(treeNode)为初始树的根节点设为不可用
	 * @param treeNode
	 */
	public void setUpButtonEnable(TreeNode treeNode){
		//	如果已经到顶层树的节点，把upButton设为不可用
		if (initRootNode == treeNode){
			upButton.setEnabled(false);
		} else {
			upButton.setEnabled(true);
		}
	}
	
	/**
	 * 构造工具面板，包括一个文本框，三个按钮
	 * @param panel
	 */
	private JPanel buildToolPanel() {
		
		JPanel panel = new JPanel();
		GridLayout gb = new GridLayout(1, 2);
		panel.setLayout(gb);
		
		panel.add(jTextField1);
		
		JPanel p = new JPanel(new GridLayout(1, 3));
		
		p.add(backButton);
		p.add(forwardButton);
		p.add(upButton);
		
		setButtonEnable(false);
		
		BtnActionLister btnAction = new BtnActionLister();
		backButton.addActionListener(btnAction);
		forwardButton.addActionListener(btnAction);
		upButton.addActionListener(btnAction);
		panel.add(p);
		
		return panel;
	}
	
	/**
	 * 设置三个按钮是否可用
	 * @param isEnable
	 */
	private void setButtonEnable(boolean isEnable){
		backButton.setEnabled(isEnable);
		forwardButton.setEnabled(isEnable);
		upButton.setEnabled(isEnable);
	}

	/**
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		FileTree m = new FileTree();
	
		Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
		Dimension frameSize = m.getSize();
		if (frameSize.height > screenSize.height) {
			frameSize.height = screenSize.height;
		}
		if (frameSize.width > screenSize.width) {
			frameSize.width = screenSize.width;
		}
		m.setLocation((screenSize.width - frameSize.width) / 5,
				(screenSize.height - frameSize.height) / 5);   
		
		m.setSize(800, 600);
		m.setVisible(true);
		m.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}	
	
	/**
	 * 树的展开，折叠事件监听器
	 * @author Administrator
	 *
	 */
	private class FileTreeExpansionListener implements TreeExpansionListener{
		public void treeCollapsed(TreeExpansionEvent e) {
			TreePath path = e.getPath();
			view.removeExpandFromSet(path);
		}

		public void treeExpanded(TreeExpansionEvent e) {
			TreePath path = e.getPath();
			view.addExpandNodeToSet(path);
			
			TreeNode node = (TreeNode) path.getLastPathComponent();
			expandNode(node);
		}
	}
	
	/**
	 * 鼠标事件监听器
	 * @author Administrator
	 *
	 */
	private class treeMouseListener extends MouseAdapter{
		public void mousePressed(MouseEvent e) {
			// 右键弹出菜单
			if((e.getModifiers() & InputEvent.BUTTON3_MASK) != 0 
					&& jTree1.getSelectionCount() > 0){
				showMenu(e.getX(), e.getY());
				return;
			}
			String filepath = getPressedNodePath(e);
			jTextField1.setText(filepath);
		}
		
		
		/**
		 * 返回鼠标正在点击的树节点代表的路径
		 * @param e
		 * @return
		 */
		public String getPressedNodePath(MouseEvent e) {
			JTree tree = (JTree) e.getSource();
			int row = tree.getRowForLocation(e.getX(), e.getY());
			if (row == -1) {
				return "";
			}
			TreePath path = tree.getPathForRow(row);
			if (path == null) {
				return "";
			}
			TreeNode node = (TreeNode) path.getLastPathComponent();
			if (node == null) {
				return "";
			}
			return node.toString();
		}
	}
}