如何更改 JTextPane 中特定单词的颜色？

Question

如何在用户键入时更改JTextPane中特定单词的颜色？ 我应该覆盖JTextPane paintComponent方法吗？

Answer 1

不。您不应该覆盖paintComponent() 方法。 相反，您应该使用StyledDocument 。 你也应该自己划定单词。

这是演示，它在键入时将“公共”、“受保护”和“私有”变为红色，就像一个简单的代码编辑器：

import javax.swing.*;
import java.awt.*;
import javax.swing.text.*;

public class Test extends JFrame {
    private int findLastNonWordChar (String text, int index) {
        while (--index >= 0) {
            if (String.valueOf(text.charAt(index)).matches("\\W")) {
                break;
            }
        }
        return index;
    }

    private int findFirstNonWordChar (String text, int index) {
        while (index < text.length()) {
            if (String.valueOf(text.charAt(index)).matches("\\W")) {
                break;
            }
            index++;
        }
        return index;
    }

    public Test () {
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setSize(400, 400);
        setLocationRelativeTo(null);

        final StyleContext cont = StyleContext.getDefaultStyleContext();
        final AttributeSet attr = cont.addAttribute(cont.getEmptySet(), StyleConstants.Foreground, Color.RED);
        final AttributeSet attrBlack = cont.addAttribute(cont.getEmptySet(), StyleConstants.Foreground, Color.BLACK);
        DefaultStyledDocument doc = new DefaultStyledDocument() {
            public void insertString (int offset, String str, AttributeSet a) throws BadLocationException {
                super.insertString(offset, str, a);

                String text = getText(0, getLength());
                int before = findLastNonWordChar(text, offset);
                if (before < 0) before = 0;
                int after = findFirstNonWordChar(text, offset + str.length());
                int wordL = before;
                int wordR = before;

                while (wordR <= after) {
                    if (wordR == after || String.valueOf(text.charAt(wordR)).matches("\\W")) {
                        if (text.substring(wordL, wordR).matches("(\\W)*(private|public|protected)"))
                            setCharacterAttributes(wordL, wordR - wordL, attr, false);
                        else
                            setCharacterAttributes(wordL, wordR - wordL, attrBlack, false);
                        wordL = wordR;
                    }
                    wordR++;
                }
            }

            public void remove (int offs, int len) throws BadLocationException {
                super.remove(offs, len);

                String text = getText(0, getLength());
                int before = findLastNonWordChar(text, offs);
                if (before < 0) before = 0;
                int after = findFirstNonWordChar(text, offs);

                if (text.substring(before, after).matches("(\\W)*(private|public|protected)")) {
                    setCharacterAttributes(before, after - before, attr, false);
                } else {
                    setCharacterAttributes(before, after - before, attrBlack, false);
                }
            }
        };
        JTextPane txt = new JTextPane(doc);
        txt.setText("public class Hi {}");
        add(new JScrollPane(txt));
        setVisible(true);
    }

    public static void main (String args[]) {
        new Test();
    }
}

代码不是很漂亮，因为我输入的很快，但它有效。 我希望它能给你一些提示。

Answer 2

覆盖paintComponent对您没有帮助。

这不是一件容易的事，但也不是不可能。 这样的事情会帮助你：

DefaultStyledDocument document = new DefaultStyledDocument();
JTextPane textpane = new JTextPane(document);
StyleContext context = new StyleContext();
// build a style
Style style = context.addStyle("test", null);
// set some style properties
StyleConstants.setForeground(style, Color.BLUE);
// add some data to the document
document.insertString(0, "", style);

您可能需要对此进行调整，但至少它会告诉您从哪里开始。

Answer 3

另一种解决方案是使用DocumentFilter 。

下面是一个例子：

创建一个扩展 DocumentFilter 的类：

private final class CustomDocumentFilter extends DocumentFilter
{
        private final StyledDocument styledDocument = yourTextPane.getStyledDocument();

        private final StyleContext styleContext = StyleContext.getDefaultStyleContext();
        private final AttributeSet greenAttributeSet = styleContext.addAttribute(styleContext.getEmptySet(), StyleConstants.Foreground, Color.GREEN);
        private final AttributeSet blackAttributeSet = styleContext.addAttribute(styleContext.getEmptySet(), StyleConstants.Foreground, Color.BLACK);

