用户注册



邮箱：

密码：

用户登录


邮箱：

密码：
记住登录一个月忘记密码？

发表随想


还能输入：200字
云代码 - java代码库

文本编辑器（能编辑html、java、cpp、txt文件，java编译与运行）

2012-11-24 作者： 程序猿style举报

[java]代码库

view sourceprint?
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTabbedPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.JToolBar;
import javax.swing.JTree;
import javax.swing.Timer;
import javax.swing.border.BevelBorder;
import javax.swing.event.CaretEvent;
import javax.swing.event.CaretListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.filechooser.FileFilter;
import javax.swing.text.BadLocationException;
import javax.swing.tree.DefaultMutableTreeNode;
 
/**
 * 一个简单的文本编辑器，能够编辑html、java、cpp、txt文件， 并支持java的编译与运行
 */
public class SimpleEditor extends JFrame {
 
    /******** 菜单栏、菜单和菜单项 *********/
    JMenuBar menuBar = new JMenuBar();
    JMenu fileMenu = new JMenu("File");
    JMenu optionMenu = new JMenu("Option");
    JMenu advanceMenu = new JMenu("Advance");
    JMenu helpMenu = new JMenu("Help");
    JMenu editMenu = new JMenu("Edit");
    JMenuItem newMenuItem = new JMenuItem("new");
    JMenuItem openMenuItem = new JMenuItem("Open");
    JMenuItem saveMenuItem = new JMenuItem("Save");
    JMenuItem exitMenuItem = new JMenuItem("exit");
    JMenuItem findMenuItem = new JMenuItem("Find");
    JMenuItem findNextMenuItem = new JMenuItem("Find Next");
    JMenuItem replaceMenuItem = new JMenuItem("Replace");
    JMenuItem compileMenuItem = new JMenuItem("Compile");
    JMenuItem buildMenuItem = new JMenuItem("Build");
    JMenuItem stopFlashMenuItem = new JMenuItem("Stop Flash");
    JMenuItem startFlashMenuItem = new JMenuItem("Start Flash");
    JMenuItem helpMenuItem = new JMenuItem("Help");
    JMenuItem copyMenuItem = new JMenuItem("Copy");
    JMenuItem cutMenuItem = new JMenuItem("Cut");
    JMenuItem pasteMenuItem = new JMenuItem("Paste");
 
    /******** 文件内容的显示 ****/
    // 用多个文本域存放多个文件内容，文本域放在JScrollPane里
    // 而JScrollPane放在JTabbedPane中，这就是一个多页面的布局
 
    // 多个文本域，每个文本域显示一个文件的内容
    JTextArea[] fileTextAreas = new JTextArea[10];
    // 编译或者运行时的控制台信息
    JTextArea consoleTextArea = new JTextArea();
    JScrollPane[] fileScrollPanes = new JScrollPane[10];
    JScrollPane consoleScrollPane;
    // 多个文本域放在不同tab里
    JTabbedPane fileTabbedPane = new JTabbedPane();
 
    /********** 工具栏以及工具栏上的按钮 **********/
    JToolBar toolBar = new JToolBar();
    JButton openButton = new JButton(new ImageIcon(loadImage("image/open.gif")));
    JButton newButton = new JButton(new ImageIcon(loadImage("image/new.gif")));
    JButton saveButton = new JButton(new ImageIcon(loadImage("image/save.gif")));
    JButton helpButton = new JButton(new ImageIcon(loadImage("image/help.gif")));
    JButton exitButton = new JButton(
            new ImageIcon(loadImage("image/close.gif")));
    JButton compileButton = new JButton(new ImageIcon(
            loadImage("image/compile.gif")));
    JButton buildButton = new JButton(new ImageIcon(
            loadImage("image/build.gif")));
    JButton copyButton = new JButton(new ImageIcon(loadImage("image/copy.gif")));
    JButton cutButton = new JButton(new ImageIcon(loadImage("image/cut.gif")));
    JButton pasteButton = new JButton(new ImageIcon(
            loadImage("image/paste.gif")));
 
    // 该文本域显示当前光标在当前文本域中的行号
    JTextArea showLineNoTextArea = new JTextArea();
    // 对话框窗体，程序中所有对话框都显示在该窗体中
    JFrame dialogFrame = new JFrame();
 
    /***** 文件名以树型结构在左边显示 *******/
    JTree tree;
    DefaultMutableTreeNode root;
    DefaultMutableTreeNode[] nodes = new DefaultMutableTreeNode[10];
 
    /******* 组件之间的分隔栏 ******/
    JSplitPane leftRightSplitPane;
    JSplitPane lineNoConsoleSplitPane;
    JSplitPane treeFlashSplitPane;
    JSplitPane tabbedLineNoSplitPane;
 
    /********** 文件选择、存储相关 ********/
    // 文件过滤器
    Filter fileFilter = new Filter();
    // 文件选择器
    FileChooser fileChooser = new FileChooser();
    // 文件读写控制，0表示文件选择器读文件，1文件选择器标示写文件
    int fileChooser_control = 0;
    FileWriter fileWriter;
 
