StyledText实现的简单Java类文件编辑器

        因为所处行业缘故，实施拷贝的虚拟机中都是只有环境，没有源码，包括Java的和TC的，所有的东西都没有源码，只能自己装反编译插件查看源码，但我不知道为啥，这个反编译插件反编译出来的代码前面都有空注释，中间穿插大量的空白行，最后还有反编译信息。反编译信息倒无所谓，只是代码开头的空注释和中间的空白行很让人眼花，很讨厌。某天心血来潮，自己写一个编辑器，处理一下这些代码。于是开动了。

        其实这个东西写完后自己发现，基本毫无用处，真正开发过程中看源代码时需要了解各个方法相互怎么调用的，还会通过代码大纲总体预览这个类什么的。而自己实现的这个编辑器，除了看起来稍微好看一点，基本没啥用处。不过没关系，就当学习练手了吧。

       一开始就是想直接用SWT的Text行了，后来想起StyleText，看名字感觉更高端一些，应该能实现很多炫酷的功能，就决定用StyleText了，然后深入研究发现，这两个玩意根本不是一回事。先看下继承关系。

                                                 

       

　　是的，Text是Scrollable的直接子类，而StyledText是Canvas的直接子类，这意味着什么，整个StyledText就是用Canvas画出来的，感觉也是很牛逼啊。想想也是，不然Eclipse中的代码着色等等高级功能如何实现？单靠Text是无法完成的，功能太单一了。

       用上StyledText先实现我最基本的功能吧，就是简单的找到字符串中的前8列字符，中间的空白字符，和最后7行代码。把他们清除掉。实现完成后在网上搜索StyledText，发现还可以实现更多有意思的功能，内容助理，代码着色等，参考别人博客的代码和自己看源码，慢慢实现出了这几个功能，下面贴出效果图。

A.  这是从反编译器中粘贴过来的代码，很乱。

B. 经过解析后，去除了注释和空白行，并对关键字进行着色。

C.再次输入代码时，对相关内容会弹出内容助理的窗口

 D.如果输入的单词是关键字，会进行着色。

            好了，运行效果就是这样，下面贴出代码，相关的东西都已经在代码里详细注释了。

主类：

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.contentassist.ContentAssistant;
import org.eclipse.jface.text.contentassist.IContentAssistant;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.jface.text.source.SourceViewerConfiguration;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.custom.VerifyKeyListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.VerifyEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.wb.swt.SWTResourceManager;

import swing2swt.layout.BorderLayout;

public class ClassEditor {

    protected Shell shell;
    private SourceViewer sourceViewer;
    private List<String> keywords = new ArrayList<String>();
    private StyledText styledText;
    //匹配Java关键字的正则表达式
    public static final String REG= "\b(abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|extends|false|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|native|new|null|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|true|transient|try|void|volatile|while)\b";
    
