JTextPane: Anpassbares Java Syntax Highlighting @ tutorials.de: Tutorials, Forum & Hilfe

***zeja*** · 27.04.08 23:51

Ich habe mal das Syntax Highlighting Beispiel von http://java.sys-con.com/read/36509.htm ein wenig erweitert.

Farben lassen sich einstellen, keywords theoretisch auch, ist aber sehr auf Java-fokussiert momentan.

Code java:

package de.tutorials;
 
import java.awt.Color;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.DefaultStyledDocument;
import javax.swing.text.Element;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
 
public class CodeDocument extends DefaultStyledDocument {
    private String word = "";
    private SimpleAttributeSet bold = new SimpleAttributeSet();
    private SimpleAttributeSet string = new SimpleAttributeSet();
    private SimpleAttributeSet normal = new SimpleAttributeSet();
    private SimpleAttributeSet number = new SimpleAttributeSet();
    private SimpleAttributeSet comments = new SimpleAttributeSet();
    private SimpleAttributeSet javadoc = new SimpleAttributeSet();
    private SimpleAttributeSet annotation = new SimpleAttributeSet();
    private int currentPos = 0;
    private Map<String, SimpleAttributeSet> keywordSets = new HashMap<String, SimpleAttributeSet>();
    public static int STRING_MODE = 10;
    public static int TEXT_MODE = 11;
    public static int NUMBER_MODE = 12;
    public static int COMMENT_MODE = 13;
    public static int LINE_COMMENT_MODE = 14;
    public static int JAVADOC_MODE = 15;
    public static int ANNOTATION_MODE = 16;
 
    private int mode = TEXT_MODE;
 
    public CodeDocument() {
        // set the bold attribute
        StyleConstants.setBold(bold, true);
        StyleConstants.setForeground(string, Color.blue);
        StyleConstants.setForeground(number, Color.red);
        StyleConstants.setForeground(comments, Color.green);
        StyleConstants.setItalic(comments, true);
        StyleConstants.setForeground(javadoc, Color.cyan);
        StyleConstants.setItalic(javadoc, true);
        StyleConstants.setForeground(annotation, Color.GRAY);
        StyleConstants.setBold(annotation, true);
    }
 
    public void setCommentColor(Color color) {
        StyleConstants.setForeground(comments, color);
    }
 
    public void setJavadocColor(Color color) {
        StyleConstants.setForeground(javadoc, color);
    }
 
    public void setAnnotationColor(Color color) {
        StyleConstants.setForeground(annotation, color);
    }
 