    // tabbedPane中tab页的当前数量
    int tb = 1;
    int find_control = 0;
    // 文本域的控制器，指向当前操作的文本域
    int textAreas_control = 0;
    // 当前文本域中的文本
    String currentTextInTextArea;
 
    // 标志文件是否为新建的，如果是新建的文件，为true
    boolean[] newFileFlags = new boolean[10];
    // 存放打开文件所在的目录
    String[] directory = new String[10];
 
    /******** 查找替换相关 ****/
    // 正在查找的字符串及其长度
    String findWord;
    int fingWordLength;
    // 保存正在查找的字符串在文本域中的文本的位置
    int findIndex;
    // 被替换的文本的长度
    int replaceLength = 0;
 
    /******** 用于显示Flash的控制器 ****/
    JLabel flashLabel = new JLabel(new ImageIcon(
            loadImage("image/Juggler0.gif")));
    Timer timer = new Timer(100, new Act_timer());
    int timerControl = 0;
 
    /******** 帮助相关 ****/
    Font font = new Font("Courier", Font.TRUETYPE_FONT, 14);
    JTextArea helpTextArea = new JTextArea();
    JFrame helpFrame = new JFrame("Help");
 
    // 构造函数
    public SimpleEditor() {
        super("文本编辑器");
 
        // 为窗体添加键盘事件处理器
        // 下面这一行非常重要，表示窗体能够接受焦点。
        // 如果没有这一句，按键盘会无效。
        this.setFocusable(true);
        this.addKeyListener(new MyKeyListener());
 
        // 为窗体添加窗口事件处理器
        this.addWindowListener(new WindowListener());
 
        // 初始化
        init();
        setLocation(200, 200);
        setVisible(true);
        pack();
        // 初始时启动动画
        timer.start();
    }
 