    // Use a regular expression to find the words you are looking for
    Pattern pattern = buildPattern();

    @Override
    public void insertString(FilterBypass fb, int offset, String text, AttributeSet attributeSet) throws BadLocationException {
        super.insertString(fb, offset, text, attributeSet);

        handleTextChanged();
    }

    @Override
    public void remove(FilterBypass fb, int offset, int length) throws BadLocationException {
        super.remove(fb, offset, length);

        handleTextChanged();
    }

    @Override
    public void replace(FilterBypass fb, int offset, int length, String text, AttributeSet attributeSet) throws BadLocationException {
        super.replace(fb, offset, length, text, attributeSet);

        handleTextChanged();
    }

    /**
     * Runs your updates later, not during the event notification.
     */
    private void handleTextChanged()
    {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                updateTextStyles();
            }
        });
    }

    /**
     * Build the regular expression that looks for the whole word of each word that you wish to find.  The "\\b" is the beginning or end of a word boundary.  The "|" is a regex "or" operator.
     * @return
     */
    private Pattern buildPattern()
    {
        StringBuilder sb = new StringBuilder();
        for (String token : ALL_WORDS_THAT_YOU_WANT_TO_FIND) {
            sb.append("\\b"); // Start of word boundary
            sb.append(token);
            sb.append("\\b|"); // End of word boundary and an or for the next word
        }
        if (sb.length() > 0) {
            sb.deleteCharAt(sb.length() - 1); // Remove the trailing "|"
        }

        Pattern p = Pattern.compile(sb.toString());

        return p;
    }


    private void updateTextStyles()
    {
        // Clear existing styles
        styledDocument.setCharacterAttributes(0, yourTextPane.getText().length(), blackAttributeSet, true);

        // Look for tokens and highlight them
        Matcher matcher = pattern.matcher(yourTextPane.getText());
        while (matcher.find()) {
            // Change the color of recognized tokens
            styledDocument.setCharacterAttributes(matcher.start(), matcher.end() - matcher.start(), greenAttributeSet, false);
        }
    }
}

然后您需要做的就是将您创建的DocumentFilter应用到JTextPane ，如下所示：

((AbstractDocument) yourTextPane.getDocument()).setDocumentFilter(new CustomDocumentFilter());

Answer 4

