Trying to understand syntax hilighting (please run code provided)

Question

Can someone enlighten me here - I've searched the API, but cannot get this to work - I have also seen and used camrickr's superb code - the point is here I'm trying to get a handle on how that works by simplifying the processes. The following code is supposed to hilight in red or blue. At present the first 2 lines are in blue and the rest is black which I find a bit odd.
1. Base Application: SyntaxTest.javaimport java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.text.*;
import java.io.*;
public class SyntaxTest{
   JTextPane textPane;
   public static void main(String a[]){
      new SyntaxTest();
   SyntaxTest(){   
      textPane = new JTextPane();
      EditorKit editorKit = new StyledEditorKit(){
         public Document createDefaultDocument(){
            return new SimpleHighlight();
      textPane.setEditorKitForContentType("text", editorKit);
      textPane.setContentType("text");
      JButton button = new JButton("Load someText");
      button.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent e){
            try{
               FileInputStream fis = new FileInputStream( "someText.txt" );
               textPane.read( fis, null );
            catch(Exception e2) {}
      JFrame frame = new JFrame("Syntax Highlighting");
      frame.getContentPane().add(new JScrollPane(textPane) );
      frame.getContentPane().add(button, BorderLayout.SOUTH);
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setSize(600,300);
      frame.setVisible(true);
2. The hilighter: SimpleHighlight.java
import java.awt.*;
import javax.swing.text.*;
public class SimpleHighlight extends DefaultStyledDocument{
   private DefaultStyledDocument doc;
   private SimpleAttributeSet red, blue;
   int tally;
   protected SimpleHighlight(){
      doc=this;
      red = new SimpleAttributeSet();
      StyleConstants.setForeground(red, Color.red);
      blue = new SimpleAttributeSet();
      StyleConstants.setForeground(blue, Color.blue);
   public void insertString(int offset, String str, AttributeSet as) throws BadLocationException{
      super.insertString(offset, str, as);
      highlight(str, str.length());
   public void remove(int offset, int length) throws BadLocationException{
      super.remove(offset, length);
System.out.print("remove:"); // doesn't appear to do anything
   private void highlight(String thisLine, int length){
      if(thisLine.startsWith("1"))
         doc.setCharacterAttributes(0, length, red, false);
      else doc.setCharacterAttributes(0, length, blue, false);
System.out.print(thisLine+" "+length);
3. And this is the text file I'm accessing;- someText.txt
01234
12345
01234
12345
1234567890

Answer 1

Thanks again camrckr - let me know whether you approve of the amendendments;-import java.awt.*;
import java.awt.event.*;
import java.awt.Toolkit.*;
import java.util.*;
import javax.swing.*;
import javax.swing.text.*;
class SyntaxDocument extends DefaultStyledDocument{
   private DefaultStyledDocument doc;
   private Element rootElement;
   private boolean multiLineComment;
   private MutableAttributeSet normal;
   private MutableAttributeSet keyword;
   private MutableAttributeSet comment;
   private MutableAttributeSet quote;
   private MutableAttributeSet symbol; // NEW
   private MutableAttributeSet number; // NEW
   private Hashtable keywords;
   private boolean started;
   public SyntaxDocument(){
      doc = this;
      rootElement = doc.getDefaultRootElement();
      putProperty( DefaultEditorKit.EndOfLineStringProperty, "\n" );
      normal = new SimpleAttributeSet();
      StyleConstants.setForeground(normal, Color.black);
      symbol = new SimpleAttributeSet();
      StyleConstants.setForeground(symbol, Color.black);
      StyleConstants.setBold(symbol, true);
      number = new SimpleAttributeSet();
      Color purple = new Color(160, 0, 160);
      StyleConstants.setForeground(number, purple);
      comment = new SimpleAttributeSet();
      Color green = new Color(0, 120, 0);
      StyleConstants.setForeground(comment, green);
      keyword = new SimpleAttributeSet();
      Color blue = new Color(0, 0, 160);
      StyleConstants.setForeground(keyword, blue);
      StyleConstants.setBold(keyword, true);
      quote = new SimpleAttributeSet();
      Color red = new Color(160,0,0);
      StyleConstants.setForeground(quote, red);
      Object dummyObject = new Object(); 
      keywords = new Hashtable();
      keywords.put( "abstract", dummyObject );
      keywords.put( "boolean", dummyObject );
      keywords.put( "break", dummyObject );
      keywords.put( "byte", dummyObject );
      keywords.put( "case", dummyObject );
      keywords.put( "catch", dummyObject );
      keywords.put( "char", dummyObject );
      keywords.put( "class", dummyObject );
      keywords.put( "continue", dummyObject );
      keywords.put( "default", dummyObject );
      keywords.put( "do", dummyObject );
      keywords.put( "double", dummyObject );
      keywords.put( "else", dummyObject );
      keywords.put( "extends", dummyObject );
      keywords.put( "false", dummyObject );     // string literal
      keywords.put( "final", dummyObject );
      keywords.put( "finally", dummyObject );
      keywords.put( "float", dummyObject );
      keywords.put( "for", dummyObject );
      keywords.put( "goto", dummyObject );     
      keywords.put( "if", dummyObject );
      keywords.put( "implements", dummyObject );
      keywords.put( "import", dummyObject );
      keywords.put( "instanceof", dummyObject );
      keywords.put( "int", dummyObject );
      keywords.put( "interface", dummyObject );
      keywords.put( "long", dummyObject );
      keywords.put( "native", dummyObject );
      keywords.put( "new", dummyObject );
      keywords.put( "null", dummyObject );      // string literal
      keywords.put( "package", dummyObject );
      keywords.put( "private", dummyObject );
      keywords.put( "protected", dummyObject );
      keywords.put( "public", dummyObject );
      keywords.put( "return", dummyObject );
      keywords.put( "short", dummyObject );
      keywords.put( "static", dummyObject );
      keywords.put( "strictfp", dummyObject );
      keywords.put( "super", dummyObject );
      keywords.put( "switch", dummyObject );
      keywords.put( "synchronized", dummyObject );
      keywords.put( "this", dummyObject );
      keywords.put( "throw", dummyObject );
      keywords.put( "throws", dummyObject );
      keywords.put( "transient", dummyObject );
      keywords.put( "true", dummyObject );       // string literal
      keywords.put( "try", dummyObject );
      keywords.put( "void", dummyObject );
      keywords.put( "volatile", dummyObject );
      keywords.put( "while", dummyObject );
   /* Override to apply syntax highlighting after the document has been updated */
   public void insertString(int offset, String str, AttributeSet a) throws BadLocationException{
      if (str.equals("{"))
      str = addMatchingBrace(offset);
      super.insertString(offset, str, a);
      processChangedLines(offset, str.length());
   /* Override to apply syntax highlighting after the document has been updated */
   public void remove(int offset, int length) throws BadLocationException{
      super.remove(offset, length);
      processChangedLines(offset, 0);
   /* Determine how many lines have been changed, then apply highlighting to each line */
   private void processChangedLines(int offset, int length) throws BadLocationException {
      String content = doc.getText(0, doc.getLength());
      // The lines affected by the latest document update
      int startLine = rootElement.getElementIndex( offset );
      int endLine = rootElement.getElementIndex( offset + length );
      // Make sure all comment lines prior to the start line are commented
      // and determine if the start line is still in a multi line comment
      setMultiLineComment( commentLinesBefore( content, startLine ) );
      // Do the actual highlighting
      for (int i=startLine; i <=endLine; i++) applyHighlighting(content, i);
      // Resolve highlighting to the next end multi line delimiter
      if (isMultiLineComment()) commentLinesAfter(content, endLine);
      else highlightLinesAfter(content, endLine);
   /* Highlight lines when a multi line comment is still 'open' */
   private boolean commentLinesBefore(String content, int line){
      int offset = rootElement.getElement( line ).getStartOffset();
      // Start of comment not found, nothing to do
      int startDelimiter = lastIndexOf( content, getStartDelimiter(), offset-2);
      if (startDelimiter < 0)return false;
      // Matching start/end of comment found, nothing to do
      int endDelimiter = indexOf( content, getEndDelimiter(), startDelimiter );
      if (endDelimiter < offset & endDelimiter != -1)return false;
      // End of comment not found, highlight the lines
      doc.setCharacterAttributes(startDelimiter, offset - startDelimiter + 1, comment, false);
      return true;
   /* Highlight comment lines to matching end delimiter */
   private void commentLinesAfter(String content, int line){
      int offset = rootElement.getElement( line ).getEndOffset();
      // End of comment not found, nothing to do
      int endDelimiter = indexOf( content, getEndDelimiter(), offset );
      if (endDelimiter < 0) return;
      // Matching start/end of comment found, comment the lines
      int startDelimiter = lastIndexOf( content, getStartDelimiter(), endDelimiter );
      if (startDelimiter < 0 || startDelimiter <= offset){
         doc.setCharacterAttributes(offset, endDelimiter - offset + 1, comment, false);
   /* Highlight lines to start or end delimiter */
   private void highlightLinesAfter(String content, int line) throws BadLocationException{
      int offset = rootElement.getElement( line ).getEndOffset();
      // Start/End delimiter not found, nothing to do
      int startDelimiter = indexOf( content, getStartDelimiter(), offset );
      int endDelimiter = indexOf( content, getEndDelimiter(), offset );
      if (startDelimiter < 0)     startDelimiter = content.length();
      if (endDelimiter < 0)endDelimiter = content.length();
      int delimiter = Math.min(startDelimiter, endDelimiter);
      if (delimiter < offset)return;
      // Start/End delimiter found, reapply highlighting
      int endLine = rootElement.getElementIndex( delimiter );
      for (int i = line + 1; i < endLine; i++){
         Element branch = rootElement.getElement( i );
         Element leaf = doc.getCharacterElement( branch.getStartOffset() );
         AttributeSet as = leaf.getAttributes();
         if ( as.isEqual(comment) ) applyHighlighting(content, i);
   /* Parse the line to determine the appropriate highlighting */
   private void applyHighlighting(String content, int line) throws BadLocationException{
      int startOffset = rootElement.getElement( line ).getStartOffset();
      int endOffset = rootElement.getElement( line ).getEndOffset() - 1;
      int lineLength = endOffset - startOffset;
      int contentLength = content.length();
      if (endOffset >= contentLength)endOffset = contentLength - 1;
         // check for multi line comments
         // (always set the comment attribute for the entire line)
         if( ( endingMultiLineComment(content, startOffset, endOffset) )
            ||( isMultiLineComment() )
            ||( startingMultiLineComment(content, startOffset, endOffset) ) ){
               doc.setCharacterAttributes(startOffset, endOffset - startOffset + 1, comment, false);
               return;
      // set normal attributes for the line
      doc.setCharacterAttributes(startOffset, lineLength, normal, true);
      int index = content.indexOf(getSingleLineDelimiter(), startOffset);
      if ( (index > -1) && (index < endOffset) ){
         doc.setCharacterAttributes(index, endOffset - index + 1, comment, false);
         endOffset = index - 1;
      if(startOffset>endOffset) tokensInBold(content, startOffset);  // NEW
      else checkForTokens(content, startOffset, endOffset);
/* This line contain the start delimiter */
   private boolean startingMultiLineComment(String content, int startOffset, int endOffset) throws BadLocationException{
      int index = indexOf( content, getStartDelimiter(), startOffset );
      if( (index < 0) || (index > endOffset) ) return false;
      else{
         setMultiLineComment( true );
         return true;
   /* Does this line contain the end delimiter */
   private boolean endingMultiLineComment(String content, int startOffset, int endOffset) throws BadLocationException{
      int index = indexOf( content, getEndDelimiter(), startOffset );
      if( (index < 0) || (index > endOffset) ) return false;
      else{
         setMultiLineComment( false );
         return true;
   /* We have found a start delimiter and are still searching for the end delimiter */
   private boolean isMultiLineComment(){
      return multiLineComment;
   private void setMultiLineComment(boolean value){
      multiLineComment = value;
   /* Wait for all other painting before painting these once */
   private void tokensInBold(String content, int length){  // NEW
      for(int i=0; i<length; i++){        
         if(isDelimiterBold(content.substring(i, i+1)))
            doc.setCharacterAttributes(i, 1, symbol, false);        
   private void checkForTokens(String content, int startOffset, int endOffset){
      while (startOffset <= endOffset){
         // skip the delimiters to find the start of a new token
         while (isDelimiter(content.substring(startOffset, startOffset+1))){
            if(startOffset < endOffset) startOffset++;
            else return;
         // Extract and process the entire token
         if (isQuoteDelimiter( content.substring(startOffset, startOffset + 1)))
            startOffset = getQuoteToken(content, startOffset, endOffset);
         else startOffset = getOtherToken(content, startOffset, endOffset);        
   private int getQuoteToken(String content, int startOffset, int endOffset){
      String quoteDelimiter = content.substring(startOffset, startOffset + 1);
      String escapeString = getEscapeString(quoteDelimiter);
      int index;
      int endOfQuote = startOffset;
      // skip over the escape quotes in this quote
      index = content.indexOf(escapeString, endOfQuote + 1);
      while ( (index > -1) && (index < endOffset) ){
         endOfQuote = index + 1;
         index = content.indexOf(escapeString, endOfQuote);
      // now find the matching delimiter
      index = content.indexOf(quoteDelimiter, endOfQuote + 1);
      if( (index < 0) || (index > endOffset) ) endOfQuote = endOffset;
      else endOfQuote = index;
      doc.setCharacterAttributes(startOffset, endOfQuote-startOffset+1, quote, false);
      return endOfQuote + 1;
   private int getOtherToken(String content, int startOffset, int endOffset){
      int endOfToken = startOffset + 1;
      while(endOfToken <= endOffset ){
         if(isDelimiter(content.substring(endOfToken, endOfToken+1)))
            break;
         endOfToken++;
      String token = content.substring(startOffset, endOfToken);
      try{                                              // NEW
        Long.parseLong(token);
        doc.setCharacterAttributes(startOffset, endOfToken-startOffset, number, false);
      }catch(NumberFormatException nfe){}
      if( isKeyword( token ) )
         doc.setCharacterAttributes(startOffset, endOfToken-startOffset, keyword, false);
         return endOfToken + 1;
      private int indexOf(String content, String needle, int offset){
         int index;
         while( (index = content.indexOf(needle, offset)) != -1 ){
            String text = getLine( content, index ).trim();
            if(text.startsWith(needle) || text.endsWith(needle)) break;
            else offset = index + 1;
         return index;
   private int lastIndexOf(String content, String needle, int offset){
      int index;
      while ( (index = content.lastIndexOf(needle, offset)) != -1 ){
         String text = getLine( content, index ).trim();
         if( (text.startsWith(needle)) || (text.endsWith(needle)) ) break;
         else offset = index - 1;
      return index;
   private String getLine(String content, int offset){
      int line = rootElement.getElementIndex( offset );
      Element lineElement = rootElement.getElement( line );
      int start = lineElement.getStartOffset();
      int end = lineElement.getEndOffset();
      return content.substring(start, end - 1);
   protected boolean isDelimiter(String character){
      String operands = ";:{}()[]+-/%<=>!&|^~*,.\\\n";     
      if (Character.isWhitespace( character.charAt(0) ) ||
         operands.indexOf(character)!= -1 )
      return true;
      else return false;
   protected boolean isQuoteDelimiter(String character){
      String quote = "\"'";
      if (quote.indexOf(character) < 0) return false;
      else return true;
   protected boolean isDelimiterBold(String character){  // NEW
      String symbolDelimiters = "{}[]();&|";
        if ( symbolDelimiters.indexOf(character)< 0) return false;
      else return true;
   protected boolean isKeyword(String token){
      Object o = keywords.get( token );
      return o == null ? false : true;
   protected String getStartDelimiter(){
      return "/*";
   protected String getEndDelimiter(){
      return "*/";
   protected String getSingleLineDelimiter(){
      return "//";
   protected String getEscapeString(String quoteDelimiter){
      return "\\" + quoteDelimiter;
   protected String addMatchingBrace(int offset) throws BadLocationException{
      StringBuffer whiteSpace = new StringBuffer();
      int line = rootElement.getElementIndex( offset );
      int i = rootElement.getElement(line).getStartOffset();
      while(true){
         String temp = doc.getText(i, 1);
         if (temp.equals(" ") || temp.equals("\t")){
            whiteSpace.append(temp);
            i++;
         else break;
      return "{\n" + whiteSpace.toString() + whiteSpace.toString()+"\n" + whiteSpace.toString() + "}";
}