    private void init() {
 
        /******* 初始化文本域、目录、树节点 *********/
        for (int i = 0; i < 10; i++) {
            nodes[i] = new DefaultMutableTreeNode("File" + (i + 1));
            newFileFlags[i] = true;
            fileTextAreas[i] = new JTextArea();
            // 设置文本域中文本的字体
            fileTextAreas[i].setFont(font);
            // 为文本域的插入光标设置颜色
            fileTextAreas[i].setCaretColor(Color.yellow);
            // 设置文本域的背景和前景颜色
            fileTextAreas[i].setBackground(new Color(70, 80, 91));
            fileTextAreas[i].setForeground(Color.pink);
            // 为文本域插入光标设置事件处理器
            fileTextAreas[i].addCaretListener(new CaretLis_lineNo());
            // 为文本域键盘设置事件处理器
            fileTextAreas[i].addKeyListener(new MyKeyListener());
            directory[i] = new String("/");
            fileScrollPanes[i] = new JScrollPane(fileTextAreas[i],
                    JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
                    JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        }
        root = new DefaultMutableTreeNode("正在编辑的文件");
        root.add(nodes[0]);
        tree = new JTree(root);
        tree.setEditable(false);
        tree.setForeground(new Color(200, 150, 10));
        tree.setBackground(new Color(70, 80, 91));
 
        // 初始化控制台文本域
        consoleTextArea.setFont(font);
        consoleScrollPane = new JScrollPane(consoleTextArea,
                JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
                JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
        consoleTextArea.setForeground(new Color(200, 150, 10));
        consoleTextArea.setBackground(new Color(70, 80, 91));
        consoleTextArea.addMouseListener(new MouseListener_console());
 
        // 初始化显示当前光标行数的文本域
        showLineNoTextArea.setEnabled(false);
        showLineNoTextArea.setFont(font);
        showLineNoTextArea.setBackground(new Color(70, 80, 91));
        showLineNoTextArea.setDisabledTextColor(Color.yellow);
 
        /************** 初始化菜单 *************/
        // 初始化菜单项
        newMenuItem.addActionListener(new Act_NewFile());
        openMenuItem.addActionListener(new Act_OpenFile());
        saveMenuItem.addActionListener(new Act_SaveFile());
        exitMenuItem.addActionListener(new Act_ExitEditor());
        findMenuItem.addActionListener(new Act_Find());
        findNextMenuItem.addActionListener(new Act_FindNext());
        replaceMenuItem.addActionListener(new Act_Replace());
        compileMenuItem.addActionListener(new Act_Compile());
        buildMenuItem.addActionListener(new Act_Build());
        helpMenuItem.addActionListener(new Act_Help());
        copyMenuItem.addActionListener(new Act_Copy());
        cutMenuItem.addActionListener(new Act_Cut());
        pasteMenuItem.addActionListener(new Act_Paste());
        stopFlashMenuItem.addActionListener(new Act_StopFlash());
        startFlashMenuItem.addActionListener(new Act_StartFlash());
        startFlashMenuItem.setEnabled(false);
        // 初始化菜单
        fileMenu.add(newMenuItem);
        fileMenu.add(openMenuItem);
        fileMenu.add(saveMenuItem);
        fileMenu.add(exitMenuItem);
        optionMenu.add(findMenuItem);
        optionMenu.add(findNextMenuItem);
        optionMenu.add(replaceMenuItem);
        advanceMenu.add(compileMenuItem);
        advanceMenu.add(buildMenuItem);
        advanceMenu.addSeparator();
        advanceMenu.add(stopFlashMenuItem);
        advanceMenu.add(startFlashMenuItem);
        helpMenu.add(helpMenuItem);
        editMenu.add(copyMenuItem);
        editMenu.add(cutMenuItem);
        editMenu.add(pasteMenuItem);
        // 初始化菜单栏
        menuBar.add(fileMenu);
        menuBar.add(optionMenu);
        menuBar.add(advanceMenu);
        menuBar.add(editMenu);
        menuBar.add(helpMenu);
        // 将菜单栏添加到窗体中
        setJMenuBar(menuBar);
 
        /*********** 初始化工具栏以及按钮 **********/
        // 初始化按钮
        newButton.addActionListener(new Act_NewFile());
        openButton.addActionListener(new Act_OpenFile());
        saveButton.addActionListener(new Act_SaveFile());
        exitButton.addActionListener(new Act_ExitEditor());
        compileButton.addActionListener(new Act_Compile());
        buildButton.addActionListener(new Act_Build());
        helpButton.addActionListener(new Act_Help());
        copyButton.addActionListener(new Act_Copy());
        cutButton.addActionListener(new Act_Cut());
        pasteButton.addActionListener(new Act_Paste());
        // 为工具栏设置提示信息，当鼠标在工具栏按钮上停留一段时间时，会显示提示信息
        newButton.setToolTipText("New");
        openButton.setToolTipText("Open");
        saveButton.setToolTipText("Save");
        exitButton.setToolTipText("Exit");
        helpButton.setToolTipText("Help");
        compileButton.setToolTipText("Compile");
        buildButton.setToolTipText("Build");
        copyButton.setToolTipText("Copy");
        cutButton.setToolTipText("Cut");
        pasteButton.setToolTipText("Paste");
        newButton.setBorder(new BevelBorder(BevelBorder.RAISED));
        openButton.setBorder(new BevelBorder(BevelBorder.RAISED));
        saveButton.setBorder(new BevelBorder(BevelBorder.RAISED));
        exitButton.setBorder(new BevelBorder(BevelBorder.RAISED));
        helpButton.setBorder(new BevelBorder(BevelBorder.RAISED));
        compileButton.setBorder(new BevelBorder(BevelBorder.RAISED));
        buildButton.setBorder(new BevelBorder(BevelBorder.RAISED));
        cutButton.setBorder(new BevelBorder(BevelBorder.RAISED));
        copyButton.setBorder(new BevelBorder(BevelBorder.RAISED));
        pasteButton.setBorder(new BevelBorder(BevelBorder.RAISED));
        // 初始化工具栏
        toolBar.add(newButton);
        toolBar.add(openButton);
        toolBar.add(saveButton);
        toolBar.add(copyButton);
        toolBar.add(cutButton);
        toolBar.add(pasteButton);
        toolBar.add(compileButton);
        toolBar.add(buildButton);
        toolBar.add(exitButton);
        toolBar.add(helpButton);
 
        /******** 初始化tab页面板和组件间的分隔栏 *********/
        fileTabbedPane.addTab("File1", fileScrollPanes[0]);
        fileTabbedPane.addChangeListener(new Act_ChangeTab());
        // 文件目录树和Flash之间的分隔栏
        treeFlashSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true,
                flashLabel, tree);
        // 文件文本域面板与指示光标所在行文本域面板之间的分隔栏
        tabbedLineNoSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true,
                fileTabbedPane, showLineNoTextArea);
        // 右边上2个面板与控制台面板的分隔栏
        lineNoConsoleSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT,
                true, tabbedLineNoSplitPane, consoleScrollPane);
        // 左边大面板与右边大面板之间的分隔栏
        leftRightSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true,
                treeFlashSplitPane, lineNoConsoleSplitPane);
        // 设置分隔栏两边面板显示的宽度，如果分割条是左右分割，则参数表示分割条的横坐标
        // 如果分割条是上下分割，则参数表示分割条的纵坐标
        leftRightSplitPane.setDividerLocation(150);
        tabbedLineNoSplitPane.setDividerLocation(460);
        lineNoConsoleSplitPane.setDividerLocation(500);
        treeFlashSplitPane.setDividerLocation(120);
 
        // 初始化帮助
        initHelp();
 
        getContentPane().setLayout(new BorderLayout());
        getContentPane().add(toolBar, BorderLayout.NORTH);
        getContentPane().add(leftRightSplitPane);
    }
 
    /**
     * 初始化帮助信息
     */
    private void initHelp() {
        // 帮助信息主要显示菜单的快捷方式
 
        // field存放JTable的表头信息，即表的标题
        String[] field = { "MenuItem", "ShortCut Key" };
        // data存放JTable的数据。
        Object[][] data = { { "     New           ", "    Ctrl+N    " },
                { "    Open          ", "    F12       " },
                { "    Save          ", "    Ctrl+S    " },
                { "    Exit          ", "    Ctrl+X    " },
                { "    Find          ", "    Alt       " },
                { "    Find Next     ", "    F3        " },
                { "    Compile       ", "    F9        " },
                { "    Build         ", "    F5        " },
                { "    Copy          ", "    Ctrl+C    " },
                { "    Cut           ", "    Ctrl+X    " },
                { "    Paste         ", "    Ctrl+Y    " },
                { "    Help          ", "    Ctrl+H    " }, };
        // 用表头和数据构造一个表
        JTable help_Table = new JTable(data, field);
        help_Table.setFont(font);
        // 不可编辑帮助信息表
        help_Table.setEnabled(false);
        // 为表和文本域设置背景和前景颜色
        helpTextArea.setFont(new Font("Courier", Font.TRUETYPE_FONT, 16));
        helpFrame.getContentPane().setLayout(new BorderLayout());
        help_Table.setForeground(Color.pink);
        helpTextArea.setForeground(Color.pink);
        help_Table.setBackground(new Color(70, 80, 91));
        help_Table.setSelectionBackground(new Color(70, 80, 91));
        helpTextArea.setBackground(new Color(70, 80, 91));
        helpTextArea
                .setText(" If you want to use this software with all functions,\n"
                        + "     You must do the things following:\n"
                        + "     1: install jdk_1.3 or Higher than it ;\n"
                        + "     2: set your classpath and path correctly;\n"
                        + "     3: if you want to use the compile and build functions,\n"
                        + "       you should save your edited File in the save directory\n"
                        + "       with  this software.\n ");
        // 将文本域和表加到窗体中
        helpFrame.getContentPane().add(
                new JScrollPane(help_Table,
                        JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
                        JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED),
                BorderLayout.CENTER);
        helpFrame.getContentPane().add(
                new JScrollPane(helpTextArea,
                        JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
                        JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED),
                BorderLayout.NORTH);
    }
 
    // 退出编辑器
    private void exitEditor() {
        // 弹出一个选择确认对话框，请求确认退出
        if ((JOptionPane.showConfirmDialog(this, "你确定文本编辑器？", "退出",
                JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION)) {
            // 如果选择YES，则退出。
            // dispose方法用于释放资源
            // 释放由此 Window、其子组件及其拥有的所有子组件所使用的所有本机屏幕资源。
            // 即这些 Component 的资源将被破坏，它们使用的所有内存都将返回到操作系统，并将它们标记为不可显示。
            // 通过随后对 pack 或 show 的调用重新构造本机资源，可以再次显示 Window 及其子组件。
            // 重新创建的 Window 及其子组件的状态在移除 Window 的点上与这些对象的状态将是一样的（不考虑这些操作之间的其他更改）。
            dispose();
            System.exit(0);
        }
    }
 
    /**
     * 键盘事件处理器
     */
    public class MyKeyListener extends KeyAdapter {
        // 覆盖父类的keyPressed方法，处理键被按下时的事件。
        public void keyPressed(KeyEvent e) {
            // 按F12打开文件
            if (e.getKeyCode() == KeyEvent.VK_F12) {
                (new Act_OpenFile()).actionPerformed(null);
            }
            // 按Ctrl加S键保存文件
            else if (e.isControlDown() && e.getKeyCode() == KeyEvent.VK_S) {
                (new Act_SaveFile()).actionPerformed(null);
            }
            // 按Alt键查找
            else if (e.isAltDown()) {
                (new Act_Find()).actionPerformed(null);
            }
            // 按F3查找下一个
            else if (e.getKeyCode() == KeyEvent.VK_F3) {
                (new Act_FindNext()).actionPerformed(null);
            }
            // 按F4替换
            else if (e.getKeyCode() == KeyEvent.VK_F4) {
                (new Act_Replace()).actionPerformed(null);
            }
            // 按Ctrl加N新建文件
            else if (e.isControlDown() && e.getKeyCode() == KeyEvent.VK_N) {
                (new Act_NewFile()).actionPerformed(null);
            }
            // 按Ctrl加E退出编辑器
            else if (e.isControlDown() && e.getKeyCode() == KeyEvent.VK_E) {
                (new Act_ExitEditor()).actionPerformed(null);
            }
            // 按F5运行Java程序
            else if (e.getKeyCode() == KeyEvent.VK_F5) {
                (new Act_Build()).actionPerformed(null);
            }
            // 按F9编译Java源代码
            else if (e.getKeyCode() == KeyEvent.VK_F9) {
                (new Act_Compile()).actionPerformed(null);
            }
            // 按Ctrl加H显示帮助
            else if (e.isControlDown() && e.getKeyCode() == KeyEvent.VK_H) {
                (new Act_Help()).actionPerformed(null);
            }
        }
    }
 
    /**
     * 窗口事件侦听器
     */
    public class WindowListener extends WindowAdapter {
        // 处理关闭窗口事件
        public void windowClosing(WindowEvent e) {
            exitEditor();
        }
    }
 
    /**
     * 文件选择器
     */
    class FileChooser extends JFileChooser {
        public FileChooser() {
            // 文件选择器默认位置为当前文件夹
            super("./");
        }
 
        /**
         * 提交选择
         */
        public void approveSelection() {
            String filename = null;
            // fileChooser_control == 0表示现在是打开文件，需要读
            if (fileChooser_control == 0) {
                // 打开文件时，在左边的树中添加一个节点
                root.add(nodes[tb]);
                remove(tree);
                tree = new JTree(root);
                tree.setBackground(new Color(70, 80, 91));
                treeFlashSplitPane.setRightComponent(tree);
                treeFlashSplitPane.setDividerLocation(120);
                // 新建一个tab页，用于装新打开的文件
                fileTabbedPane.addTab("File" + (tb + 1), fileScrollPanes[tb]);
                fileTabbedPane.setSelectedIndex(tb);
                // 将当前文本域设置到新打开的文件上
                textAreas_control = tb;
                tb++;
 
                // 获取待打开的文件名
                filename = fileChooser.getSelectedFile().getName();
                // 获取待打开的文件所在的目录，将目录保存至数组，这样在保存文件的时候，能够将文件名保存到目录中
                directory[textAreas_control] = fileChooser
                        .getCurrentDirectory().toString();
                fileTextAreas[textAreas_control].setText(null);
                try {
                    // 将文件内容显示到文本域中
                    String str;
                    BufferedReader breader = new BufferedReader(new FileReader(
                            directory[textAreas_control] + "/" + filename));
                    while (true) {
                        str = breader.readLine();
                        if (str == null) {
                            break;
                        }
                        fileTextAreas[textAreas_control].append(str + '\n');
                    }
                } catch (Exception e_open) {
                    JOptionPane.showMessageDialog(dialogFrame.getContentPane(),
                            "读取发生错误");
                }
 
            } else if (fileChooser_control == 1) {
                // fileChooser_control == 1表示现在是保存新文件，需要写
                filename = fileChooser.getSelectedFile().getName();
                directory[textAreas_control] = fileChooser
                        .getCurrentDirectory().toString();
                try {
                    // 将文本域中的内容写到文件中
                    fileWriter = new FileWriter(directory[textAreas_control]
                            + "/" + filename);
                    fileWriter
                            .write(fileTextAreas[textAreas_control].getText());
                    fileWriter.close();
                } catch (Exception e_save) {
                    JOptionPane.showMessageDialog(dialogFrame.getContentPane(),
                            "读取发生错误");
                }
 
            }
 
            // 关闭对话框
            dialogFrame.dispose();
 
            // 更新文件目录树中的名字
            root.remove(nodes[textAreas_control]);
            nodes[textAreas_control] = new DefaultMutableTreeNode(filename);
            root.add(nodes[textAreas_control]);
            // 将当前显示的树删除、显示新的树
            remove(tree);
            tree = new JTree(root);
            tree.setBackground(new Color(70, 80, 91));
            treeFlashSplitPane.setRightComponent(tree);
            treeFlashSplitPane.setDividerLocation(120);
            // 将tab页的标题改为文件名
            fileTabbedPane.setTitleAt(textAreas_control, filename);
            // 无论是打开、还是保存，这个文件不是已经新建的，所以置为false
            newFileFlags[textAreas_control] = false;
        }
 
        /**
         * 取消选择
         */
        public void cancelSelection() {
            dialogFrame.dispose();
        }
    }
 
    /**
     * 文件过滤器，只支持编辑".java,*.html,*.txt,*.cpp"文件
     */
    class Filter extends FileFilter {
        // 覆盖FileFilter的accept方法
        public boolean accept(File file1) {
            return (file1.getName().endsWith(".java") || file1.isDirectory()
                    || file1.getName().endsWith(".html")
                    || file1.getName().endsWith(".txt") || file1.getName()
                    .endsWith(".cpp"));
        }
 
        public String getDescription() {
            return (".java,*.html,*.txt,*.cpp");
        }
    }
 
    /**
     * 用于侦听文本组件插入符的位置更改的侦听器 获取当前光标在文件中的行号
     */
    class CaretLis_lineNo implements CaretListener {
        public void caretUpdate(CaretEvent e) {
            try {
                showLineNoTextArea
                        .setText("          Cursor at the "
                                + (fileTextAreas[textAreas_control]
                                        .getLineOfOffset(fileTextAreas[textAreas_control]
                                                .getCaretPosition()) + 1)
                                + " line in the file of "
                                + fileTabbedPane.getTitleAt(textAreas_control));
            } catch (BadLocationException eB) {
                System.out.println("IO Wrong");
            }
        }
    }
 
    /**
     * 控制台文本域中鼠标事件的侦听器 当控制台中有错误信息时，表明Java源文件编译有问题，定位到出错的行号。
     */
    class MouseListener_console extends MouseAdapter {
        public void mouseClicked(MouseEvent e) {
            // 获取光标在控制台文本域中的位置
            int off_err = consoleTextArea.getCaretPosition();
            int line_no = 0;
            try {
                // 根据光标位置，定位它在控制台文本域中的行
                int index = -1;
                int line_err = consoleTextArea.getLineOfOffset(off_err - 1);
                // 获取光标所在行的起始字符在文本域中的位置
                int start_err = consoleTextArea.getLineStartOffset(line_err);
                // 获取光标所在行的起始位置到光标位置之间文本，即错误信息
                String err_str = consoleTextArea.getText(start_err, off_err
                        - start_err);
                // 高亮显示错误信息
                consoleTextArea.select(start_err, off_err);
                // 分析错误信息中是否有编译器指出的Java源文件行号，这里假定最多10000行源程序
                for (line_no = 0; line_no < 10000; line_no++) {
                    index = err_str.indexOf(":" + line_no + ":");
                    if (index > 0) {
                        break;
                    }
                }
                // 如果能够分析出Java源文件的行号，则在文件文本域中高亮显示。
                if (index != -1) {
                    fileTextAreas[textAreas_control].requestFocus();
                    fileTextAreas[textAreas_control].select(
                            fileTextAreas[textAreas_control]
                                    .getLineStartOffset(line_no - 1),
                            fileTextAreas[textAreas_control]
                                    .getLineEndOffset(line_no - 1));
                }
            } catch (BadLocationException eB) {
                System.out.println("IO Wrong");
            }
        }
    }
 
    /**
     * 切换tab页事件
     */
    class Act_ChangeTab implements ChangeListener {
        public void stateChanged(ChangeEvent e) {
            // 切换tab页时，更新textAreas_control的值。
            textAreas_control = fileTabbedPane.getSelectedIndex();
        }
    }
 
    /**
     * 新建文件事件
     */
    class Act_NewFile implements ActionListener {
        public void actionPerformed(ActionEvent e_ji0) {
            // 建立新文件时，更新树和tab页。
            root.add(nodes[tb]);
            remove(tree);
            tree = new JTree(root);
            tree.setBackground(new Color(70, 80, 91));
            treeFlashSplitPane.setRightComponent(tree);
            treeFlashSplitPane.setDividerLocation(120);
            fileTabbedPane.addTab("File" + (tb + 1), fileScrollPanes[tb]);
            fileTabbedPane.setSelectedIndex(tb);
            textAreas_control = tb;
            tb++;
        }
    }
 
    /**
     * 打开文件事件
     */
    class Act_OpenFile implements ActionListener {
        public void actionPerformed(ActionEvent e_ji1) {
            // 打开已有文件
            // 将文件选择器置为打开文件状态
            fileChooser_control = 0;
            fileChooser.setApproveButtonText("打开");
            fileChooser.addChoosableFileFilter(fileFilter);
            dialogFrame.getContentPane().add(fileChooser);
            dialogFrame.setSize(550, 350);
            dialogFrame.setTitle("请选择要打开的文件!");
            dialogFrame.setVisible(true);
            fileTextAreas[textAreas_control].setCaretPosition(0);
        }
    }
 
    /**
     * 保存文件事件
     */
    class Act_SaveFile implements ActionListener {
        public void actionPerformed(ActionEvent e_ji2) {
            System.out.println("Act_SaveFile" + textAreas_control);
            if (newFileFlags[textAreas_control]) {
                // 对于新建的文件，需要指定文件存储路径，因此调用了文件选择起存储文件
                // 将文件选择器置为保存文件状态
                fileChooser_control = 1;
                fileChooser.setApproveButtonText("保存");
                fileChooser.addChoosableFileFilter(fileFilter);
                dialogFrame.getContentPane().add(fileChooser);
                dialogFrame.setTitle("请输入文件名!");
                dialogFrame.setSize(550, 350);
                dialogFrame.setVisible(true);
 
            } else {
                try {
                    // 对于已经存在的文件，直接保存
                    // 写文件，将当前文本域中文本写入到文件。
                    fileWriter = new FileWriter(directory[textAreas_control]
                            + "/"
                            + fileTabbedPane.getTitleAt(textAreas_control));
                    fileWriter
                            .write(fileTextAreas[textAreas_control].getText());
                    fileWriter.close();
                } catch (Exception e_save) {
                    JOptionPane.showMessageDialog(null, "读取发生错误");
                }
            }
        }
    }
 
    /**
     * 退出编辑器事件
     */
    class Act_ExitEditor implements ActionListener {
        public void actionPerformed(ActionEvent e_ji3) {
            // 退出编辑器
            exitEditor();
        }
    }
 
    /**
     * 查找事件
     */
    class Act_Find implements ActionListener {
        public void actionPerformed(ActionEvent e_ji4) {
            // 查找对话框
            findWord = JOptionPane.showInputDialog("请输入查找内容");
            if (findWord == null) {
                JOptionPane.showMessageDialog(null, "查找失败！");
            } else {
                // 根据查找内容在当前文本域中进行匹配
                fingWordLength = findWord.length();
                currentTextInTextArea = fileTextAreas[textAreas_control]
                        .getText();
                findIndex = currentTextInTextArea.indexOf(findWord);
                if (findIndex < 0) {
                    JOptionPane.showMessageDialog(null, "   查找内容不存在  ");
                } else {
                    // 如果找到了，则将鼠标键盘焦点放在当前文本域中，并将匹配字符串标示出来
                    fileTextAreas[textAreas_control].requestFocus();
                    fileTextAreas[textAreas_control].select(findIndex,
                            findIndex + fingWordLength);
                }
            }
        }
    }
 
    /**
     * 查找下一个事件
     */
    class Act_FindNext implements ActionListener {
        public void actionPerformed(ActionEvent e_ji4_next) {
            // 查找下一个匹配的字符串
            currentTextInTextArea = fileTextAreas[textAreas_control].getText();
            findIndex = currentTextInTextArea.indexOf(findWord, findIndex + 1);
            if (findIndex < 0) {
                JOptionPane.showMessageDialog(null, " 查找已经到达文件尾！ ");
            } else {
                fileTextAreas[textAreas_control].select(findIndex, findIndex
                        + fingWordLength);
            }
        }
    }
 
    /**
     * 替换事件
     */
    class Act_Replace implements ActionListener {
        public void actionPerformed(ActionEvent e_ji5) {
            // 替换对话框
            Object[] endButton1 = { "Replace", "Cancel" };
            String message1 = "确认替换？";
            currentTextInTextArea = fileTextAreas[textAreas_control].getText();
 
            // 获取被替换的内容
            String seek_word = JOptionPane.showInputDialog("请输入查找内容");
            // 获取替换后的内容
            String replace_word = JOptionPane.showInputDialog("请输入替换内容");
            // 如果用户输入的查找内容不为null，则开始进行替换操作
            if (seek_word != null) {
                // 获取查找内容的长度，也就是将来替换的长度
                replaceLength = seek_word.length();
                while (true) {
                    // 先获取当前文本域的文本，再进行查找
                    currentTextInTextArea = fileTextAreas[textAreas_control]
                            .getText();
                    findIndex = currentTextInTextArea.indexOf(seek_word,
                            findIndex + replaceLength);
                    if (findIndex < 0) {
                        // 文本中不存在查找内容
                        JOptionPane.showMessageDialog(null, "查找已经到达文件尾！");
                        break;
                    } else {
                        // 查找成功，则标示出查找内容
                        fileTextAreas[textAreas_control].requestFocus();
                        fileTextAreas[textAreas_control].select(findIndex,
                                findIndex + replaceLength);
                        // 替换确认
                        JOptionPane end1 = new JOptionPane(message1,
                                JOptionPane.WARNING_MESSAGE,
                                JOptionPane.DEFAULT_OPTION, null, endButton1);
                        JDialog endD1 = end1.createDialog(end1, "请选择");
                        endD1.setVisible(true);
                        Object push1 = end1.getValue();
                        if (push1 == endButton1[0]) {
                            // 如果用户选择替换，则将文本域中被标示的文字用replace替换
                            fileTextAreas[textAreas_control]
                                    .replaceSelection(replace_word);
                        }
                    }
                }
            }
        }
    }
 
    /**
     * 编译compile事件
     */
    class Act_Compile implements ActionListener {
        public void actionPerformed(ActionEvent e_ji6) {
            // compile一个java源文件
            // 控制台信息
            consoleTextArea.setText(null);
            // 目前只支持编译java类
            if ((fileTabbedPane.getTitleAt(textAreas_control)).indexOf(".java") > -1) {
                try {
                    int count;
                    byte input[] = new byte[256];
                    String InputString;
                    // 编译java源文件的命令"javac"
                    String[] command = {
                            "javac",
                            directory[textAreas_control]
                                    + "/"
                                    + fileTabbedPane
                                            .getTitleAt(textAreas_control) };
                    // 当前应用程序启动一个新进程，用于执行命令
                    Process p = Runtime.getRuntime().exec(command);
                    // 读取执行命令时的错误输出
                    BufferedInputStream bufin = new BufferedInputStream(
                            p.getErrorStream());
                    // 这里仅仅读取前1024个字节
                    bufin.mark(1024);
                    count = bufin.read(input);
                    if (count <= 0) {
                        // 编译没有错误
                        consoleTextArea.append("Compile to "
                                + fileTabbedPane.getTitleAt(textAreas_control)
                                + " Success");
                    } else {
                        // 编译失败
                        InputString = new String(input, 0, count);
                        consoleTextArea.append("Compile to "
                                + fileTabbedPane.getTitleAt(textAreas_control)
                                + " Fail\n" + InputString);
                    }
                } catch (IOException e) {
                    System.err.println("IO error: " + e);
                }
            } else {
                consoleTextArea.append(fileTabbedPane
                        .getTitleAt(textAreas_control)
                        + " is not a java File !\n Please Check it again!");
            }
        }
    }
 
    /**
     * 运行build事件
     */
    class Act_Build implements ActionListener {
        public void actionPerformed(ActionEvent e_ji7) {
            // build一个Java类
            consoleTextArea.setText(null);
            if ((fileTabbedPane.getTitleAt(textAreas_control)).indexOf(".java") > -1) {
                try {
                    int count;
                    byte input[] = new byte[256];
                    String InputString;
                    // 获取java类的名字，去掉java源文件名的后五个字母".java"
                    String class_name;
                    int length = (fileTabbedPane.getTitleAt(textAreas_control))
                            .length();
                    class_name = (fileTabbedPane.getTitleAt(textAreas_control))
                            .substring(0, length - 5);
                    // 运行java类的命令"java"
                    String[] command = { "java", "-classpath",
                            directory[textAreas_control], class_name };
                    Process p = Runtime.getRuntime().exec(command);
                    BufferedInputStream bufin = new BufferedInputStream(
                            p.getErrorStream());
                    bufin.mark(256);
                    count = bufin.read(input);
                    if (count <= 0) {
                        // 运行没有错误
                        consoleTextArea.append("Build to "
                                + fileTabbedPane.getTitleAt(textAreas_control)
                                + " Success");
                    } else {
                        // 运行有错误
                        InputString = new String(input, 0, count);
                        consoleTextArea.append("Builld to "
                                + fileTabbedPane.getTitleAt(textAreas_control)
                                + " Fail\n" + InputString);
                    }
                } catch (IOException e) {
                    System.err.println("IO error: " + e);
                } catch (IndexOutOfBoundsException e2) {
                    System.err.println("IO error: " + e2);
                }
            } else {
                consoleTextArea.append(fileTabbedPane
                        .getTitleAt(textAreas_control)
                        + " is not a java File !\n Please Check it again!");
            }
        }
    }
 
    /**
     * 显示帮助Help事件
     */
    class Act_Help implements ActionListener {
        public void actionPerformed(ActionEvent e_ji9) {
            helpFrame.pack();
            helpFrame.setVisible(true);
            helpFrame.requestFocus();
            helpFrame.setLocation(200, 0);
        }
    }
 
    class Act_Copy implements ActionListener {
        public void actionPerformed(ActionEvent e_ji9) {
            // 复制事件，直接调用JTextArea的copy方法
            fileTextAreas[textAreas_control].copy();
        }
    }
 
    class Act_Cut implements ActionListener {
        public void actionPerformed(ActionEvent e_ji10) {
            // 剪贴事件，直接调用JTextArea的cut方法
            fileTextAreas[textAreas_control].cut();
        }
    }
 
    class Act_Paste implements ActionListener {
        public void actionPerformed(ActionEvent e_ji11) {
            // 粘贴事件，直接调用JTextArea的paste方法
            fileTextAreas[textAreas_control].paste();
        }
    }
 
    /**
     * 动画显示事件
     */
    class Act_timer implements ActionListener {
        public void actionPerformed(ActionEvent e_time) {
            // Flash显示，一共就4个图片文件，按顺序显示
            if (timerControl > 4) {
                timerControl = 0;
            }
            flashLabel.setIcon(new ImageIcon(loadImage("image/Juggler"
                    + timerControl + ".gif")));
            timerControl++;
        }
    }
 
    /**
     * 停止动画事件
     */
    class Act_StopFlash implements ActionListener {
        public void actionPerformed(ActionEvent E_stop) {
            // Flash控制。停止动画
            timer.stop();
            startFlashMenuItem.setEnabled(true);
            stopFlashMenuItem.setEnabled(false);
        }
    }
 
    /**
     * 启动动画事件
     */
    class Act_StartFlash implements ActionListener {
        public void actionPerformed(ActionEvent E_start) {
            // Flash控制。启动动画
            timer.start();
            startFlashMenuItem.setEnabled(false);
            stopFlashMenuItem.setEnabled(true);
        }
    }
 
    /**
     * 从jar包中读取图片文件
     *
     * @param name
     * @return 返回一个图片对象
     */
    private java.awt.Image loadImage(String name) {
        try {
            java.net.URL url = getClass().getResource(name);
            // 根据URL中内容新建一个图片文件
            return createImage((java.awt.image.ImageProducer) url.getContent());
        } catch (Exception ex) {
            return null;
        }
    }
 
    public static void main(String args[]) {
        new SimpleEditor();
    }
}

[代码运行效果截图]


文本编辑器（能编辑html、java、cpp、txt文件，java编译与运行）


网友评论    (发表评论)


发表评论：

评论须知：

  • 1、评论每次加2分，每天上限为30；
  • 2、请文明用语，共同创建干净的技术交流环境；
  • 3、若被发现提交非法信息，评论将会被删除，并且给予扣分处理，严重者给予封号处理；
  • 4、请勿发布广告信息或其他无关评论，否则将会删除评论并扣分，严重者给予封号处理。


扫码下载

加载中，请稍后...

输入口令后可复制整站源码

加载中，请稍后...