您可以像我在这里为我使用关键字文本着色构建的 SQL 编辑器所做的那样扩展 DefaultStyledDocument ...

    import java.util.ArrayList;
    import java.util.List;
    import javax.swing.text.AttributeSet;
    import javax.swing.text.BadLocationException;
    import javax.swing.text.DefaultStyledDocument;
    import javax.swing.text.Style;

    public class KeywordStyledDocument extends DefaultStyledDocument  {
        private static final long serialVersionUID = 1L;
        private Style _defaultStyle;
        private Style _cwStyle;

        public KeywordStyledDocument(Style defaultStyle, Style cwStyle) {
            _defaultStyle =  defaultStyle;
            _cwStyle = cwStyle;
        }

         public void insertString (int offset, String str, AttributeSet a) throws BadLocationException {
             super.insertString(offset, str, a);
             refreshDocument();
         }

         public void remove (int offs, int len) throws BadLocationException {
             super.remove(offs, len);
             refreshDocument();
         }

         private synchronized void refreshDocument() throws BadLocationException {
             String text = getText(0, getLength());
             final List<HiliteWord> list = processWords(text);

             setCharacterAttributes(0, text.length(), _defaultStyle, true);   
             for(HiliteWord word : list) {
                 int p0 = word._position;
                 setCharacterAttributes(p0, word._word.length(), _cwStyle, true);
             }
         }       

         private static  List<HiliteWord> processWords(String content) {
             content += " ";
             List<HiliteWord> hiliteWords = new ArrayList<HiliteWord>();
             int lastWhitespacePosition = 0;
             String word = "";
             char[] data = content.toCharArray();

             for(int index=0; index < data.length; index++) {
                 char ch = data[index];
                 if(!(Character.isLetter(ch) || Character.isDigit(ch) || ch == '_')) {
                     lastWhitespacePosition = index;
                     if(word.length() > 0) {
                         if(isReservedWord(word)) {
                             hiliteWords.add(new HiliteWord(word,(lastWhitespacePosition - word.length())));
                         }
                         word="";
                     }
                 }
                 else {
                     word += ch;
                 }
            }
            return hiliteWords;
         }

         private static final boolean isReservedWord(String word) {
             return(word.toUpperCase().trim().equals("CROSS") || 
                            word.toUpperCase().trim().equals("CURRENT_DATE") ||
                            word.toUpperCase().trim().equals("CURRENT_TIME") ||
                            word.toUpperCase().trim().equals("CURRENT_TIMESTAMP") ||
                            word.toUpperCase().trim().equals("DISTINCT") ||
                            word.toUpperCase().trim().equals("EXCEPT") ||
                            word.toUpperCase().trim().equals("EXISTS") ||
                            word.toUpperCase().trim().equals("FALSE") ||
                            word.toUpperCase().trim().equals("FETCH") ||
                            word.toUpperCase().trim().equals("FOR") ||
                            word.toUpperCase().trim().equals("FROM") ||
                            word.toUpperCase().trim().equals("FULL") ||
                            word.toUpperCase().trim().equals("GROUP") ||
                            word.toUpperCase().trim().equals("HAVING") ||
                            word.toUpperCase().trim().equals("INNER") ||
                            word.toUpperCase().trim().equals("INTERSECT") ||
                            word.toUpperCase().trim().equals("IS") ||
                            word.toUpperCase().trim().equals("JOIN") ||
                            word.toUpperCase().trim().equals("LIKE") ||
                            word.toUpperCase().trim().equals("LIMIT") ||
                            word.toUpperCase().trim().equals("MINUS") ||
                            word.toUpperCase().trim().equals("NATURAL") ||
                            word.toUpperCase().trim().equals("NOT") ||
                            word.toUpperCase().trim().equals("NULL") ||
                            word.toUpperCase().trim().equals("OFFSET") ||
                            word.toUpperCase().trim().equals("ON") ||
                            word.toUpperCase().trim().equals("ORDER") ||
                            word.toUpperCase().trim().equals("PRIMARY") ||
                            word.toUpperCase().trim().equals("ROWNUM") ||
                            word.toUpperCase().trim().equals("SELECT") ||
                            word.toUpperCase().trim().equals("SYSDATE") ||
                            word.toUpperCase().trim().equals("SYSTIME") ||
                            word.toUpperCase().trim().equals("SYSTIMESTAMP") ||
                            word.toUpperCase().trim().equals("TODAY") ||
                            word.toUpperCase().trim().equals("TRUE") ||
                            word.toUpperCase().trim().equals("UNION") ||
                            word.toUpperCase().trim().equals("UNIQUE") ||
                            word.toUpperCase().trim().equals("WHERE"));
        }
    }

只需将其添加到您的类中，如下所示：

    import java.awt.BorderLayout;
    import java.awt.Color;
    import java.awt.Font;
    import javax.swing.JFrame;
    import javax.swing.JScrollPane;
    import javax.swing.JTextPane;
    import javax.swing.text.BadLocationException;
    import javax.swing.text.Style;
    import javax.swing.text.StyleConstants;
    import javax.swing.text.StyleContext;

    public class SQLEditor extends JFrame {
        private static final long serialVersionUID = 1L;

        public SQLEditor() {
            StyleContext styleContext = new StyleContext();
            Style defaultStyle = styleContext.getStyle(StyleContext.DEFAULT_STYLE);
            Style cwStyle = styleContext.addStyle("ConstantWidth", null);
            StyleConstants.setForeground(cwStyle, Color.BLUE);
            StyleConstants.setBold(cwStyle, true);

            final JTextPane pane = new JTextPane(new KeywordStyledDocument(defaultStyle, cwStyle));
            pane.setFont(new Font("Courier New", Font.PLAIN, 12));

            JScrollPane scrollPane = new JScrollPane(pane);
            getContentPane().add(scrollPane, BorderLayout.CENTER);
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setSize(375, 400);      
        }

        public static void main(String[] args) throws BadLocationException {
            SQLEditor app = new SQLEditor();
            app.setVisible(true);
        }
    }

这是缺少的 HiliteWord 类...

public class HiliteWord {

    int _position;  
    String _word;

    public HiliteWord(String word, int position) {
        _position = position;   
        _word = word;
    }
}

Answer 5