    private void insertKeyword(String str, int pos, SimpleAttributeSet as) {
        try {
            // remove the old word and formatting
            this.remove(pos - str.length(), str.length());
            /*
             * replace it with the same word, but new formatting we MUST call
             * the super class insertString method here, otherwise we would end
             * up in an infinite loop !!
             */
            super.insertString(pos - str.length(), str, as);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    private void insertTextString(String str, int pos) {
        try {
            // remove the old word and formatting
            this.remove(pos, str.length());
            super.insertString(pos, str, string);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    private void insertNumberString(String str, int pos) {
        try {
            // remove the old word and formatting
            this.remove(pos, str.length());
            super.insertString(pos, str, number);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    private void insertCommentString(String str, int pos) {
        try {
            // remove the old word and formatting
            this.remove(pos, str.length());
            super.insertString(pos, str, comments);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    private void insertJavadocString(String str, int pos) {
        try {
            // remove the old word and formatting
            this.remove(pos, str.length());
            super.insertString(pos, str, javadoc);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    private void insertAnnotationString(String str, int pos) {
        try {
            // remove the old word and formatting
            this.remove(pos, str.length());
            super.insertString(pos, str, annotation);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    private void checkForString() {
        int offs = this.currentPos;
        Element element = this.getParagraphElement(offs);
        String elementText = "";
        try {
            // this gets our chuck of current text for the element we're on
            elementText = this.getText(element.getStartOffset(), element
                    .getEndOffset()
                    - element.getStartOffset());
        } catch (Exception ex) {
            // whoops!
            System.out.println("no text");
        }
        int strLen = elementText.length();
        if (strLen == 0) {
            return;
        }
        int i = 0;
 
        if (element.getStartOffset() > 0) {
            // translates backward if neccessary
            offs = offs - element.getStartOffset();
        }
        int quoteCount = 0;
        if ((offs >= 0) && (offs <= strLen - 1)) {
            i = offs;
            while (i > 0) {
                // the while loop walks back until we hit a delimiter
 
                char charAt = elementText.charAt(i);
                if ((charAt == '"')) {
                    quoteCount++;
                }
                i--;
            }
            int rem = quoteCount % 2;
            // System.out.println(rem);
            mode = (rem == 0) ? TEXT_MODE : STRING_MODE;
        }
    }
 
    private void checkForKeyword() {
        if (mode != TEXT_MODE) {
            return;
        }
        int offs = this.currentPos;
        Element element = this.getParagraphElement(offs);
        String elementText = "";
        try {
            // this gets our chuck of current text for the element we're on
            elementText = this.getText(element.getStartOffset(), element
                    .getEndOffset()
                    - element.getStartOffset());
        } catch (Exception ex) {
            // whoops!
            System.out.println("no text");
        }
        int strLen = elementText.length();
        if (strLen == 0) {
            return;
        }
        int i = 0;
 
        if (element.getStartOffset() > 0) {
            // translates backward if neccessary
            offs = offs - element.getStartOffset();
        }
        if ((offs >= 0) && (offs <= strLen - 1)) {
            i = offs;
            while (i > 0) {
                // the while loop walks back until we hit a delimiter
                i--;
                char charAt = elementText.charAt(i);
                if ((charAt == ' ') | (i == 0) | (charAt == '(')
                        | (charAt == ')') | (charAt == '{') | (charAt == '}')) { // if i
                    // == 0
                    // then
                    // we're
                    // at
                    // the
                    // begininng
                    if (i != 0) {
                        i++;
                    }
                    word = elementText.substring(i, offs);// skip the period
 
                    String s = word.trim().toLowerCase();
                    // this is what actually checks for a matching keyword
                    if (keywordSets.containsKey(s)) {
                        insertKeyword(word, currentPos, keywordSets.get(s));
                    }
                    break;
                }
            }
        }
    }
 
    private void checkForNumber() {
        int offs = this.currentPos;
        Element element = this.getParagraphElement(offs);
        String elementText = "";
        try {
            // this gets our chuck of current text for the element we're on
            elementText = this.getText(element.getStartOffset(), element
                    .getEndOffset()
                    - element.getStartOffset());
        } catch (Exception ex) {
            // whoops!
            System.out.println("no text");
        }
        int strLen = elementText.length();
        if (strLen == 0) {
            return;
        }
        int i = 0;
 
        if (element.getStartOffset() > 0) {
            // translates backward if neccessary
            offs = offs - element.getStartOffset();
        }
        mode = TEXT_MODE;
        if ((offs >= 0) && (offs <= strLen - 1)) {
            i = offs;
            while (i > 0) {
                // the while loop walks back until we hit a delimiter
                char charAt = elementText.charAt(i);
                if ((charAt == ' ') | (i == 0) | (charAt == '(')
                        | (charAt == ')') | (charAt == '{') | (charAt == '}') /* | */) { // if i
                    // == 0
                    // then
                    // we're
                    // at
                    // the
                    // begininng
                    if (i != 0) {
                        i++;
                    }
                    mode = NUMBER_MODE;
                    break;
                } else if (!(charAt >= '0' & charAt <= '9' | charAt == '.'
                        | charAt == '+' | charAt == '-' | charAt == '/'
                        | charAt == '*' | charAt == '%' | charAt == '=')) {
                    mode = TEXT_MODE;
                    break;
                }
                i--;
            }
        }
    }
 
    private void checkForComment() {
        int offs = this.currentPos;
        Element element = this.getParagraphElement(offs);
        String elementText = "";
        try {
            // this gets our chuck of current text for the element we're on
            elementText = this.getText(element.getStartOffset(), element
                    .getEndOffset()
                    - element.getStartOffset());
        } catch (Exception ex) {
            // whoops!
            System.out.println("no text");
        }
        int strLen = elementText.length();
        if (strLen == 0) {
            return;
        }
        int i = 0;
 
        if (element.getStartOffset() > 0) {
            // translates backward if neccessary
            offs = offs - element.getStartOffset();
        }
        if ((offs >= 1) && (offs <= strLen - 1)) {
            i = offs;
            char commentStartChar1 = elementText.charAt(i - 1);
            char commentStartChar2 = elementText.charAt(i);
            if (mode == COMMENT_MODE && commentStartChar1 == '*'
                    && commentStartChar2 == '*') {
                mode = JAVADOC_MODE;
                this.insertJavadocString("/**", currentPos - 2);
            } else if (commentStartChar1 == '/' && commentStartChar2 == '*') {
                mode = COMMENT_MODE;
                this.insertCommentString("/*", currentPos - 1);
            } else if (commentStartChar1 == '/' && commentStartChar2 == '/') {
                mode = LINE_COMMENT_MODE;
                this.insertCommentString("//", currentPos - 1);
            } else if (commentStartChar1 == '*' && commentStartChar2 == '/') {
                boolean javadoc = false;
                if (mode == JAVADOC_MODE) {
                    javadoc = true;
                }
                mode = TEXT_MODE;
                if (javadoc) {
                    this.insertJavadocString("*/", currentPos - 1);
                } else {
                    this.insertCommentString("*/", currentPos - 1);
                }
            }
 
        }
    }
 
    private void processChar(String str) {
        char strChar = str.charAt(0);
        if (mode != COMMENT_MODE && mode != LINE_COMMENT_MODE
                && mode != JAVADOC_MODE && mode != ANNOTATION_MODE) {
            mode = TEXT_MODE;
        }
        switch (strChar) {
        case ('@'):
            if (mode == TEXT_MODE) {
                mode = ANNOTATION_MODE;
            }
            break;
        case ('{'):
        case ('}'):
        case (' '):
        case ('\n'):
        case ('('):
        case (')'):
        case (';'):
        case ('.'): {
            checkForKeyword();
            if (mode == ANNOTATION_MODE && strChar == '(') {
                mode = TEXT_MODE;
            }
            if ((mode == STRING_MODE || mode == LINE_COMMENT_MODE || mode == ANNOTATION_MODE)
                    && strChar == '\n') {
                mode = TEXT_MODE;
            }
        }
            break;
        case ('"'): {
            insertTextString(str, currentPos);
            this.checkForString();
        }
            break;
        case ('0'):
        case ('1'):
        case ('2'):
        case ('3'):
        case ('4'):
        case ('5'):
        case ('6'):
        case ('7'):
        case ('8'):
        case ('9'): {
            checkForNumber();
        }
            break;
        case ('*'):
        case ('/'): {
            checkForComment();
        }
            break;
        }
        if (mode == TEXT_MODE) {
            this.checkForString();
        }
        if (mode == STRING_MODE) {
            insertTextString(str, this.currentPos);
        } else if (mode == NUMBER_MODE) {
            insertNumberString(str, this.currentPos);
        } else if (mode == COMMENT_MODE) {
            insertCommentString(str, this.currentPos);
        } else if (mode == LINE_COMMENT_MODE) {
            insertCommentString(str, this.currentPos);
        } else if (mode == JAVADOC_MODE) {
            insertJavadocString(str, this.currentPos);
        } else if (mode == ANNOTATION_MODE) {
            insertAnnotationString(str, this.currentPos);
        }
 
    }
 
    private void processChar(char strChar) {
        char[] chrstr = new char[1];
        chrstr[0] = strChar;
        String str = new String(chrstr);
        processChar(str);
    }
 
    public void insertString(int offs, String str, AttributeSet a)
            throws BadLocationException {
        super.insertString(offs, str, normal);
 
        int strLen = str.length();
        int endpos = offs + strLen;
        int strpos;
        for (int i = offs; i < endpos; i++) {
            currentPos = i;
            strpos = i - offs;
            processChar(str.charAt(strpos));
        }
        currentPos = offs;
    }
 
    public Set<String> getKeywords() {
        return this.keywordSets.keySet();
    }
 
    public void setKeywords(Map<String, Color> aKeywordList) {
        if (aKeywordList != null) {
            for (Map.Entry<String, Color> entry : aKeywordList.entrySet()) {
                SimpleAttributeSet temp = new SimpleAttributeSet();
                StyleConstants.setForeground(temp, entry.getValue());
                StyleConstants.setBold(temp, true);
                this.keywordSets.put(entry.getKey(), temp);
            }
            // this.keywords = aKeywordList;
        }
    }
}

Code java:

package de.tutorials;
import java.awt.Color;
import java.util.HashMap;
import java.util.Map;
 
import javax.swing.JFrame;
import javax.swing.JTextPane;
import javax.swing.WindowConstants;
 
public class Test{
 
  public static void main(String[] args) {
    JFrame frame = new JFrame();
    JTextPane editor = new JTextPane();
    CodeDocument doc = new CodeDocument();
    Map<String,Color> keywords = new HashMap<String,Color>();
    
    
    Color comment = new Color(63,197,95);
    Color javadoc = new Color(63,95,191);
    Color annotation = new Color(100,100,100);
    doc.setCommentColor(comment);
    doc.setJavadocColor(javadoc);
    doc.setAnnotationColor(annotation);
    
    Color defColor = new Color(127,0,85);
    keywords.put("abstract",defColor);
    keywords.put("boolean",defColor);
    keywords.put("break",defColor);
    keywords.put("byte",defColor);
    keywords.put("case",defColor);
    keywords.put("catch",defColor);
    keywords.put("char",defColor);
    keywords.put("class",defColor);
    keywords.put("continue",defColor);
    keywords.put("default",defColor);
    keywords.put("do",defColor);
    keywords.put("double",defColor);
    keywords.put("enum",defColor);
    keywords.put("extends",defColor);
    keywords.put("else",defColor);
    keywords.put("false",defColor);
    keywords.put("final",defColor);
    keywords.put("finally",defColor);
    keywords.put("float",defColor);
    keywords.put("for",defColor);
    keywords.put("if",defColor);
    keywords.put("implements",defColor);
    keywords.put("import",defColor);
    keywords.put("instanceof",defColor);
    keywords.put("int",defColor);
    keywords.put("interface",defColor);
    keywords.put("long",defColor);
    keywords.put("native",defColor);
    keywords.put("new",defColor);
    keywords.put("null",defColor);
    keywords.put("package",defColor);
    keywords.put("private",defColor);
    keywords.put("protected",defColor);
    keywords.put("public",defColor);
    keywords.put("return",defColor);
    keywords.put("short",defColor);
    keywords.put("static",defColor);
    keywords.put("super",defColor);
    keywords.put("switch",defColor);
    keywords.put("synchronized",defColor);
    keywords.put("this",defColor);
    keywords.put("throw",defColor);
    keywords.put("throws",defColor);
    keywords.put("transient",defColor);
    keywords.put("true",defColor);
    keywords.put("try",defColor);
    keywords.put("void",defColor);
    keywords.put("volatile",defColor);
    keywords.put("while",defColor);
    doc.setKeywords(keywords);
    editor.setDocument(doc);
    frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    frame.setSize(400,400);
    frame.getContentPane().add(editor);
    frame.setVisible(true);
  }
}

tut orials.de	tut verbinden	tut dir helfen	tut kooperieren
©2000-2012 tutorials.de Alle Rechte vorbehalten	tut informieren » Impressum » Nutzungsregeln » Netiquette » Team » Redaktion	» Tutorials » Videotutorials » Showroom » Events & Contests » Chat » RSS-Feed » Blogs	» der-webdesigner.net » DesignerInAction » Design Nation » Directorforum » Flashhilfe » PHP-Resource » PHPwelt » PSD-Tutorials

Themen-Optionen

Anzeige

Ähnliche Themen

Java Syntax Highlighting nach Beispiel

Syntax Highlighting

Syntax-Highlighting

Java Syntax highlighting (PHP)

E-Mail:

Abonnieren Abbestellen