textfileeditor.java

∥显示数据文件未压缩大小及压缩大小单行文本显示域存储随机生成的数据

package org.jr.jzj.editor;
/**
 * <p>Copyright: Copyright (c) 2002-2003</p>
 * <p>Company: JavaResearch(http://www.javaresearch.org)</p>
 * <p>最后更新日期:2003年3月20日
 * @author Barney,Cherami,Brain
 * @version 0.8
 */

import java.io.*;
import java.util.*;

import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.text.html.*;
import javax.swing.text.rtf.*;
import javax.swing.undo.*;

import org.jr.jzj.*;

/**
 * java文件加亮的查看器，默认是java文件类型，支持显示行号，undo等
 * 支持以XML格式的语法加亮设置文件
 */

public class TextFileEditor
    extends JPanel
    implements UndoableEditListener, DocumentListener, CaretListener {
  private static int UNDODEPTH = 100;
  private static JZJLogger logger = new JZJLogger(TextFileEditor.class);
  private JTextPane editor;
  private Object highlight = null;
  private boolean dirty;
  private File file;
  private UndoManager undo;
  private String searchString = "";
  private String replaceString = "";
  private boolean ignoreCase = false;
  private LineNumber lineNumber;
  private JScrollPane scrollPane;

  //
  private HashMap typeHandlers;
  private File syntaxFile = null;
  private SyntaxParser parser = null;

  /**
   * 默认构造函数
   */
  public TextFileEditor() {
    super(new BorderLayout(), true);
    setLayout(new BorderLayout());
    editor = new JTextPane();
    editor.addCaretListener(this);
    scrollPane = new JScrollPane(editor);

    add(scrollPane, BorderLayout.CENTER);
    undo = new UndoManager();
    undo.setLimit(this.UNDODEPTH);

    editor.getDocument().addUndoableEditListener(this);
    editor.getDocument().addDocumentListener(this);

    setLineNumberVisible(false);

  }

  /**
   * 直接打开一个文件的：构造函数
   * @param f
   */
  public TextFileEditor(File f) {
    this();
    doOpen(f);
  }

  /**
   * 导入语法加亮，属性文件改过之后也可用这个函数更新
   * @param syntaxFile
   */
  public void loadSyntax(File syntaxFile) {
    this.syntaxFile = syntaxFile;
    if (syntaxFile != null) {
      parser = new SyntaxParser(syntaxFile);
      if (typeHandlers == null) {
        typeHandlers = new HashMap();
      }
      typeHandlers.clear();
    }
  }

  /**
   * 是否显示行号
   * @param bVisibale
   */
  public void setLineNumberVisible(boolean bVisible) {
    if (lineNumber == null) {
      lineNumber = new LineNumber(editor);
      scrollPane.setRowHeaderView(lineNumber);
    }

    scrollPane.getRowHeader().setVisible(bVisible);

  }

  public boolean isLineNumberVisible() {
    return scrollPane.getRowHeader().isVisible();
  }

  /**
   *
   * @param type
   * @return
   */
  private EditorKit getEditorKitForContentType(String type) {
    if (typeHandlers == null) {
      typeHandlers = new HashMap();
    }

    EditorKit k = (EditorKit) typeHandlers.get(type);
    if (k == null) {
      k = createEditorKitForContentType(type);
      if (k != null) {
        typeHandlers.put(type, k);
        editor.setEditorKitForContentType(type, k);
      }
    }
    editor.setContentType(type);
    return k;

  }

  /**
   *
   * @param type
   * @return
   */
  protected EditorKit createEditorKitForContentType(String type) {
    if (parser != null) {
      return createEditorKitForContentTypeX(type);
    }

    if (type.equals("text/java")) {
      return (new SyntaxEditorKit());
    }
    else if (type.equals("text/plain")) {
      return (new StyledEditorKit());
    }
    else if (type.equals("text/html")) {
      return (new HTMLEditorKit());
    }
    else if (type.equals("text/rtf")) {
      return (new RTFEditorKit());
    }
    else if (type.equals("text/cpp")) {
      return (new SyntaxEditorKit());
    }
    else if (type.equals("text/unknown")) {
      return (new StyledEditorKit());
    }
    else {
      return editor.getEditorKitForContentType(type);
    }
  }

  /**
   *
   * @param type
   * @return
   */
  protected EditorKit createEditorKitForContentTypeX(String type) {

    if (type.equals("text/plain")) {
      return (new StyledEditorKit());
    }
    else if (type.equals("text/html")) {
      return (new HTMLEditorKit());
    }
    else if (type.equals("text/rtf")) {
      return (new RTFEditorKit());
    }
    else {
      EditorKit et = SyntaxEditorKit.newInstance(type, parser);
      if (et != null) {
        return et;
      }
      else {
        return editor.getEditorKitForContentType(type);
      }

    }
  }

  protected void selectEditorKit(String filename) {
    if (filename.endsWith(".java")) {
      getEditorKitForContentType("text/java");
    }
    else if (filename.endsWith(".cpp") || filename.endsWith(".c")
             || filename.endsWith(".hpp") || filename.endsWith(".h")) {
      getEditorKitForContentType("text/cpp");

    }
    else if (filename.endsWith(".html") || filename.endsWith(".htm")) {
      getEditorKitForContentType("text/html");
    }
    else if (filename.endsWith(".rtf")) {
      getEditorKitForContentType("text/rtf");
    }
    else {
      getEditorKitForContentType("text/unknown");
    }
  }

  /**
   *
   * @param f
   */
  public void doOpen(File f) {
    file = f;
    if (f.getName().endsWith(".html") || f.getName().endsWith(".htm")) {
      try {
        editor.setPage(org.jr.io.FileUtil.getURL(f));
        return;
      }
      catch (Exception ex) {
        ex.printStackTrace();
      }

    }

    selectEditorKit(f.getName());
    doOpen();
  }

  private void doOpen() {
    try {
      FileReader reader = new FileReader(file);
      editor.read(reader, file.getAbsolutePath());
      reader.close();
      dirty = false;
    }
    catch (IOException ex) {
      ex.printStackTrace();
      logger.error(ex.toString());
    }
  }

  public void doSave() {
    if (file == null) {
      return;
    }

    /**
     * 保存
     */
    try {
      FileWriter writer = new FileWriter(file);
      editor.write(writer);
      writer.close();
      dirty = false;
    }
    catch (IOException ex) {
      logger.error(ex.toString());
    }
  }

  public File getFile() {
    return file;
  }

  public final JTextPane getEditor() {
    return editor;
  }

  public void removeUpdate(DocumentEvent ev) {
    dirty = true;
  }

  public void changedUpdate(DocumentEvent ev) {
  }

  public void insertUpdate(DocumentEvent ev) {
    dirty = true;
  }

  public boolean getDirty() {
    return dirty;
  }

  public void doUndo() {
    if (undo.canUndo()) {
      undo.undo();
    }
  }

  public void doRedo() {
    if (undo.canRedo()) {
      undo.redo();
    }
  }

  public void caretUpdate(CaretEvent ev) {
    Highlighter highlighter = editor.getHighlighter();
    if (highlight != null) {
      highlighter.removeHighlight(highlight);
    }
    try {
      int offset = findMatchingBracket(editor.getDocument(), ev.getDot() - 1);
      if (offset != -1) {
        highlight = highlighter.addHighlight(offset, offset + 1,
                                             new DefaultHighlighter.
                                             DefaultHighlightPainter(Color.cyan));
      }
    }
    catch (BadLocationException ex) {
    }
  }

  public void undoableEditHappened(UndoableEditEvent ev) {
    undo.addEdit(ev.getEdit());
  }

  public String getSearchString() {
    return searchString;
  }

  public void setSearchString(String s) {
    searchString = s;
  }

  public String getReplaceString() {
    return replaceString;
  }

  public void setReplaceString(String s) {
    replaceString = s;
  }

  public boolean getIgnoreCase() {
    return ignoreCase;
  }

  public void setIgnoreCase(boolean b) {
    ignoreCase = b;
  }

  public void doSearch(String search, boolean ignore) {
    if (search.length() > 0) {
      setSearchString(search);
      setIgnoreCase(ignore);
      int length = editor.getDocument().getLength();
      int position = editor.getCaretPosition();
      try {
        String contents = editor.getText(0, length);
        if (ignoreCase) {
          contents = contents.toLowerCase();
        }
        int found = contents.indexOf(search, position);
        if (found != -1) {
          editor.setCaretPosition(found);
          editor.setSelectionStart(found);
          editor.setSelectionEnd(found + search.length());
        }
        else {
          Toolkit.getDefaultToolkit().beep();
        }
      }
      catch (BadLocationException ex) {
      }

    }

  }

  public void doReplace(String replace) {
    if (replace.length() > 0) {
      setReplaceString(replace);
      int start = editor.getSelectionStart();
      int end = editor.getSelectionEnd();
      if ( (start == 0 && end == 0) || (searchString.length() == 0) ||
          (replaceString.length() == 0)) {
        getToolkit().beep();
      }
      else {
        try {
          editor.getDocument().remove(start, end - start);
          editor.getDocument().insertString(start, replaceString, null);
        }
        catch (BadLocationException ex) {
//					MessageFrame.setErrorText(ex.toString());
        }
      }
    }
  }

  public int findMatchingBracket(Document doc, int offset) throws
      BadLocationException {
    int toReturn = -1;
    if (doc.getLength() == 0) {
      return toReturn;
    }
    char c = doc.getText(offset, 1).charAt(0);
    switch (c) {
      case '(':
        toReturn = searchForward(c, ')', offset);
        break;
      case '[':
        toReturn = searchForward(c, ']', offset);
        break;
      case '{':
        toReturn = searchForward(c, '}', offset);
        break;
      case ')':
        toReturn = searchBackward(c, '(', offset);
        break;
      case ']':
        toReturn = searchBackward(c, '[', offset);
        break;
      case '}':
        toReturn = searchBackward(c, '{', offset);
        break;
    }
    return toReturn;
  }

  private int searchForward(char c, char d, int offset) throws
      BadLocationException {
    int count = 1;
    offset++;
    int len = editor.getDocument().getLength() - offset;
    String text = editor.getDocument().getText(offset, len);
    for (int i = 0; i < len; i++) {
      char x = text.charAt(i);
      if (x == c) {
        count++;
      }
      else if (x == d) {
        if (--count == 0) {
          return i + offset;
        }
      }
    }
    return -1;
  }

  private int searchBackward(char c, char d, int offset) throws
      BadLocationException {
    int count = 1;
    String text = editor.getDocument().getText(0, offset);
    for (int i = offset - 1; i >= 0; i--) {
      char x = text.charAt(i);
      if (x == c) {
        count++;
      }
      else if (x == d) {
        if (--count == 0) {
          return i;
        }
      }
    }
    return -1;
  }
}