@康斯坦丁

亲爱的康斯坦丁，我在我的小项目中使用了您的优秀解决方案，经过几次调整后，您的解决方案对我来说效果很好。

如果您允许，我的更改是：

我在我自己的 JFrame 中使用您的类 KeywordStyledDocument：

StyleContext styleContext = new StyleContext();
Style defaultStyle = styleContext.getStyle(StyleContext.DEFAULT_STYLE);

这行我已经改变了： MutableAttributeSet cwStyle = Functions.style(true, false, Color.RED);

private JTextPane jTextPaneNumbers = new JTextPane(new KeywordStyledDocument(defaultStyle, cwStyle));

我在一个名为 style 的静态函数中外包了 cwStyle 实例的供应：

public static MutableAttributeSet style(boolean boldness, boolean italic, Color color) {
    
    MutableAttributeSet s = new SimpleAttributeSet();
    
    StyleConstants.setLineSpacing(s, -0.2f);
    StyleConstants.setBold(s, boldness);
    StyleConstants.setItalic(s, italic);
    StyleConstants.setForeground(s, color);
    
    return s;
}

此外，正如您在上面看到的，cwStyle 类不再是 StyleConstants 的实例，而是 MutableAttributeSet 的实例。 因此，我自然也不得不更改 KeywordStyledDocumentClass 的构造函数：

public KeywordStyledDocument(Style defaultStyle, MutableAttributeSet cwStyle) {
    _defaultStyle =  defaultStyle;
    _cwStyle = cwStyle;
}

