file：commons
package org.crazyit.editor.commons; import org.crazyit.editor.EditorFrame;
import org.crazyit.editor.handler.add.AddHandler; /**
* 添加的信息对象
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class AddInfo { //字符串, 在新增界面的text前显示, 例如: 文件名称
private String info; //受新增操作影响的主frame
private EditorFrame editorFrame; //新增完后的处理类
private AddHandler handler; public AddInfo(String info, EditorFrame editorFrame, AddHandler handler) {
this.info = info;
this.editorFrame = editorFrame;
this.handler = handler;
} public AddHandler getHandler() {
return handler;
} public void setHandler(AddHandler handler) {
this.handler = handler;
} public String getInfo() {
return info;
} public void setInfo(String info) {
this.info = info;
} public EditorFrame getEditorFrame() {
return editorFrame;
} public void setEditorFrame(EditorFrame editorFrame) {
this.editorFrame = editorFrame;
} }
AddInfo
package org.crazyit.editor.commons; import java.io.File; import javax.swing.JInternalFrame; import org.crazyit.editor.EditPane; /**
* 编辑的文件对象
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class EditFile { //当前编辑的文件
private File file; //该文件是否已经被保存
private boolean saved; //该文件对应的窗口
private JInternalFrame iframe; //该文件所对应的编辑器
private EditPane editPane; public EditFile(File file, boolean saved, JInternalFrame iframe,
EditPane editPane) {
this.file = file;
this.saved = saved;
this.iframe = iframe;
this.editPane = editPane;
} public EditPane getEditPane() {
return editPane;
} public void setEditPane(EditPane editPane) {
this.editPane = editPane;
} public JInternalFrame getIframe() {
return iframe;
} public void setIframe(JInternalFrame iframe) {
this.iframe = iframe;
} public boolean isSaved() {
return saved;
} public void setSaved(boolean saved) {
this.saved = saved;
} public File getFile() {
return file;
} public void setFile(File file) {
this.file = file;
} }
EditFile
package org.crazyit.editor.commons; import java.io.File; import javax.swing.JInternalFrame; import org.crazyit.editor.EditPane; /**
* 编辑的文件对象
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class EditFile { //当前编辑的文件
private File file; //该文件是否已经被保存
private boolean saved; //该文件对应的窗口
private JInternalFrame iframe; //该文件所对应的编辑器
private EditPane editPane; public EditFile(File file, boolean saved, JInternalFrame iframe,
EditPane editPane) {
this.file = file;
this.saved = saved;
this.iframe = iframe;
this.editPane = editPane;
} public EditPane getEditPane() {
return editPane;
} public void setEditPane(EditPane editPane) {
this.editPane = editPane;
} public JInternalFrame getIframe() {
return iframe;
} public void setIframe(JInternalFrame iframe) {
this.iframe = iframe;
} public boolean isSaved() {
return saved;
} public void setSaved(boolean saved) {
this.saved = saved;
} public File getFile() {
return file;
} public void setFile(File file) {
this.file = file;
} }
WorkSpace
file：config
package org.crazyit.editor.config; /**
* 编译配置对象
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class CompileConfig { //记录源文件的目录
public final static String SRC_DIR = "src"; //记录项目编译目录
public final static String OUTPUT_DIR = "classes";
}
CompileConfig
file：expection
package org.crazyit.editor.exception; /**
* 文件异常类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class FileException extends RuntimeException { public FileException(String message) {
super(message);
}
}
Expection
file：handler
package org.crazyit.editor.handler.add; import java.io.File; import javax.swing.JOptionPane; import org.crazyit.editor.AddFrame;
import org.crazyit.editor.EditorFrame;
import org.crazyit.editor.exception.FileException;
import org.crazyit.editor.tree.ProjectTreeModel;
import org.crazyit.editor.tree.ProjectTreeNode; /**
* 添加文件处理类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class AddFileHandler implements AddHandler { public void afterAdd(EditorFrame editorFrame, AddFrame addFrame, Object data) {
try {
//获得当前所选择的树节点
ProjectTreeNode selectNode = editorFrame.getSelectNode();
//获取当前选择节点所对应的文件
File folder = selectNode.getFile();
//如果folder不是一个目录，则用selectNode的父节点（是一个目录）作为新文件的存放目录
if (!folder.isDirectory()) {
ProjectTreeNode parent = (ProjectTreeNode)selectNode.getParent();
selectNode = parent;
folder = parent.getFile();
}
//创建文件，放到folder下
File newFile = new File(folder.getAbsoluteFile() + File.separator + data);
//如果文件已经存在，就弹出提示并返回
if (newFile.exists()) {
JOptionPane.showMessageDialog(addFrame, "文件已经存在");
return;
}
newFile.createNewFile();
editorFrame.reloadNode(selectNode);
//使主编辑frame可用
editorFrame.setEnabled(true);
///让添加的frame不可见
addFrame.setVisible(false);
} catch (Exception e) {
throw new FileException("create file error: " + e.getMessage());
}
} }
AddFileHandler
package org.crazyit.editor.handler.add; import java.io.File; import javax.swing.JOptionPane; import org.crazyit.editor.AddFrame;
import org.crazyit.editor.EditorFrame;
import org.crazyit.editor.exception.FileException;
import org.crazyit.editor.tree.ProjectTreeNode; /**
* 添加目录处理类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class AddFolderHandler implements AddHandler { public void afterAdd(EditorFrame editorFrame, AddFrame addFrame, Object data) {
try {
//获得树中所选取的节点
ProjectTreeNode selectNode = editorFrame.getSelectNode();
//获取该节点所对应的文件对象
File folder = selectNode.getFile();
//如果folder不是一个目录，则用selectNode的父节点（是一个目录）作为新目录的父目录
if (!folder.isDirectory()) {
ProjectTreeNode parent = (ProjectTreeNode)selectNode.getParent();
//让当前所选择的文件的父目录作为当前选择的目录
selectNode = parent;
folder = parent.getFile();
}
//创建一个文件目录对象
File newFolder = new File(folder.getAbsoluteFile() + File.separator + data);
//如果该目录已经存在，弹出提示并返回
if (newFolder.exists()) {
JOptionPane.showMessageDialog(addFrame, "目录已经存在");
return;
}
//创建新的目录
newFolder.mkdir();
//刷新树的节点
editorFrame.reloadNode(selectNode);
//让EditorFrame可用
editorFrame.setEnabled(true);
//让添加的frame不可见
addFrame.setVisible(false);
} catch (Exception e) {
throw new FileException("create folder error: " + e.getMessage());
}
} }
AddFolderHandler
package org.crazyit.editor.handler.add; import org.crazyit.editor.AddFrame;
import org.crazyit.editor.EditorFrame; /**
* 添加事件的接口
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public interface AddHandler { //新增完后需要做的事情，需要做的事情由实现类去实现
//参数为EditorFrame，AddFrame，输入的信息data
void afterAdd(EditorFrame editorFrame, AddFrame addFrame, Object data);
}
AddHandler
package org.crazyit.editor.handler.add; import java.io.File; import javax.swing.JOptionPane;
import javax.swing.JTree; import org.crazyit.editor.AddFrame;
import org.crazyit.editor.EditorFrame;
import org.crazyit.editor.commons.WorkSpace;
import org.crazyit.editor.config.CompileConfig;
import org.crazyit.editor.exception.FileException; /**
* 添加项目处理类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class AddProjectHandler implements AddHandler { public void afterAdd(EditorFrame editorFrame, AddFrame addFrame, Object data) {
try {
//获取工作空间所在的目录
File spaceFolder = editorFrame.getWorkSpace().getFolder();
//创建.project文件
File projectFile = new File(spaceFolder.getAbsoluteFile() +
File.separator + data + ".project");
//创建项目目录
File projectFolder = new File(spaceFolder.getAbsoluteFile() + File.separator + data);
//项目已经存在，弹出警告并返回
if (projectFile.exists() && projectFolder.exists()) {
JOptionPane.showMessageDialog(addFrame, "项目已经存在");
return;
}
//项目文件不存在， 创建项目文件
if (!projectFile.exists()) projectFile.createNewFile();
//项目目录不存在， 创建项目文件目录
if (!projectFolder.exists()) projectFolder.mkdir();
//创建项目的src目录和编译目录
File src = new File(projectFolder.getAbsoluteFile() +
File.separator + CompileConfig.SRC_DIR);
//Java文件编译的输入目录
File output = new File(projectFolder.getAbsoluteFile() +
File.separator + CompileConfig.OUTPUT_DIR);
//创建src和output两个目录
src.mkdir();
output.mkdir();
//刷新整棵树
JTree newTree = editorFrame.getTreeCreator().createTree(editorFrame);
editorFrame.refreshTree(newTree);
//让EditorFrame变得可用
editorFrame.setEnabled(true);
//让添加的frame不可见
addFrame.setVisible(false);
} catch (Exception e) {
throw new FileException("create project error: " + e.getMessage());
}
} }
AddProjectHandler
file：run
package org.crazyit.editor.handler.run; import java.io.File; import org.crazyit.editor.EditorFrame;
import org.crazyit.editor.config.CompileConfig;
import org.crazyit.editor.util.CommandUtil; /**
* 运行Java文件处理类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class JavaRunHandler { public String run(EditorFrame editorFrame) {
try {
//获得项目目录的路径
String projectPath = editorFrame.getCurrentProject().getAbsolutePath();
//获得源文件的全路径
String sourcePath = editorFrame.getCurrentFile().getFile().getAbsolutePath();
//获得项目的编译路径，项目目录加CompileConfig中配置的输出目录
String classPath = editorFrame.getCurrentProject().getAbsolutePath()
+ File.separator + CompileConfig.OUTPUT_DIR;
//获取类名
String className = getClassName(projectPath, sourcePath);
//拼装命令
String command = "java -cp \"" + classPath + "\" " + className;
Process p = CommandUtil.executeCommand(command);
return CommandUtil.getRunString(p);
} catch (Exception e) {
return e.getMessage();
}
} //根据项目目录的路径和Java源文件的路径获取一个类的全限定类名
private String getClassName(String projectPath, String sourcePath) {
String temp = projectPath + File.separator + CompileConfig.SRC_DIR +
File.separator;
String result = sourcePath.replace(temp, "");
result = result.replace(".java", "");
result = result.replace(String.valueOf(File.separatorChar), ".");
return result;
} }
JavaRunHandler
file：save
package org.crazyit.editor.handler.save; import org.crazyit.editor.EditorFrame;
import org.crazyit.editor.commons.EditFile;
import org.crazyit.editor.util.FileUtil; /**
* 执行普通保存的处理类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class CommonSaveHandler implements SaveHandler { //提供一个保存方法，作为普通的保存
public String save(EditorFrame editorFrame) {
EditFile editFile = editorFrame.getCurrentFile();
FileUtil.writeFile(editFile.getFile(), editFile.getEditPane().getText());
return null;
} }
CommonSaveHandler
package org.crazyit.editor.handler.save; import java.io.File;
import java.io.FileWriter;
import java.io.InputStream; import org.crazyit.editor.EditorFrame;
import org.crazyit.editor.config.CompileConfig;
import org.crazyit.editor.util.CommandUtil; /**
* 保存Java文件的处理类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class JavaSaveHandler extends CommonSaveHandler { public String save(EditorFrame editorFrame) {
//调用父类的保存方法
super.save(editorFrame);
return javac(editorFrame);
} //执行javac命令
private String javac(EditorFrame editorFrame) {
try {
//获得项目的编译路径，项目目录加CompileConfig中配置的输出目录
String classPath = editorFrame.getCurrentProject().getAbsolutePath()
+ File.separator + CompileConfig.OUTPUT_DIR;
//获得源文件的文件路径
String filePath = editorFrame.getCurrentFile().getFile().getAbsolutePath();
//拼装字符串命令，该命令只可在windows下运行
String command = "javac -d \"" + classPath + "\" \"" + filePath + "\"";
Process p = CommandUtil.executeCommand(command);
return CommandUtil.getProcessString(p);
} catch (Exception e) {
return e.getMessage();
}
} }
JavaSaveHandler
package org.crazyit.editor.handler.save; import org.crazyit.editor.EditorFrame; /**
* 保存处理接口
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public interface SaveHandler { //执行保存的接口方法
String save(EditorFrame editorFrame);
}
SaveHandler
package org.crazyit.editor.handler.save; import org.crazyit.editor.EditorFrame; /**
* 保存的中介者
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public abstract class SaveMediator { //需要子类去实现的保存方法
public abstract String doSave(EditorFrame editorFramet);
}
SaveMediator
package org.crazyit.editor.handler.save; import org.crazyit.editor.EditorFrame;
import org.crazyit.editor.commons.EditFile; /**
* 保存动作的中介者实现
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class SaveMediatorConcrete extends SaveMediator { private SaveHandler commonHandler; private SaveHandler javaHandler; //构造两个处理保存的对象
public SaveMediatorConcrete() {
this.commonHandler = new CommonSaveHandler();
this.javaHandler = new JavaSaveHandler();
} public String doSave(EditorFrame editorFrame) {
//获得当前编辑的文件名
String fileName = editorFrame.getCurrentFile().getFile().getName();
String result = null;
//判断文件是否为Java文件， 再决定处理类
if (fileName.endsWith(".java")) {//保存java文件
result = javaHandler.save(editorFrame);
} else {//执行普通的保存
result = commonHandler.save(editorFrame);
}
return result;
} }
SaveMediatorConcrete
file：tree
package org.crazyit.editor.tree; import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeNode; /**
* 项目树的Model对象
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class ProjectTreeModel extends DefaultTreeModel { public ProjectTreeModel(ProjectTreeNode arg0) {
super(arg0);
} public void reload(ProjectTreeNode node, TreeCreator creator) {
//获取node节点的父节点
ProjectTreeNode parent = (ProjectTreeNode)node.getParent();
//父节点为null，返回，不需要reload
if (parent == null) return;
//获取node节点在父节点的索引
int index = parent.getIndex(node);
//先装node节点从parent中删除
parent.remove(index);
//再通过TreeCreator获取新的节点
node = creator.createNode(node.getFile());
//添加到父节点中
parent.insert(node, index);
//调用DefaultTreeModel的reload方法
super.reload(node);
} }
ProjectTreeModel
package org.crazyit.editor.tree; import java.io.File;
import java.util.ArrayList;
import java.util.List; import javax.swing.tree.DefaultMutableTreeNode; /**
* 项目树的节点对象
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class ProjectTreeNode extends DefaultMutableTreeNode { //该节点对应的文件
private File file; //该节点下的子节点
private List<ProjectTreeNode> children; //ProjectTreeNode的构造器，参数分别时该节点对应的文件，是否允许有子节点
public ProjectTreeNode(File file, boolean allowsChildren) {
super(file.getName(), allowsChildren);
this.file = file;
//初始化该节点下的子节点集合
children = new ArrayList<ProjectTreeNode>();
} public File getFile() {
return file;
} public void setFile(File file) {
this.file = file;
} public List<ProjectTreeNode> getChildren() {
//清空children, 再重新获取一次
children.removeAll(children);
for (int i = 0; i < getChildCount(); i++) {
children.add((ProjectTreeNode)getChildAt(i));
}
return this.children;
} }
ProjectTreeNode
package org.crazyit.editor.tree; import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent; import javax.swing.event.TreeSelectionEvent; import org.crazyit.editor.EditorFrame; /**
* 项目树选择监听器
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class ProjectTreeSelectionListener extends MouseAdapter { //主界面的frame
private EditorFrame editorFrame; //将主界面的frame(EditorFrame)作为构造参数传入监听器
public ProjectTreeSelectionListener(EditorFrame editorFrame) {
this.editorFrame = editorFrame;
} public void mousePressed(MouseEvent e) {
//得到当前所选择的节点
ProjectTreeNode selectNode = this.editorFrame.getSelectNode();
//如果没有选择节点，就返回
if (selectNode == null) return;
//如果选择的是一个目录，返回
if (selectNode.getFile().isDirectory()) return;
//使用EditorFrame的方法来打开文件
this.editorFrame.openFile(selectNode.getFile());
} }
ProjectTreeSelectionListener
package org.crazyit.editor.tree; import java.io.File; import javax.swing.JTree; import org.crazyit.editor.EditorFrame; /**
* 树创建接口
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public interface TreeCreator { /**
* 根据编辑的EditorFrame对象创建项目树
* @param editorFrame
* @return
*/
JTree createTree(EditorFrame editorFrame); /**
* 根据一个目录创建它的节点
* @param folder
* @return
*/
ProjectTreeNode createNode(File folder);
}
TreeCreator
package org.crazyit.editor.tree; import java.io.File;
import java.util.ArrayList;
import java.util.List; import javax.swing.JTree;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreePath; import org.crazyit.editor.EditorFrame;
import org.crazyit.editor.util.ImageUtil; /**
* 树创建实现类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class TreeCreatorImpl implements TreeCreator { @Override
public JTree createTree(EditorFrame editorFrame) {
File spaceFolder = editorFrame.getWorkSpace().getFolder();
ProjectTreeNode root = new ProjectTreeNode(spaceFolder, true);
ProjectTreeModel treeModel = new ProjectTreeModel(root);
JTree tree = new JTree(treeModel);
//获取工作空间下面所有的目录（即与有projectName.project相对应的目录），也就是项目目录
List<File> projectFolders = getProjectFolders(spaceFolder);
//遍历项目目录集合，并为其创建子节点
for (int i = 0; i < projectFolders.size(); i++) {
//获取循环中的目录
File projectFolder = projectFolders.get(i);
//调用createNode创建它所有的子节点
ProjectTreeNode node = createNode(projectFolder);
//向根节点添加子节点（项目目录）
root.add(node);
} //定制节点图片
DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
//目录打开时的图片
renderer.setOpenIcon(ImageUtil.getImageIcon(ImageUtil.FOLDER_OPEN));
//节点没有子节点的图片
renderer.setLeafIcon(ImageUtil.getImageIcon(ImageUtil.FILE));
//目录关闭时的图片
renderer.setClosedIcon(ImageUtil.getImageIcon(ImageUtil.FOLDER_CLOSE));
//设置树的部件处理类为上面的renderer
tree.setCellRenderer(renderer);
//为项目树添加一个树选择监听器
tree.addMouseListener(new ProjectTreeSelectionListener(editorFrame));
//创建根在项目树中的路径
TreePath path = new TreePath(root);
//让树默认展开根节点
tree.expandPath(path);
//设置树的根节点不可见
tree.setRootVisible(false);
return tree;
} /*
* 根据一个目录创建它的所有直接节点
*/
private List<ProjectTreeNode> createNodes(File folder) {
//获取该目录下的所有文件
File[] files = folder.listFiles();
List<ProjectTreeNode> result = new ArrayList<ProjectTreeNode>();
//对该目录下的所有文件的数组进行两次遍历
for (File file : files) {
//第一次遍历，如果是目录的话，就加入到结果集合中
if (file.isDirectory()) {
result.add(new ProjectTreeNode(file, true));
}
}
for (File file : files) {
//第二次遍历，如果非目录的话，就加入到结果集合中
if (!file.isDirectory()) {//再加普通文件
result.add(new ProjectTreeNode(file, false));
}
}
return result;
} //根据一个目录去创建该目录所对应的节点对象，该对象的所有的子节点都已经创建
public ProjectTreeNode createNode(File folder) {
//创建一个父节点，即本方法即将返回的节点对象
ProjectTreeNode parent = null;
//如果参数foler不是一个目录的话，创建一个ProjectTreeNode对象并返回，表明它不允许拥有子节点
if (!folder.isDirectory()) {
return new ProjectTreeNode(folder, false);
} else {
//如果是一个目录的话，则创建上面的parent，表明它是一个目录，可以拥有子节点
parent = new ProjectTreeNode(folder, true);
}
//利用上面的parent节点去查找它下面所有的直接节点
List<ProjectTreeNode> nodes = createNodes(parent.getFile());
//获取到parent下面的所有直接子节点后，再去循环递归调用本方法
for (ProjectTreeNode node : nodes) {
//递归创建子节点，并将返回的节点添加到parent中
parent.add(createNode(node.getFile()));
}
return parent;
} /**
* 获取工作空间目录下所有的项目名称
* @return
*/
private List<String> getProjectNames(File spaceFolder) {
List<String> result = new ArrayList<String>();
for (File file : spaceFolder.listFiles()) {
if (file.getName().endsWith(".project")) {//取以.project结尾的文件
result.add(file.getName().substring(0, file.getName().indexOf(".project")));
}
}
return result;
} /*
* 获取工作空间目录下所有的项目目录
*/
private List<File> getProjectFolders(File spaceFolder) {
List<String> projectNames = getProjectNames(spaceFolder);
List<File> result = new ArrayList<File>();
//获取工作空间下面所有的文件
File[] files = spaceFolder.listFiles();
for (String projectName : projectNames) {
for (File file : files) {
if (file.isDirectory()) {//如果工作空间下面的文件是目录，再去判断是否是项目目录
if (projectName.equals(file.getName())) {
result.add(file);
}
}
}
}
return result;
}
}
TreeCreatorImpl
file: util
package org.crazyit.editor.util; import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream; /**
* 命令工具类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class CommandUtil { public final static String WINDOWS_COMMAND = "cmd /c "; //返回进程process的错误信息
public static String getErrorMessage(Process process) {
return getProcessString(process.getErrorStream());
} private static String getProcessString(InputStream is) {
try {
StringBuffer buffer = new StringBuffer();
byte[] b = new byte[4096];
for (int n; (n = is.read(b)) != -1;)
buffer.append(new String(b, 0, n));
is.close();
return buffer.toString();
} catch (Exception e) {
return e.getMessage();
}
} //获取一个进程的错误信息
public static String getProcessString(Process process) {
StringBuffer result = new StringBuffer();
//调用CommandUtil的方法
String errorString = getErrorMessage(process);
if (errorString.length() != 0) result.append("错误: " + errorString);
else result.append("执行完成");
return result.toString();
} //返回一个进程的信息
public static String getRunString(Process process) {
String error = getErrorMessage(process);
String message = getProcessString(process.getInputStream());
return error + message;
} //执行一个命令并返回相应的信息
public static Process executeCommand(String command) {
try {
//在windows下将命令生成一份bat文件, 再执行该bat文件
File batFile = new File("dump.bat");
if (!batFile.exists()) batFile.createNewFile();
//将命令写入文件中
FileWriter writer = new FileWriter(batFile);
writer.write(command);
writer.close();
//执行该bat文件
Process process =Runtime.getRuntime().exec(WINDOWS_COMMAND + batFile.getAbsolutePath());
process.waitFor();
//将bat文件删除
batFile.delete();
return process;
} catch (Exception e) {
return null;
}
}
}
CommandUtil
package org.crazyit.editor.util; import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream; import javax.swing.JTextArea; import org.crazyit.editor.exception.FileException; /**
* 文件处理工具类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class FileUtil { //读取一个文件的内容
public static String readFile(File file) {
StringBuffer result = new StringBuffer();
try {
//使用IO流读取文件
FileInputStream fis= new FileInputStream(file);
String content = null;
byte[] arr = new byte[1024];
int readLength ;
while ((readLength = fis.read(arr)) > 0) {
content = new String(arr, 0, readLength);
result.append(content);
}
fis.close();
}
catch(IOException e) {
throw new FileException("read '" + file.getAbsolutePath() + "' file error");
}
return result.toString();
} //使用IO流将参数content写入到参数file中
public static void writeFile(File file, String content) {
try {
FileOutputStream fos = new FileOutputStream(file);
PrintStream ps = new PrintStream(fos);
ps.print(content);
ps.close();
fos.close();
} catch (IOException e) {
throw new FileException("write file error");
}
}
}
FileUtil
package org.crazyit.editor.util; import java.awt.Image;
import java.io.File; import javax.imageio.ImageIO;
import javax.swing.ImageIcon; /**
* 图片工具类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class ImageUtil { //目录关闭图片
public static String FOLDER_CLOSE = "images/folder-close.gif";
//目录打开图片
public static String FOLDER_OPEN = "images/folder-open.gif";
//无子节点的文件图片
public static String FILE = "images/file.gif";
//使用ImageIO流读取图片
public static Image getImage(String path) {
try {
return ImageIO.read(new File(path));
} catch (Exception e) {
e.printStackTrace();
return null;
}
} public static ImageIcon getImageIcon(String path) {
return new ImageIcon(getImage(path));
}
}
ImageUtil
file:src
package org.crazyit.editor; import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter; import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField; import org.crazyit.editor.commons.AddInfo; /**
* 添加界面
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class AddFrame extends JFrame { //该Frame的JPanel
private JPanel mainPanel; //项目名称
private JPanel namePanel; //显示文件的JLabel
private JLabel nameLabel; //输入名称的JTextField
private JTextField nameText; //放按钮的Panel
private JPanel buttonPanel; //确定按钮
private JButton confirmButton; //取消按钮
private JButton cancelButton; public AddFrame(final AddInfo info) {
mainPanel = new JPanel();
namePanel = new JPanel();
//设置nameLabel的文字
nameLabel = new JLabel(info.getInfo());
nameText = new JTextField("", 20);
buttonPanel = new JPanel();
confirmButton = new JButton("确定");
cancelButton = new JButton("取消"); mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS));
addWindowListener(new WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent e) {
cancel(info);
}
});
setLocation(200, 200);
setResizable(false);
//文本框前面的字
namePanel.setLayout(new BoxLayout(namePanel, BoxLayout.X_AXIS));
namePanel.add(nameLabel);
namePanel.add(nameText);
nameText.addKeyListener(new KeyAdapter() {
public void keyReleased(KeyEvent e) {
//判断项目路径与名称是否有值, 如果两个text field都有值, 则确定按钮可用
if (nameText.getText().equals("")) {
confirmButton.setEnabled(false);
} else {
confirmButton.setEnabled(true);
}
}
}); //确定和取消的按钮
buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));
confirmButton.setEnabled(false);
buttonPanel.add(confirmButton);
buttonPanel.add(new JLabel(" "));
buttonPanel.add(cancelButton); //为取消按钮添加监听器
cancelButton.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
cancel(info);
}
});
//为确定按钮添加监听器
confirmButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
//如果输入框没有值，返回
if (nameText.getText() == "") return;
handerConfirm(info);
}
});
mainPanel.add(namePanel);
mainPanel.add(buttonPanel);
add(mainPanel);
pack();
} //处理确定按钮的点击
private void handerConfirm(AddInfo info) {
//获取得用户输入
String data = nameText.getText();
//新增后会涉及的一些与业务相关的操作留给Handler类处理
info.getHandler().afterAdd(info.getEditorFrame(), this, data);
} private void cancel(AddInfo info) {
//设置EditorFrame可用
info.getEditorFrame().setEnabled(true);
//让本窗口不可见
setVisible(false);
} }
AddFrame
package org.crazyit.editor; import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener; /**
* 文档监听器
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class EditDocumentListener implements DocumentListener {
//主界面对象
private EditorFrame editorFrame;
public EditDocumentListener(EditorFrame editorFrame) {
this.editorFrame = editorFrame;
}
public void changedUpdate(DocumentEvent e) {
}
public void insertUpdate(DocumentEvent e) {
//设置当前编辑的文件的saved属性为false
this.editorFrame.getCurrentFile().setSaved(false);
}
public void removeUpdate(DocumentEvent e) {
}
}
EditDocumentListener
package org.crazyit.editor; import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.InputEvent;
import java.io.File;
import java.util.ArrayList;
import java.util.List; import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JDesktopPane;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTabbedPane;
import javax.swing.JTextArea;
import javax.swing.JToolBar;
import javax.swing.JTree;
import javax.swing.KeyStroke;
import javax.swing.tree.TreePath; import org.crazyit.editor.commons.AddInfo;
import org.crazyit.editor.commons.EditFile;
import org.crazyit.editor.commons.WorkSpace;
import org.crazyit.editor.handler.add.AddFileHandler;
import org.crazyit.editor.handler.add.AddFolderHandler;
import org.crazyit.editor.handler.add.AddProjectHandler;
import org.crazyit.editor.handler.run.JavaRunHandler;
import org.crazyit.editor.handler.save.SaveMediator;
import org.crazyit.editor.handler.save.SaveMediatorConcrete;
import org.crazyit.editor.tree.ProjectTreeModel;
import org.crazyit.editor.tree.ProjectTreeNode;
import org.crazyit.editor.tree.TreeCreator; /**
* 编辑界面
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class EditorFrame extends JFrame { //多文件的tab标题
private JTabbedPane tabPane; //存放tabPane与desk
private Box box; //创建一个多文档的桌面容器
private JDesktopPane desk; //用于分隔主编辑区和信息显示区的容器
private JSplitPane editorSplitPane; //可以滚动的JScrollPane对象，用于放infoArea
private JScrollPane infoPane; //用于显示信息的文本域
private JTextArea infoArea; //存放树的可滚动容器
private JScrollPane treePane; //整个界面的分隔组件的容器
private JSplitPane mainSplitPane; //项目树对象
private JTree tree; //菜单栏对象
private JMenuBar menuBar; //编辑菜单对象
private JMenu editMenu; //文件菜单
private JMenu fileMenu; //工具条
private JToolBar toolBar; private WorkSpace workSpace; private TreeCreator treeCreator; //添加的界面
private AddFrame addFrame; //文件选择器
private FileChooser fileChooser; //当前正在编辑的文件对象
private EditFile currentFile; //窗口监听器
private IFrameListener iframeListener; //打开文件的集合
private List<EditFile> openFiles = new ArrayList<EditFile>(); //中介者对象
private SaveMediator saveMediator; //运行class文件的处理类
private JavaRunHandler runHandler; //新建文件的Action对象
private Action fileNew = new AbstractAction("新建文件", new ImageIcon("images/newFile.gif")) {
public void actionPerformed(ActionEvent e) {
newFile();
}
};
//新建目录的Action对象
private Action folerNew = new AbstractAction("新建目录", new ImageIcon("images/newFile.gif")) {
public void actionPerformed(ActionEvent e) {
newFolder();
}
};
//新建项目的Action对象
private Action projectNew = new AbstractAction("新建项目", new ImageIcon("images/newFile.gif")) {
public void actionPerformed(ActionEvent e) {
newProject();
}
};
//打开文件的Action对象
private Action open = new AbstractAction("打 开", new ImageIcon("images/open.gif")) {
public void actionPerformed(ActionEvent e) {
selectFile();
}
};
//保存文件的Action对象
private Action save = new AbstractAction("保 存", new ImageIcon("images/save.gif")) {
public void actionPerformed(ActionEvent e) {
saveFile(getCurrentFile());
}
};
//刷新树的Action对象
private Action refresh = new AbstractAction("刷 新", new ImageIcon("images/refresh.gif")) {
public void actionPerformed(ActionEvent e) {
reloadNode(getSelectNode());
}
};
//运行文件的Action对象
private Action run = new AbstractAction("运 行", new ImageIcon("images/run.gif")) {
public void actionPerformed(ActionEvent e) {
run();
}
};
//退出的Action对象
private Action exit = new AbstractAction("退 出") {
public void actionPerformed(ActionEvent e) {
System.exit(0);//直接退出
}
};
//复制文本的Action对象
private Action copy = new AbstractAction("复 制", new ImageIcon("images/copy.gif")) {
public void actionPerformed(ActionEvent e) {
if (getCurrentFile() != null) {
getCurrentFile().getEditPane().copy();
}
}
};
//剪切文本的Action对象
private Action cut = new AbstractAction("剪 切", new ImageIcon("images/cut.gif")) {
public void actionPerformed(ActionEvent e) {
if (getCurrentFile() != null) {
getCurrentFile().getEditPane().cut();
}
}
};
//粘贴文本的Action对象
private Action paste = new AbstractAction("粘 贴", new ImageIcon("images/paste.gif")) {
public void actionPerformed(ActionEvent e) {
if (getCurrentFile() != null) {
getCurrentFile().getEditPane().paste();
}
}
}; public EditorFrame(String title, TreeCreator treeCreator) {
super(title); //设置标题
this.treeCreator = treeCreator;
this.iframeListener = new IFrameListener(this);
this.saveMediator = new SaveMediatorConcrete();
this.runHandler = new JavaRunHandler();
} public void initFrame(WorkSpace space) {
this.workSpace = space;
//设置窗口关闭，退出程序
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//创建主编辑区的tabPane
tabPane = new JTabbedPane(JTabbedPane.TOP, JTabbedPane.SCROLL_TAB_LAYOUT );
desk = new JDesktopPane();//创建JDesktopPane对象
desk.setBackground(Color.GRAY);//设置desk的背景颜色为灰色
box = new Box(BoxLayout.Y_AXIS);//设置box的布局
box.add(tabPane);
box.add(desk);
//创建信息显示区的文本域
infoArea = new JTextArea("", 5, 50);
//将infoArea文本域作为组件放到infoPane中
infoPane = new JScrollPane(infoArea);
//设置信息区不可编辑
infoArea.setEditable(false);
//创建这个分隔组件的容器，并将box对象和infoPane放置其中
editorSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, box, infoPane);
editorSplitPane.setDividerSize(3);
editorSplitPane.setDividerLocation(500);
//创建树
tree = treeCreator.createTree(this);
//创建可滚动的容器对象
treePane = new JScrollPane(tree);
//创建主界面的JSplitPane，横向，左边为treePane，右边为editorSplitPane
mainSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, treePane,
editorSplitPane);
//设置分隔条的位置
mainSplitPane.setDividerLocation(200);
//设置分隔条的粗细
mainSplitPane.setDividerSize(3);
add(mainSplitPane); //创建菜单栏对象
menuBar = new JMenuBar();
//创建编辑菜单对象
editMenu = new JMenu("编辑");
//创建文件菜单
fileMenu = new JMenu("文件");
//将文件菜单添加到菜单栏中
menuBar.add(fileMenu);
//将编辑菜单添加到菜单栏中
menuBar.add(editMenu);
//设置JFrame的菜单栏
setJMenuBar(menuBar); toolBar = new JToolBar();
toolBar.setFloatable(false);//设置工具栏不可移动
toolBar.setMargin(new Insets(0, 10, 5, 5));//设置工具栏的边距
add(toolBar, BorderLayout.NORTH);//将工具栏添加到EditorFrame中 pack();//使JFrame调整最佳大小
addListeners();
} public TreeCreator getTreeCreator() {
return treeCreator;
} //为EditorFrame中的组件添加监听器
public void addListeners() {
//新建文件的监听器
fileMenu.add(fileNew).setAccelerator(KeyStroke.getKeyStroke('N', InputEvent.CTRL_MASK));
//新建目录的监听器
fileMenu.add(folerNew).setAccelerator(KeyStroke.getKeyStroke('F', InputEvent.CTRL_MASK));
//新建项目的监听器
fileMenu.add(projectNew).setAccelerator(KeyStroke.getKeyStroke('P', InputEvent.CTRL_MASK));
//打开菜单添加监听器
fileMenu.add(open).setAccelerator(KeyStroke.getKeyStroke('O', InputEvent.CTRL_MASK));
//为保存菜单添加监听器
fileMenu.add(save).setAccelerator(KeyStroke.getKeyStroke('S', InputEvent.CTRL_MASK));
//为刷新菜单添加监听器
fileMenu.add(refresh).setAccelerator(KeyStroke.getKeyStroke("F5"));
//为运行菜单添加监听器
fileMenu.add(run).setAccelerator(KeyStroke.getKeyStroke('R', InputEvent.CTRL_MASK));
fileMenu.add(exit);
//添加复制监听器
editMenu.add(copy).setAccelerator(KeyStroke.getKeyStroke('C', InputEvent.CTRL_MASK));
//添加剪切监听器
editMenu.add(cut).setAccelerator(KeyStroke.getKeyStroke('X', InputEvent.CTRL_MASK));
//添加粘贴监听器
editMenu.add(paste).setAccelerator(KeyStroke.getKeyStroke('V', InputEvent.CTRL_MASK)); //为工具条添加各个操作
toolBar.add(fileNew).setToolTipText("新建文件");
toolBar.add(open).setToolTipText("打开");
toolBar.add(save).setToolTipText("保存");
toolBar.add(refresh).setToolTipText("刷新");
toolBar.add(run).setToolTipText("运行");
toolBar.add(copy).setToolTipText("复制");
toolBar.add(cut).setToolTipText("剪切");
toolBar.add(paste).setToolTipText("粘贴"); //为tabPane添加监听器
tabPane.addChangeListener(new TabListener(this));
} //获取编辑器主界面项目树中所选中的节点
public ProjectTreeNode getSelectNode() {
//获得当前树选择的节点在树中的路径
TreePath path = tree.getSelectionPath();
//如果当前选择了节点
if (path != null) {
//创建一个ProjectTreeNode对象并用于返回
ProjectTreeNode selectNode = (ProjectTreeNode)path.getLastPathComponent();
return selectNode;
}
//当前没有选择节就返回null
return null;
} //显示iframe对象
public void showIFrame(JInternalFrame iframe) {
try {
iframe.setSelected(true);
iframe.toFront();
} catch (Exception ex) {
}
} //打开文件的方法
public void openFile(File file) {
if (currentFile != null) {
//如果参数file是当前正在编辑的文件
if (file.equals(currentFile.getFile())) return;
}
//在打开文件的集合中查找该文件, 再判断该文件是否已经打开
EditFile openedFile = getOpenFile(file);
//如果文件已经打开了，调用打开方法（打开已经在编辑tab页面中显示的文件）
if (openedFile != null) {
openExistFile(openedFile, file);
return;
}
//打开新的文件
openNewFile(file);
} //从本类中记录已经打开的文件集合中得到与参数file一样的EditFile对象
private EditFile getOpenFile(File file) {
for (EditFile openFile : openFiles) {
if (openFile.getFile().equals(file)) return openFile;
}
return null;
} //根据参数file获取该file对应的tab页中的索引
private int getFileIndex(File file) {
//如果从打开文件的集合中找不到与参数file对应的EditFile对象，返回-1
EditFile openFile = getEditFile(file);
if (openFile == null) return -1;
return getTabIndex(openFile.getIframe().getToolTipText());
} //在打开的文件中获得文件是file的EditFile对象
private EditFile getEditFile(File file) {
for (EditFile openFile : openFiles) {
if (openFile.getFile().equals(file)) return openFile;
}
return null;
} //根据tab页中的tips找到所对应的在tabPane的索引
public int getTabIndex(String tips) {
for (int i = 0; i < this.tabPane.getTabCount(); i++) {
if (this.tabPane.getToolTipTextAt(i).equals(tips)) return i;
}
return -1;
} //打开已经存在的文件（已经在编辑文件集合中的文件），openFiles集合中的文件
public void openExistFile(EditFile openedFile, File willOpenFile) {
//将tab页变成当前所选择文件的索引
tabPane.setSelectedIndex(getFileIndex(willOpenFile));
//显示iframe
showIFrame(openedFile.getIframe());
//设置当前打开文件
this.currentFile = openedFile;
//添加到当前打开的文件集合中
this.openFiles.add(openedFile);
} //打开一个不在编辑集合中的文件
public void openNewFile(File file) {
//设置EditorFrame的标题为该文件的全路径
setTitle(file.getAbsolutePath());
//创建一个JInternalFrame对象，title为文件的绝对路径
JInternalFrame iframe = new JInternalFrame(file.getAbsolutePath(), true, true, true, true); //新建一个EditPane对象
EditPane editPane = new EditPane(file); //为EditPane添加键盘监听器
editPane.getDocument().addDocumentListener(new EditDocumentListener(this));
iframe.add(new JScrollPane(editPane));
//为JInternalFrame添加窗口监听器
iframe.addInternalFrameListener(this.iframeListener);
desk.add(iframe);
iframe.show();
iframe.reshape(0, 0, 400, 300);
tabPane.addTab(file.getName(), null, null, file.getAbsolutePath());
tabPane.setSelectedIndex(tabPane.getTabCount() - 1);
//设置当前的文件对象
this.currentFile = new EditFile(file, true, iframe, editPane);
//将当前的文件加到打开的文件集合中
this.openFiles.add(this.currentFile);
} public void selectFile() {
fileChooser = new FileChooser(this);
} //新建文件的方法
public void newFile() {
//当没有选择一个节点而新建目录的时候，需要提醒
if (getSelectNode() == null) {
JOptionPane.showMessageDialog(this, "请选择目录");
return;
}
AddInfo info = new AddInfo("文件名称：", this, new AddFileHandler());
showAddFrame(info);
}
//显示新增的界面
private void showAddFrame(AddInfo info) {
//使EditorFrame变为不可用
setEnabled(false);
addFrame = new AddFrame(info);
addFrame.pack();
addFrame.setVisible(true);
} //刷新树节点
public void reloadNode(ProjectTreeNode selectNode) {
if (selectNode == null) return;
//刷新树的节点
ProjectTreeModel model = (ProjectTreeModel)getTree().getModel();
//重新加载所选择的节点
model.reload(selectNode, treeCreator);
} public WorkSpace getWorkSpace() {
return workSpace;
} public JTree getTree() {
return this.tree;
} //新建目录的方法
public void newFolder() {
//当没有选择一个节点而新建目录的时候，需要提醒
if (getSelectNode() == null) {
JOptionPane.showMessageDialog(this, "请选择目录");
return;
}
AddInfo info = new AddInfo("目录名称：", this, new AddFolderHandler());
showAddFrame(info);
} //新建项目的方法
public void newProject() {
AddInfo info = new AddInfo("项目名称：", this, new AddProjectHandler());
showAddFrame(info);
} //重新在treePane中构造一次树
public void refreshTree(JTree newTree) {
//将tree对象变为参数中的newTree
this.tree = newTree;
//让treePane（放树的容器）设置newTree为新的视图
treePane.setViewportView(newTree);
//更新界面
treePane.updateUI();
} public EditFile getCurrentFile() {
return currentFile;
} public void setCurrentFile(EditFile currentFile) {
this.currentFile = currentFile;
} public List<EditFile> getOpenFiles() {
return openFiles;
} public JDesktopPane getDesk() {
return desk;
} public JTabbedPane getTabPane() {
return tabPane;
} //根据JInternalFrame标题找到JInternalFrame对象
public JInternalFrame getIFrame(String title) {
JInternalFrame[] iframes = desk.getAllFrames();
for (JInternalFrame iframe : iframes) {
if (iframe.getTitle().equals(title)) return iframe;
}
return null;
} //根据JInternalFrame在打开的文件集合中获取相应的文件对象
public EditFile getEditFile(JInternalFrame iframe) {
for (EditFile openFile : openFiles) {
if (openFile.getIframe().equals(iframe)) return openFile;
}
return null;
} //询问是否要保存, 参数为将被打开的文件
public void askSave(EditFile file) {
//该份文件修改过没有保存
if (!file.isSaved()) {
//弹出询问
int val = JOptionPane.showConfirmDialog(this, "是否要保存？", "询问",
JOptionPane.YES_NO_OPTION);
//点击了需要保存
if (JOptionPane.YES_OPTION == val) {
//调用EditorFrame的保存方法对文件进行保存
saveFile(file);
}
}
} //用于保存当前所打开的文件
public void saveFile(EditFile file) {
if (file == null) return;
//调用中介者对象的方法去保存文件
String result = saveMediator.doSave(this);
//将结果放到信息显示区的文本域中
infoArea.setText(result);
//写完文件后，设置当前文件的保存状态为true，表示已经保存
file.setSaved(true);
} //关闭一个窗口
public void closeIFrame(JInternalFrame iframe) {
//获得当前的文件，即要关闭的文件对象
EditFile closeFile = getEditFile(iframe);
//设置本类中的currentFile属性
afterClose(closeFile);
//获得该iframe在tab页中对应的索引
int index = getTabIndex(iframe.getTitle());
//从tab页中删除
getTabPane().remove(index);
//从打开的文件集合中删除这个关闭的文件
openFiles.remove(closeFile);
} //当关闭一份文件后，设置本对象的currentFile属性
private void afterClose(EditFile closeFile) {
//获取关闭文件在打开文件集合中的索引
int openFilesIndex = getEditFileIndex(closeFile);
//如果该文件已经是所有打开的文件的最后一份
if (this.openFiles.size() == 1) {
this.currentFile = null;
} else {//如果还有其他文件，判断关闭的文件位置
if (openFilesIndex == 0) {
//如果关闭的文件是第一份，拿集合中的第二份
this.currentFile = openFiles.get(openFilesIndex + 1);
} else if (openFilesIndex == (openFiles.size() - 1)) {
//如果关闭的是最后一份，取倒数第二份
this.currentFile = openFiles.get(openFiles.size() - 2);
} else {
//不是第一份，也不是最后一份
this.currentFile = openFiles.get(openFilesIndex - 1);
}
}
} //获取editFile在打开的文件集合中的索引
private int getEditFileIndex(EditFile editFile) {
for (int i = 0; i < this.openFiles.size(); i++) {
if (openFiles.get(i).equals(editFile)) return i;
}
return -1;
} //返回项目树当前所选中的节点所属的项目节点对应的目录
public File getCurrentProject() {
//获取根节点(工作空间)
ProjectTreeNode root = (ProjectTreeNode)getSelectNode().getRoot();
//获取根节点下的所有子节点（即项目节点集合）
List<ProjectTreeNode> projects = root.getChildren();
ProjectTreeNode selectNode = getSelectNode();
if (selectNode != null) {
for (ProjectTreeNode project : projects) {
//当前先中节点是该project下的子节点
if (selectNode.isNodeAncestor(project)) {
return project.getFile();
}
}
}
return null;
} //运行文件的方法
public void run() {
//运行前先保存
saveFile(getCurrentFile());
//将结果显示
String result = runHandler.run(this);
infoArea.setText(result);
} }
class FileChooser extends JFileChooser { private EditorFrame editorFrame; public FileChooser(EditorFrame editorFrame){
//调用父类的构造器
//利用editorFrame的工作空间作为文件选择器打开时的默认目录
super(editorFrame.getWorkSpace().getFolder());
this.editorFrame = editorFrame;
showOpenDialog(editorFrame);
} public void approveSelection() {
File file = getSelectedFile();
//设置树当前选择的节点为null, 即树没有被选中
this.editorFrame.getTree().setSelectionPath(null);
this.editorFrame.openFile(file);
super.approveSelection();
}
}
EditorFrame
package org.crazyit.editor; import java.awt.Color;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner; import javax.swing.JTextPane;
import javax.swing.text.Element;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument; import org.crazyit.editor.util.FileUtil; /**
* 编辑界面
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class EditPane extends JTextPane { //样式文档对象
protected StyledDocument doc;
//构造一个文本格式器
protected SyntaxFormatter formatter = new SyntaxFormatter("java.stx");
private SimpleAttributeSet quotAttr = new SimpleAttributeSet();
//保存文档改变的开始位置
private int docChangeStart = 0;
//保存文档改变的长度
private int docChangeLength = 0;
//定义文档中行数文本的外观属性
private SimpleAttributeSet lineAttr = new SimpleAttributeSet(); public EditPane(File file) {
this.setText(FileUtil.readFile(file));
this.doc = getStyledDocument();
//设置该文档的页边距
this.setMargin(new Insets(3, 40, 0, 0));
syntaxParse();
//添加按键监听器，当按键松开时进行语法分析
this.addKeyListener(new KeyAdapter() {
public void keyReleased(KeyEvent ke)
{
syntaxParse();
}
});
}
//
// //重写父类方法，使JTextPane不会自动换行
// public boolean getScrollableTracksViewportWidth() {
// return (getSize().width < getParent().getSize().width - 100);
// }
//
// //重写父类方法，使JTextPane不会自动换行
// public void setSize(Dimension d) {
// if (d.width < getParent().getSize().width) {
// d.width = getParent().getSize().width;
// }
// d.width += 100;
// super.setSize(d);
// } public void syntaxParse() {
try {
//获取文档的根元素，即文档内的全部内容
Element root = doc.getDefaultRootElement();
//获取文档中光标插入符的位置
int cursorPos = this.getCaretPosition();
int line = root.getElementIndex(cursorPos);
//获取光标所在位置的行
Element para = root.getElement(line);
//定义光标所在行的行头在文档中位置
int start = para.getStartOffset();
//如果文档修改位置比当前行还前
if (start > docChangeStart) {
start = docChangeStart;
}
//定义被修改部分的长度
int length = para.getEndOffset() - start;
if (length < docChangeLength) {
length = docChangeLength + 1;
}
//取出所有被修改的字符串
String s = doc.getText(start, length);
//以空格、点号等作为分隔符
String[] tokens = s.split("\\s+|\\.|\\(|\\)|\\{|\\}|\\[|\\]");
//定义当前分析单词的在s字符串中的开始位置
int curStart = 0;
boolean isQuot = false;
for (String token : tokens) {
//找出当前分析单词在s字符串的中位置
int tokenPos = s.indexOf(token , curStart);
if (isQuot && (token.endsWith("\"") || token.endsWith("\'"))) {
doc.setCharacterAttributes(start + tokenPos, token.length(), quotAttr, false);
isQuot = false;
}
else if (isQuot && !(token.endsWith("\"") || token.endsWith("\'"))) {
doc.setCharacterAttributes(start + tokenPos, token.length(), quotAttr, false);
}
else if ((token.startsWith("\"") || token.startsWith("\'"))
&& (token.endsWith("\"") || token.endsWith("\'"))) {
doc.setCharacterAttributes(start + tokenPos, token.length(), quotAttr, false);
}
else if ((token.startsWith("\"") || token.startsWith("\'"))
&& !(token.endsWith("\"") || token.endsWith("\'"))) {
doc.setCharacterAttributes(start + tokenPos, token.length(), quotAttr, false);
isQuot = true;
}
else {
//使用格式器对当前单词设置颜色
formatter.setHighLight(doc , token , start + tokenPos, token.length());
}
//开始分析下一个单词
curStart = tokenPos + token.length();
}
}
catch (Exception ex) {
ex.printStackTrace();
}
}
//重画该组件，设置行号
public void paint(Graphics g){
super.paint(g);
Element root = doc.getDefaultRootElement();
//获得行号
int line = root.getElementIndex(doc.getLength());
//设置颜色
g.setColor(new Color(230, 230, 230));
//绘制行数矩形框
g.fillRect(0, 0, this.getMargin().left - 10, getSize().height);
//设置行号的颜色
g.setColor(new Color(40, 40, 40));
//每行绘制一个行号
for (int count = 0, j = 1; count <= line; count++, j++) {
g.drawString(String.valueOf(j), 3,
(int)((count + 1) * 1.5020 * StyleConstants.getFontSize(lineAttr)));
}
}
}
class SyntaxFormatter {
//以一个Map保存关键字和颜色的对应关系
private Map<SimpleAttributeSet , ArrayList> attMap
= new HashMap<SimpleAttributeSet , ArrayList>();
//定义文档的正常文本的外观属性
SimpleAttributeSet normalAttr = new SimpleAttributeSet();
public SyntaxFormatter(String syntaxFile) {
//设置正常文本的颜色、大小
StyleConstants.setForeground(normalAttr, Color.BLACK);
//StyleConstants.setFontSize(normalAttr, 14);
//创建一个Scanner对象，负责根据语法文件加载颜色信息
Scanner scaner = null;
try {
scaner = new Scanner(new File(syntaxFile));
}
catch (FileNotFoundException e) {
throw new RuntimeException("丢失语法文件：" + e.getMessage());
}
int color = -1;
ArrayList<String> keywords = new ArrayList<String>();
//不断读取语法文件的内容行
while(scaner.hasNextLine()) {
String line = scaner.nextLine();
//如果当前行以#开头
if (line.startsWith("#")) {
if (keywords.size() > 0 && color > -1) {
//取出当前行的颜色值，并封装成SimpleAttributeSet对象
SimpleAttributeSet att = new SimpleAttributeSet();
StyleConstants.setForeground(att, new Color(color));
//StyleConstants.setFontSize(att, 14);
//将当前颜色和关键字List对应起来
attMap.put(att , keywords);
}
//重新创建新的关键字List，为下一个语法格式准备
keywords = new ArrayList<String>();
color = Integer.parseInt(line.substring(1) , 16);
} else {
//对于普通行，每行内容添加到关键字List里
if (line.trim().length() > 0) {
keywords.add(line.trim());
}
}
}
//把最后的关键字和颜色对应起来
if (keywords.size() > 0 && color > -1) {
SimpleAttributeSet att = new SimpleAttributeSet();
StyleConstants.setForeground(att, new Color(color));
attMap.put(att , keywords);
}
}
//返回该格式器里正常文本的外观属性
public SimpleAttributeSet getNormalAttributeSet() {
return normalAttr;
}
//设置语法高亮
public void setHighLight(StyledDocument doc , String token ,
int start , int length) {
//保存需要对当前单词对应的外观属性
SimpleAttributeSet currentAttributeSet = null;
outer :
for (SimpleAttributeSet att : attMap.keySet())
{
//取出当前颜色对应的所有关键字
ArrayList keywords = attMap.get(att);
//遍历所有关键字
for (Object keyword : keywords)
{
//如果该关键字与当前单词相同
if (keyword.toString().equals(token))
{
//跳出循环，并设置当前单词对应的外观属性
currentAttributeSet = att;
break outer;
}
}
}
//如果当前单词对应的外观属性不为空
if (currentAttributeSet != null){
//设置当前单词的颜色
doc.setCharacterAttributes(start, length, currentAttributeSet, false);
} else {//否则使用普通外观来设置该单词
doc.setCharacterAttributes(start, length, normalAttr, false);
}
}
}
EditPane
package org.crazyit.editor; import javax.swing.JInternalFrame;
import javax.swing.event.InternalFrameAdapter;
import javax.swing.event.InternalFrameEvent; import org.crazyit.editor.commons.EditFile; /**
* 窗口监听器
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class IFrameListener extends InternalFrameAdapter { private EditorFrame editorFrame; public IFrameListener(EditorFrame editorFrame) {
this.editorFrame = editorFrame;
} public void internalFrameActivated(InternalFrameEvent e) {
JInternalFrame iframe = editorFrame.getDesk().getSelectedFrame();
int tapIndex = editorFrame.getTabIndex(iframe.getTitle());
editorFrame.getTabPane().setSelectedIndex(tapIndex);
} public void internalFrameClosing(InternalFrameEvent e) {
//获取当前关闭操作所对应的JInternalFrame
JInternalFrame iframe = (JInternalFrame)e.getSource();
//获取当前操作的文件
EditFile editFile = editorFrame.getCurrentFile();
//询问是否要保存
editorFrame.askSave(editFile);
//关闭当前的iframe
editorFrame.closeIFrame(iframe);
}
}
IFrameListener
package org.crazyit.editor; import java.awt.Label;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File; import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField; import org.crazyit.editor.commons.WorkSpace; /**
* 工作空间界面
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class SpaceFrame extends JFrame { private JPanel mainPanel; private JLabel infoLabel; private JPanel chosePanel; private JLabel workTextLabel; //工作空间中显示用户选择文件目录的JTextField
private JTextField pathText; private JButton choseButton; private JPanel buttonPanel; //工作空间中的确定按钮
private JButton confirmButton; private JButton cancelButton; private SpaceChooser chooser; //用户选择的文件目录对象
private File folder; public SpaceFrame(EditorFrame editorFrame) {
mainPanel = new JPanel();
infoLabel = new JLabel("请选择工作空间");
chosePanel = new JPanel();
workTextLabel = new JLabel("工作空间: ");
pathText = new JTextField("", 40);
choseButton = new JButton("选择");
buttonPanel = new JPanel();
confirmButton = new JButton("确定");
cancelButton = new JButton("取消");
chooser = new SpaceChooser(this); //设置主Panel的布局
mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS));
mainPanel.add(infoLabel);
//设置选择区的布局
chosePanel.setLayout(new BoxLayout(chosePanel, BoxLayout.X_AXIS));
choseButton.addActionListener(new ChoseButtonListener(chooser));
pathText.setEditable(false);
chosePanel.add(workTextLabel);
chosePanel.add(pathText);
chosePanel.add(choseButton);
mainPanel.add(chosePanel); confirmButton.setEnabled(false);
//为确定按钮添加确定的事件, 即创建一个WorkSpace对象
confirmButton.addActionListener(new ConfirmButtonListener(this, editorFrame));
buttonPanel.add(confirmButton);
buttonPanel.add(new Label(" "));
buttonPanel.add(cancelButton);
//为取消按钮添加退出事件
cancelButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
System.exit(0);
}
});
mainPanel.add(buttonPanel);
add(mainPanel);
pack();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocation(300, 200);
setResizable(false);
} public File getFolder() {
return folder;
} public void setFolder(File folder) {
this.folder = folder;
} public JTextField getPathText() {
return pathText;
} public JButton getConfirmButton() {
return confirmButton;
}
} /**
* 确定按钮的监听器
* @author hp
*
*/
class ConfirmButtonListener implements ActionListener { private SpaceFrame spaceFrame; private EditorFrame editorFrame; public ConfirmButtonListener(SpaceFrame spaceFrame, EditorFrame editorFrame) {
this.spaceFrame = spaceFrame;
this.editorFrame = editorFrame;
} public void actionPerformed(ActionEvent arg0) {
//调EditorFrame的initFrame方法初始化界面
editorFrame.initFrame(new WorkSpace(spaceFrame.getFolder(), editorFrame));
//将EditorFrame设为可见
editorFrame.setVisible(true);
editorFrame.setSize(900, 600);
//让工作选择空间界面不可见
spaceFrame.setVisible(false);
}
} /**
* 选择按钮的监听器
* @author hp
*
*/
class ChoseButtonListener implements ActionListener { private JFileChooser chooser; public ChoseButtonListener(JFileChooser chooser) {
this.chooser = chooser;
} @Override
public void actionPerformed(ActionEvent arg0) {
chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
chooser.showOpenDialog(null);
} } /**
* 文件选择器
* @author hp
*
*/
class SpaceChooser extends JFileChooser { private SpaceFrame spaceFrame; //需要将SpaceFrame作为构造参数
public SpaceChooser(SpaceFrame spaceFrame) {
//设置选择器打开时的目录
super("/");
this.spaceFrame = spaceFrame;
} //重写父类的选择文件方法
public void approveSelection() {
//获取用户选择的文件
File folder = getSelectedFile();
//设置SpaceFrame的属性folder的值
spaceFrame.setFolder(folder);
//设置SpaceFrame文本框
spaceFrame.getPathText().setText(folder.getAbsolutePath());
//设置确定按钮可用
spaceFrame.getConfirmButton().setEnabled(true);
//调用父类的选择文件方法
super.approveSelection();
}
}
SpaceFrame
package org.crazyit.editor; import javax.swing.JInternalFrame;
import javax.swing.JTabbedPane;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener; import org.crazyit.editor.commons.EditFile; /**
* tab页转换监听器
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class TabListener implements ChangeListener { private EditorFrame editorFrame; public TabListener(EditorFrame editorFrame) {
this.editorFrame = editorFrame;
} public void stateChanged(ChangeEvent e) {
//获得当前点击tab页对象
JTabbedPane tab = (JTabbedPane)e.getSource();
//获得tab页的索引
int index = tab.getSelectedIndex();
if (index == -1) return;
//根据tab页的tips(文件的绝对路径)获得当前的JInternalFrame对象
JInternalFrame currentFrame = editorFrame.getIFrame(tab.getToolTipTextAt(index));
//让当前点击的JInternalFrame对象可见
editorFrame.showIFrame(currentFrame);
//根据当前的JInternalFrame对象获得对应的文件
EditFile currentFile = editorFrame.getEditFile(currentFrame);
//设置EditorFrame当前编辑的文件为tab对应的文件
editorFrame.setCurrentFile(currentFile);
} }
TabListener
package org.crazyit.editor; import org.crazyit.editor.tree.TreeCreator;
import org.crazyit.editor.tree.TreeCreatorImpl; /**
* 程序入口类
*
* @author yangenxiong yangenxiong2009@gmail.com
* @version 1.0
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br>Copyright (C), 2009-2010, yangenxiong
* <br>This program is protected by copyright laws.
*/
public class Main { public static void main(String[] args) {
TreeCreator treeCreator = new TreeCreatorImpl();
//创建EditorFrame，暂时不用设置可见
EditorFrame editorFrame = new EditorFrame("ide", treeCreator);
//将editorFrame对象作为SpaceFrame的构造参数
SpaceFrame spaceFrame = new SpaceFrame(editorFrame);
//让SpaceFrame可见
spaceFrame.setVisible(true);
}
}
Main