    public static void main(String[] args) {
        try {
            ClassEditor window = new ClassEditor();
            window.open();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Open the window.
     */
    public void open() {
        Display display = Display.getDefault();
        createContents();
        shell.open();
        shell.layout();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
    }

    /**
     * Create contents of the window.
     */
    protected void createContents() {
        shell = new Shell();
        shell.setSize(612, 468);
        shell.setText("类文件编辑器");
        shell.setLayout(new BorderLayout(0, 0));
        
        sourceViewer = new SourceViewer(shell, null, SWT.V_SCROLL);
        //此处的Document非必备参数，但是当需要实现内容助手等复杂功能时，必须添加此参数，否则会一直报空指针异常
        //本人就是一直报异常，查看源码才找出这个问题的。内容助手底层代码使用到了这个Document对象。
        sourceViewer.setDocument(new Document());
        styledText = sourceViewer.getTextWidget();
        styledText.setText("/*     */ package org.eclipse.jface.dialogs;
/*     */ 
/*     */ import org.eclipse.swt.custom.StackLayout;
/*     */ import org.eclipse.swt.widgets.Composite;
/*     */ import org.eclipse.swt.widgets.ProgressBar;
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ public class ProgressIndicator
/*     */   extends Composite
/*     */ {
/*     */   private static final int PROGRESS_MAX = 1000;
/*  30 */   private boolean animated = true;
/*     */   
/*     */ 
/*     */   private StackLayout layout;
/*     */   
/*     */ 
/*     */   private ProgressBar determinateProgressBar;
/*     */   
/*     */ 
/*     */   private ProgressBar indeterminateProgressBar;
/*     */   
/*     */ 
/*     */   private double totalWork;
/*     */   
/*     */   private double sumWorked;
/*     */   
/*     */ 
/*     */   public ProgressIndicator(Composite parent)
/*     */   {
/*  49 */     this(parent, 0);
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   public ProgressIndicator(Composite parent, int style)
/*     */   {
/*  62 */     super(parent, 0);
/*     */     
/*     */ 
/*  65 */     if ((style & 0x200) == 0) {
/*  66 */       style |= 0x100;
/*     */     }
/*  68 */     this.determinateProgressBar = new ProgressBar(this, style);
/*  69 */     this.indeterminateProgressBar = new ProgressBar(this, style | 
/*  70 */       0x2);
/*  71 */     this.layout = new StackLayout();
/*  72 */     setLayout(this.layout);
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */   public void beginAnimatedTask()
/*     */   {
/*  79 */     done();
/*  80 */     this.layout.topControl = this.indeterminateProgressBar;
/*  81 */     layout();
/*  82 */     this.animated = true;
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   public void beginTask(int max)
/*     */   {
/*  92 */     done();
/*  93 */     this.totalWork = max;
/*  94 */     this.sumWorked = 0.0D;
/*  95 */     this.determinateProgressBar.setMinimum(0);
/*  96 */     this.determinateProgressBar.setMaximum(1000);
/*  97 */     this.determinateProgressBar.setSelection(0);
/*  98 */     this.layout.topControl = this.determinateProgressBar;
/*  99 */     layout();
/* 100 */     this.animated = false;
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */   public void done()
/*     */   {
/* 107 */     if (!this.animated) {
/* 108 */       this.determinateProgressBar.setMinimum(0);
/* 109 */       this.determinateProgressBar.setMaximum(0);
/* 110 */       this.determinateProgressBar.setSelection(0);
/*     */     }
/* 112 */     this.layout.topControl = null;
/* 113 */     layout();
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */   public void sendRemainingWork()
/*     */   {
/* 120 */     worked(this.totalWork - this.sumWorked);
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */   public void worked(double work)
/*     */   {
/* 128 */     if ((work == 0.0D) || (this.animated)) {
/* 129 */       return;
/*     */     }
/* 131 */     this.sumWorked += work;
/* 132 */     if (this.sumWorked > this.totalWork) {
/* 133 */       this.sumWorked = this.totalWork;
/*     */     }
/* 135 */     if (this.sumWorked < 0.0D) {
/* 136 */       this.sumWorked = 0.0D;
/*     */     }
/* 138 */     int value = (int)(this.sumWorked / this.totalWork * 1000.0D);
/* 139 */     if (this.determinateProgressBar.getSelection() < value) {
/* 140 */       this.determinateProgressBar.setSelection(value);
/*     */     }
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */   public void showError()
/*     */   {
/* 149 */     this.determinateProgressBar.setState(1);
/* 150 */     this.indeterminateProgressBar.setState(1);
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */   public void showPaused()
/*     */   {
/* 158 */     this.determinateProgressBar.setState(4);
/* 159 */     this.indeterminateProgressBar.setState(4);
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */   public void showNormal()
/*     */   {
/* 167 */     this.determinateProgressBar.setState(0);
/* 168 */     this.indeterminateProgressBar.setState(0);
/*     */   }
/*     */ }

/* Location:           D:\Siemens\Teamcenter8\portal\plugins\org.eclipse.jface_3.5.0.I20090525-2000.jar
 * Qualified Name:     org.eclipse.jface.dialogs.ProgressIndicator
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.0.1
 */");
        styledText.setFont(SWTResourceManager.getFont("微软雅黑", 12, SWT.NORMAL));
        styledText.setAlwaysShowScrollBars(false);
        styledText.setSelectionBackground(SWTResourceManager.getColor(SWT.COLOR_BLACK));
        styledText.setBackground(SWTResourceManager.getColor(199, 237, 204));
        /**
         * 1.文本修改监听，只有当文本框内的内容被修改时执行的操作，添加或删除文字时会执行的操作
         *   其余的比如按下Shift键等操作不会被监听到，此监听应该和下面的那个键盘监听区分开来
         * 2.这个监听中实现了输入Java关键字后自动着色功能
         * 3.实现思路
         *   a,从SourceViewer对象中获取ITextSelection对象（所有Viewer中基本都有此对象）
         *   b,获取当前光标所处的位置，然后根据此位置获取当前输入的单词的起始位置
         *   c,计算当前输入的单词的长度并判断此单词是否是Java关键字，是就进行着色。
         */
        styledText.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent e) {
                ITextSelection selection = (ITextSelection) sourceViewer.getSelectionProvider().getSelection();
                int offset = selection.getOffset();
                String key = MyContentAssist.extractPrefix(sourceViewer,offset);
                int p = offset-key.length();
                if(key.length()>0&&keywords.contains(key)) {
                    styledText.setStyleRange(new StyleRange(p, key.length(), SWTResourceManager.getColor(SWT.COLOR_DARK_MAGENTA), null));
                }else {
                    styledText.setStyleRange(new StyleRange(p, key.length(), null, null));
                }
            }
        });
        
        
        Composite composite = new Composite(shell, SWT.NONE);
        composite.setLayoutData(BorderLayout.SOUTH);
        composite.setLayout(new FillLayout(SWT.HORIZONTAL));
        
        Button btnParse = new Button(composite, SWT.NONE);
        btnParse.setText("解析");
        btnParse.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                /**
                 * 功能：删除所有的注释和空白行
                 * 思路：用换行符将整个文本分成数组，然后将每一行的前8个去掉，并将最后7行删除，最后拼接起来
                 * 缺点：太死板
                 */
                String string = styledText.getText();
                String[] split = string.split("
");
                StringBuilder result = new StringBuilder();
                for(int i=0;i<split.length-7;i++) {
                    String s = split[i].substring(9);
                    if(s.equals(" ")) {
                        continue;
                    }else {
                        result = result.append(s).append("
");
                    }
                }
                styledText.setText(result.toString());
                btnParse.setEnabled(false);
                /**
                 * 另一种实现方式，用正则表达式匹配所有的注释，并删除
                 * 但是此方法还没删除空白行
                 */
//                Pattern pattern = Pattern.compile("/\*{1,2}[\S\s]*?\*/");
//                Matcher matcher = pattern.matcher(string);
//                styledText.setText(matcher.replaceAll(""));
                parseKey();
            }
            /**
             * 此方法主要利用正则表达式为整个文本框中的代码中的关键字和引号中的字符串着色
             */
            private void parseKey() {
                String text = sourceViewer.getTextWidget().getText();
                Pattern pattern = Pattern.compile(REG);
                Matcher matcher = pattern.matcher(text);
                while(matcher.find()) {
                    int start = matcher.start();
                    int end = matcher.end();
                    styledText.setStyleRange(new StyleRange(start, end-start, SWTResourceManager.getColor(SWT.COLOR_DARK_MAGENTA), null));
                }
                Pattern pattern2 = Pattern.compile("".*"");
                Matcher matcher2 = pattern2.matcher(text);
                while(matcher2.find()) {
                    int start = matcher2.start();
                    int end = matcher2.end();
                    styledText.setStyleRange(new StyleRange(start, end-start, SWTResourceManager.getColor(SWT.COLOR_BLUE), null));
                }
            }
        });
        
        Button btnExport = new Button(composite, SWT.NONE);
        btnExport.setText("导出");
        btnExport.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                FileDialog dialog = new FileDialog(shell,SWT.SAVE);
                dialog.setFilterExtensions(new String[] {"*.java"});
                dialog.setText("保存为...");
                String path = dialog.open();
                if(null==path) return;
                File file = new File(path);
                try {
                    if(!file.exists()) {
                        file.createNewFile();
                    }
                    FileWriter writer = new FileWriter(file);
                    writer.write(styledText.getText());
                    writer.close();
                    MessageDialog.openInformation(shell, "导出成功!", "文本已成功导出至"+path+"目录下！");
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        });
        
        Button btnExit = new Button(composite, SWT.NONE);
        btnExit.setText("关闭");
        composite.setTabList(new Control[]{btnParse, btnExport, btnExit});
        btnExit.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                shell.dispose();
            }
        });
        initData();
    }
    
    private void initData() {
        keywords.add("private");
        keywords.add("void");
        keywords.add("new");
        keywords.add("this");
        keywords.add("return");
        keywords.add("class");
        keywords.add("if");
        
        /**
         * 配置内容助理
         */
        sourceViewer.configure(new SourceViewerConfiguration() {
            @Override
               public IContentAssistant getContentAssistant(ISourceViewer sourceViewer) {
                ContentAssistant contentAssistant = new ContentAssistant();
                contentAssistant.setInformationControlCreator(getInformationControlCreator(sourceViewer));
                contentAssistant.enableAutoActivation(true);
                contentAssistant.setContentAssistProcessor(new MyContentAssist(), IDocument.DEFAULT_CONTENT_TYPE);
                return contentAssistant;
            }
        });
        /**
         * 添加键盘监听，输入“Alt+/”时，打开内容助理
         */
        styledText.addVerifyKeyListener(new VerifyKeyListener() {
            public void verifyKey(VerifyEvent event) {
                if(event.stateMask == SWT.ALT && event.character =='/') {
                    if(sourceViewer.canDoOperation(SourceViewer.CONTENTASSIST_PROPOSALS)) {
                        sourceViewer.doOperation(SourceViewer.CONTENTASSIST_PROPOSALS);
                        event.doit = false;
                    }
                }
            }
        });
    }
}

内容助理类：

import java.util.ArrayList;
import java.util.List;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.contentassist.CompletionProposal;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.jface.text.contentassist.IContextInformationValidator;


public class MyContentAssist implements IContentAssistProcessor {

    @Override
    public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {
        String[] keywords = new String[] {"continue","public","return","reta"};
        ITextSelection selection= (ITextSelection) viewer.getSelectionProvider().getSelection();
        if (selection.getOffset() == offset) {
            offset= selection.getOffset() + selection.getLength();
        }
        
        String text= extractPrefix(viewer, offset);
        List<String> list = new ArrayList<String>();
        for(String s:keywords) {
            if(text.length()<s.length()&&s.substring(0, text.length()).equalsIgnoreCase(text)) {
                list.add(s);
            }
        }
        if(list.size()>0) {
            CompletionProposal[] resu = new CompletionProposal[list.size()];
            for(int i=0;i<list.size();i++) {
                resu[i] = new CompletionProposal(list.get(i), offset-text.length(), text.length(), list.get(i).length());
            }
            return resu;
        }else {
            return new CompletionProposal[0];
        }
    }
    
    /**
     * 此方法是从源码中提取出来的，主要是提取当前光标所处位置到前面非Java字符的字符串
     * @param viewer
     * @param offset
     * @return
     */
    public static String extractPrefix(ITextViewer viewer, int offset) {
        int i= offset;
        IDocument document= viewer.getDocument();
        if (i > document.getLength())
            return ""; 

        try {
            while (i > 0) {
                char ch= document.getChar(i - 1);
                if (!Character.isJavaIdentifierPart(ch))
                    break;
                i--;
            }

            return document.get(i, offset - i);
        } catch (BadLocationException e) {
            return ""; 
        }
    }
    @Override
    public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) {
        return null;
    }

    @Override
    public char[] getCompletionProposalAutoActivationCharacters() {
        return null;
    }

    @Override
    public char[] getContextInformationAutoActivationCharacters() {
        return null;
    }

    @Override
    public String getErrorMessage() {
        return null;
    }

    @Override
    public IContextInformationValidator getContextInformationValidator() {
        return null;
    }

}

          要运行的话直接把这两个类放到一个包里运行主类就可以了。