在这点改变之后，在你的 isReservedWord 函数中添加我自己的“单词”，并将我的 Characters ' 和 * 添加到你的 processWord 函数中：

 ...word.toUpperCase().trim().equals("UNION") ||
                    word.toUpperCase().trim().equals("UNIQUE") ||
                    word.toUpperCase().trim().equals("WHERE") ||
                    word.trim().equals("''''''") ||
                    word.trim().equals("******") 
                    );
 if(!(Character.isLetter(ch) || Character.isDigit(ch) || ch == '_' || ch == '\'' || ch == '*')) {

我成为了我想要的结果：

非常感谢您在这里展示您的代码。

Answer 6

借助用户shuangwhywhy代码中的想法，我修改了他的代码并做了一些改进，我相信这对许多希望能够在 JTextPane 中动态突出显示关键字的人来说是有益的。

在我的代码中，我扩展了JTextPane并创建了一个名为JSyntaxTextPane的组件。

它允许开发人员 state 需要着色/突出显示的单词列表，然后一旦在该组件的文本中找到这些单词，它们就会相应地着色。

主要方法：

initializeSyntaxHighlighter() - 这是我创建的默认方法，用于设置关键字着色规则。

addKeyWord(Color color, String...words) - 这是开发人员可以用来指定需要突出显示的颜色和单词的方法

import java.awt.Color;
import java.util.ArrayList;

import javax.swing.JFrame;
import javax.swing.JTextPane;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.DefaultStyledDocument;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyleContext;
import javax.swing.text.TabSet;
import javax.swing.text.TabStop;

/**
 * This class is a prototype for a syntax highlighter for java code.
 * It highlights common java keywords, boolean values and it highlights digits in the text.
 * 
 * Limitations of the current prototype:
 * -It does not highlight comments
 * -It does not highlight method calls
 * -It does not highlight objects that are not a part of common java keywords
 * -It does not have intellisense autosuggestion
 * 
 * Addendum:
 * Even though this syntax highlighter is designed for java code, {@link #initializeSyntaxHighlighter()} can be modified to highlight any other programming language or keywords
 */
public class JSyntaxTextPane extends JTextPane {

    // Default Styles
    final StyleContext cont = StyleContext.getDefaultStyleContext();
    AttributeSet defaultForeground = cont.addAttribute(cont.getEmptySet(), StyleConstants.Foreground, Color.white);
    AttributeSet defaultNumbers = cont.addAttribute(cont.getEmptySet(), StyleConstants.Foreground, Color.cyan);
    
    public JSyntaxTextPane () {
        // Styler
        DefaultStyledDocument doc = new DefaultStyledDocument() {
            public void insertString (int offset, String str, AttributeSet a) throws BadLocationException {
                super.insertString(offset, getDeveloperShortcuts(str), a);

                String text = getText(0, getLength());
                int before = findLastNonWordChar(text, offset);
                if (before < 0) before = 0;
                int after = findFirstNonWordChar(text, offset + str.length());
                int wordL = before;
                int wordR = before;

                while (wordR <= after) {
                    if (wordR == after || String.valueOf(text.charAt(wordR)).matches("\\W")) {
                        // Colors words in appropriate style, if nothing matches, make it default black
                        boolean matchFound = false;
                        
                        for (KeyWord keyWord : keyWords) {
                            if (text.substring(wordL, wordR).matches("(\\W)*("+keyWord.getWords()+")")) {
                                setCharacterAttributes(wordL, wordR - wordL, keyWord.getColorAttribute(), false);
                                matchFound = true;
                            }
                        }
                        
                        // Highlight numbers
                        if (text.substring(wordL, wordR).matches("\\W\\d[\\d]*")) {
                            setCharacterAttributes(wordL, wordR - wordL, defaultNumbers, false);
                            matchFound = true;
                        }
                        
                        // ================ ANY ADDITIONAL HIGHLIGHTING LOGIC MAY BE ADDED HERE
                        // Ideas: highlighting a comment; highlighting method calls;
                        
                        // ================
                        
                        // If no match found, make text default colored
                        if(!matchFound) {
                            setCharacterAttributes(wordL, wordR - wordL, defaultForeground, false);
                        }
                        
                        wordL = wordR;
                    }
                    
                    wordR++;
                }
            }

            public void remove (int offs, int len) throws BadLocationException {
                super.remove(offs, len);

                String text = getText(0, getLength());
                int before = findLastNonWordChar(text, offs);
                if (before < 0) before = 0;
                int after = findFirstNonWordChar(text, offs);

                // Colors words in appropriate style, if nothing matches, make it default black
                boolean matchFound = false;
                
                for (KeyWord keyWord : keyWords) {
                    if (text.substring(before, after).matches("(\\W)*("+keyWord.getWords()+")")) {
                        setCharacterAttributes(before, after - before, keyWord.getColorAttribute(), false);
                        matchFound = true;
                    } 
                    
                    // Highlight numbers
                    if (text.substring(before, after).matches("\\W\\d[\\d]*")) {
                        setCharacterAttributes(before, after - before, defaultNumbers, false);
                        matchFound = true;
                    }
                    
                    // ================ ANY ADDITIONAL HIGHLIGHTING LOGIC MAY BE ADDED HERE
                    // Ideas: highlighting a comment; highlighting method calls;
                    
                    // ================
            
                    if(!matchFound) {
                        setCharacterAttributes(before, after - before, defaultForeground, false);
                    }
                }
            }
        };
        
        setStyledDocument(doc);
        
        // SET DEFAULT TAB SIZE
        setTabSize(40);

        // THIS PART APPLIES DEFAULT SYNTAX HIGHLIGHTER BEHAVIOUR
        initializeSyntaxHighlighter();
    }
    
    private int findLastNonWordChar (String text, int index) {
        while (--index >= 0) {
            if (String.valueOf(text.charAt(index)).matches("\\W")) {
                break;
            }
        }
        return index;
    }

    private int findFirstNonWordChar (String text, int index) {
        while (index < text.length()) {
            if (String.valueOf(text.charAt(index)).matches("\\W")) {
                break;
            }
            index++;
        }
        return index;
    }
    
    /**
     * Shortcuts, when letter is typed, it will produce additional strings specified inside of this method
     * 
     * @param str
     * @return
     */
    private String getDeveloperShortcuts(String str) {
        // Add ending parenthesis when it is open
        if(str.equals("(")) {
            return "()";
        }
        
        // Add ending braces when it is open
        if(str.equals("{")) {
            return "{\n\n};";
        }
        
        return str;
    }
    
    /**
     * Sets size of space produced when user presses Tab button
     * 
     * @param tabSize
     */
    public void setTabSize(int tabSize) {
        // Once tab count exceed x times, it will make a small space only
        int maxTabsPerRow = 10;
        
        TabStop[] tabs = new TabStop[maxTabsPerRow];
        for(int i = 0; i < maxTabsPerRow; i++) {
            tabs[i] = new TabStop(tabSize*(i+1), TabStop.ALIGN_LEFT, TabStop.LEAD_NONE);
        }
        
        TabSet tabset = new TabSet(tabs);
        
        StyleContext sc = StyleContext.getDefaultStyleContext();
        AttributeSet aset = sc.addAttribute(SimpleAttributeSet.EMPTY,
        StyleConstants.TabSet, tabset);
        setParagraphAttributes(aset, false);
    }
    
    /**
     * Adds a key word or keywords that will be colored in the JTextPane
     * 
     * @param color - color of the words
     * @param words - words that need to be colored
     */
    public void addKeyWord(Color color, String ...words) {
        keyWords.add(new KeyWord(color, words));
    }
    
    ArrayList<KeyWord> keyWords = new ArrayList<KeyWord>();
    
    /**
     * Holds information about list of words that need to be colored in a specific color
     * 
     */
    class KeyWord {
        Color color;
        String[] words;
        
        /**
         * Instantiates a new key word object that holds a list of words that need to be colored.
         *
         * @param color the color
         * @param words the words
         */
        public KeyWord(Color color, String...words) {
            this.color = color;
            this.words = words;
        }
        
        public String getWords() {
            String text = "";
            
            for (int i = 0; i < words.length; i++) {
                if(i != words.length-1) {
                    text = text + words[i] + "|";
                } else {
                    text = text + words[i];
                }
            }
            
            return text;
        }
        
        public AttributeSet getColorAttribute() {
            StyleContext cont = StyleContext.getDefaultStyleContext();
            return cont.addAttribute(cont.getEmptySet(), StyleConstants.Foreground, color);
        }

    }
    
    /**
     * Sets color of all integers
     * 
     * @param color
     */
    public void setIntegerColours(Color color) {
        defaultNumbers = cont.addAttribute(cont.getEmptySet(), StyleConstants.Foreground, color);
        
    }
    
    /**
     * Sets color of non-keywords 
     * 
     * @param color
     */
    public void setDefaultTextColour(Color color) {
        defaultForeground = cont.addAttribute(cont.getEmptySet(), StyleConstants.Foreground, color);
    }
    
    /**
     * Initializes rules by which textpane should be coloring text
     */
    public void initializeSyntaxHighlighter() {
        // Set background color
        setBackground(Color.black);
        
        // Java keywords
        addKeyWord(Color.pink,
                "abstract",
                "continue",
                "for",
                "new",
                "switch",
                "assert",
                "default",
                "goto",
                "package",
                "synchronized",
                "do",
                "if",
                "private",
                "this",
                "break",
                "double",
                "implements",
                "protected",
                "throw",
                "else",
                "import",
                "public",
                "throws",
                "case",
                "enum",
                "instanceof",
                "return",
                "transient",
                "catch",
                "extends",
                "short",
                "try",
                "char",
                "final",
                "interface",
                "static",
                "void",
                "class",
                "finally",
                "strictfp",
                "volatile",
                "const",
                "native",
                "super",
                "while"
                );
        
        // Developer's preference
        addKeyWord(Color.green,
                "true"
                );
        
        addKeyWord(Color.red,
                "false"
                );
        
        addKeyWord(Color.red, 
                "!"
                );
        
        // Java Variables
        addKeyWord(Color.yellow,
                "String",
                "byte", "Byte",
                "short", "Short",
                "int", "Integer",
                "long", "Long",
                "float", "Float",
                "double", "Double",
                "char", "Character",
                "boolean", "Boolean");
    }
    
    /**
     * Demo for testing purposes
     */
    public static void main(String[] args) {
        // Our Component
        JSyntaxTextPane textPane = new JSyntaxTextPane();
        
        textPane.setText("public class Test {\r\n"
                + " int age = 18;\r\n"
                + " String name = \"Gerald\";\r\n"
                + " Long life = 100.50;\r\n"
                + " boolean alive = true;\r\n"
                + " boolean happy = false;\r\n"
                + " \r\n"
                + " // Comment Example\r\n"
                + " public static void shout(int loudness) {\r\n"
                + "     System.out.println(loudness);\r\n"
                + " };\r\n"
                + "\r\n"
                + "};");
        
        // JFrame
        JFrame frame = new JFrame("Test");
        frame.getContentPane().add(textPane);
        frame.pack();
        frame.setSize(350, 350);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

}