Source code: novaworx/textpane/SyntaxTextPane.java

   /*
   Novaworx Development Environment
   Copyright (C) 2000-2003 Mark Soderquist
   Portions Copyright (C) 1998-2001 Slava Pestov
   Portions Copyright (C) 1999-2000 Mike Dillon
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to:
  
  Free Software Foundation, Inc.
  59 Temple Place, Suite 330
  Boston, MA 02111-1307 USA
  */
  
  package novaworx.textpane;
  
  import java.awt.*;
  import java.awt.event.*;
  import java.awt.font.*;
  import java.lang.reflect.*;
  import java.util.regex.*;
  import javax.swing.*;
  import javax.swing.event.*;
  import javax.swing.plaf.*;
  import javax.swing.text.*;
  import javax.swing.undo.*;
  import novaworx.syntax.*;
  import cosmoworx.log.*;
  
  /**
  <p>The <code>SyntaxTextPane</code> is a powerful set of classes for editing primarily
  text.  It may be adapted to handle editing of binary files at a future date.</p>
  
  <p>The <code>SyntaxTextPane</code> was derived from two versions of the program
  <a href="http://www.jedit.org">jEdit</a> written by Slava Pestov.</p>
  
  @author Slava Pestov
  @author Mark Soderquist
  @since Novaworx 1.0
  */
  public class SyntaxTextPane extends JEditorPane {
  
    /**
    The default editor kit for this text component.
    */
    public static final EditorKit EDITOR_KIT = new SyntaxEditorKit();
  
    public static final String STYLES_ATTRIBUTE = "colors";
  
    private static boolean mbKeymapInitialized;
  
    private String msSyntax;
  
    private boolean mbAntiAlias;
  
    private Color moLineHighlightColor;
  
    private Object moLineHighlightTag;
  
    private int miBracketLine = -1;
  
    private int miOtherBracketLine = -1;
  
    private Color moBracketHighlightColor;
  
    private Object moBracketHighlightTag;
  
    private Object moOtherBracketHighlightTag;
  
    private Object moBlockCaretHighlightTag;
  
    private int miTabSize = 2;
  
    private int miElectricLines;
  
    private boolean mbBlock;
  
    private boolean mbOverwrite;
  
    private boolean mbBlockSelect;
  
    private int miLastLine = -1;
  
    private int miLastBracketPosition = -1;
  
    private int miLastOtherBracketPosition = -1;
  
    private double mdScrollToPercentFromTop = 0.3;
  
   private static Cursor moNoCursor;
 
   private static Cursor moTextCursor;
 
   /**
   Create a new <code>SyntaxTextPane</code> component without syntax highlighting by default.
   */
   public SyntaxTextPane() {
     Toolkit oToolkit = Toolkit.getDefaultToolkit();
     byte[] aData = { 0 };
 
     setBorder(null);
 
     // Setup the cursor.
     moNoCursor = oToolkit.createCustomCursor( oToolkit.createImage( aData ), new Point( 0, 0 ), "cursor.none" );
     moTextCursor = Cursor.getPredefinedCursor( Cursor.TEXT_CURSOR );
     setCursor( moTextCursor );
     addMouseMotionListener( new MouseMotionHandler() );
 
     // Setup default colors.
     setSyntaxStyles( getDefaultSyntaxStyles() );
     Color oSelectionColor = UIManager.getColor( "List.selectionBackground" );
     Color oNewSelectionColor = new Color( oSelectionColor.getRed(), oSelectionColor.getGreen(), oSelectionColor.getBlue(), 128 );
     setSelectionColor( oNewSelectionColor );
     moLineHighlightColor = new Color( 128, 128, 128, 64 );
     moBracketHighlightColor = new Color( 255, 128, 128, 128 );
 
     // FIX There is a new way of handling keymaps in Java 1.4.0.
     // Initialize the keymap.
     if( !mbKeymapInitialized ) {
       Keymap oMap = JTextComponent.getKeymap( JTextComponent.DEFAULT_KEYMAP );
       oMap.setDefaultAction( new DefaultKeyTypedAction() );
       oMap.addActionForKeyStroke( KeyStroke.getKeyStroke( KeyEvent.VK_INSERT, 0 ), new InsertKeyAction() );
       mbKeymapInitialized = true;
     }
 
     // Set up actions.
     ActionMap oActionMap = getActionMap();
 
     // Display the action keys in the map.
     //Object[] aKeys = oActionMap.allKeys();
     //for( int iIndex = 0; iIndex < aKeys.length; iIndex++ ) {
     //  System.out.println( "Action key: " + aKeys[ iIndex ].toString() );
     //}
 
     oActionMap.put( "undo", new UndoAction() );
     oActionMap.put( "redo", new RedoAction() );
     oActionMap.put( "indent", new IndentAction() );
     oActionMap.put( "unindent", new UnindentAction() );
 
     // Setup the caret.
     EditorCaret oCaret = new EditorCaret();
     setCaret( oCaret );
     setCaretColor( Color.red );
     setElectricBorder( 3 );
   }
 
   /**
   Returns the default editor kit for this text component.
   */
   public EditorKit createDefaultEditorKit() {
     return EDITOR_KIT;
   }
 
   /**
   Set the anti-alias flag.
   */
   public void setAntiAlias( boolean abAntiAlias ) {
     mbAntiAlias = abAntiAlias;
     repaint();
   }
 
   /**
   Get the anit-alias flag.
   */
   public boolean isAntiAlias() {
     return mbAntiAlias;
   }
 
   /**
   Sets the currently highlighted line.
   @param aiLineStart The start offset of the line in the document.
   @param aiLineEnd The end offset of the line in the document.
   */
 
   public void setHighlightedLine( int aiLineStart, int aiLineEnd ) {
     if( moLineHighlightTag == null ) return;
 
     try {
       getHighlighter().changeHighlight( moLineHighlightTag, aiLineStart, aiLineEnd);
     } catch( BadLocationException aoException ) {
       Log.write( Log.ERROR, aoException );
     }
   }
 
   /**
   Sets the line highlight color.
   @param aoColor The line highlight color.
   */
 
   public void setLineHighlightColor( Color aoColor ) {
     moLineHighlightColor = aoColor;
   }
 
   /**
   Returns the line highlight color.
   */
 
   public Color getLineHighlightColor() {
     return moLineHighlightColor;
   }
 
   /**
   Sets the current line highlighting feature.
   @param abLineHighlight True if the current line should be
   highlighted, false otherwise.
   */
   public void setLineHighlight( boolean abLineHighlight ) {
     if( moLineHighlightTag != null ) {
       if( abLineHighlight) {
         return;
       } else {
         getHighlighter().removeHighlight( moLineHighlightTag );
         moLineHighlightTag = null;
       }
     } else if( abLineHighlight ) {
       try {
         moLineHighlightTag = getHighlighter().addHighlight( 0, 0, new CurrentLineHighlighter() );
       } catch(BadLocationException aoException ) {
         Log.write( Log.ERROR, aoException );
       }
     }
   }
 
   /**
   Returns true if current line highlighting is enabled, false
   otherwise.
   */
   public boolean getLineHighlight() {
     return moLineHighlightTag != null;
   }
 
   /**
   Sets the highlighted bracket.
   @param aiBracketPosition The offset of the bracket in the document.
   */
   public void setHighlightedBracket( int aiBracketPosition ) {
     if( moBracketHighlightTag == null ) return;
 
     if( aiBracketPosition == miLastBracketPosition ) return;
 
     miLastBracketPosition = aiBracketPosition;
 
     try
     {
       if( aiBracketPosition == -1) {
         getHighlighter().changeHighlight( moBracketHighlightTag, 0, 0 );
       } else {
         getHighlighter().changeHighlight( moBracketHighlightTag, aiBracketPosition, aiBracketPosition + 1 );
       }
     } catch( BadLocationException aoException ) {
       Log.write( Log.ERROR, aoException );
     }
   }
 
   /**
   Sets the other highlighted bracket.
   @param aiBracketPosition The offset of the other bracket in the document.
   */
   public void setOtherHighlightedBracket( int aiOtherBracketPosition ) {
     if( moOtherBracketHighlightTag == null ) return;
 
     if( aiOtherBracketPosition == miLastOtherBracketPosition ) return;
 
     miLastOtherBracketPosition = aiOtherBracketPosition;
 
     try
     {
       if( aiOtherBracketPosition == -1) {
         getHighlighter().changeHighlight( moOtherBracketHighlightTag, 0, 0 );
       } else {
         getHighlighter().changeHighlight( moOtherBracketHighlightTag, aiOtherBracketPosition, aiOtherBracketPosition + 1 );
       }
     } catch( BadLocationException aoException ) {
       Log.write( Log.ERROR, aoException );
     }
   }
 
   /**
   Sets the bracket highlight color.
   @param aoColor The bracket highlight color.
   */
 
   public void setBracketHighlightColor( Color aoColor ) {
     moBracketHighlightColor = aoColor;
   }
 
   /**
   Returns the bracket highlight color.
   */
 
   public Color getBracketHighlightColor() {
     return moBracketHighlightColor;
   }
 
   /**
   Sets the bracket highlighting feature.
   @param abBracketHighlight True if matching brackets should be highlighted, false otherwise.
   */
 
   public void setBracketHighlight( boolean abBracketHighlight ) {
     if( moBracketHighlightTag != null) {
       if( abBracketHighlight ) {
         return;
       } else {
         getHighlighter().removeHighlight( moBracketHighlightTag );
         moBracketHighlightTag = null;
       }
     } else if( abBracketHighlight ) {
       try {
         moBracketHighlightTag = getHighlighter().addHighlight( 0, 0, new BracketHighlighter() );
       } catch( BadLocationException aoException ) {
         Log.write( Log.ERROR, aoException );
       }
     }
 
     if( moOtherBracketHighlightTag != null) {
       if( abBracketHighlight ) {
         return;
       } else {
         getHighlighter().removeHighlight( moOtherBracketHighlightTag );
         moOtherBracketHighlightTag = null;
       }
     } else if( abBracketHighlight ) {
       try {
         moOtherBracketHighlightTag = getHighlighter().addHighlight( 0, 0, new BracketHighlighter() );
       } catch( BadLocationException aoException ) {
         Log.write( Log.ERROR, aoException );
       }
     }
   }
 
   /**
   Returns true if bracket highlighting is enabled, false otherwise.
   */
 
   public boolean getBracketHighlight() {
     return moBracketHighlightTag != null & moOtherBracketHighlightTag != null;
   }
 
   /**
   Sets the number of lines from the top or bottom of the
   text area from which autoscroll begins.
   @param aiLines The number of lines
   */
 
   public void setElectricBorder( int aiLines ) {
     miElectricLines = aiLines;
   }
 
   /**
   Returns the number of lines from the top or bottom of the
   text area from which autoscrolling begins.
   */
 
   public int getElectricBorder() {
     return miElectricLines;
   }
 
   /**
   Sets the block caret.
   @param abBlock True if a block caret should be drawn, false otherwise
   */
 
   public void setBlockCaret( boolean abBlockCaret ) {
     mbBlock = abBlockCaret;
 
     if( moBlockCaretHighlightTag != null ) {
       if( abBlockCaret & !mbOverwrite ) {
         return;
       } else {
         getHighlighter().removeHighlight( moBlockCaretHighlightTag );
         moLineHighlightTag = null;
       }
     } else if( abBlockCaret & !mbOverwrite ) {
       try {
         moBlockCaretHighlightTag = getHighlighter().addHighlight( 0, 0, new BlockCaretHighlighter() );
       } catch(BadLocationException aoException ) {
         Log.write( Log.ERROR, aoException );
       }
     }
   }
 
   /**
   Returns true if a block caret is enabled, false otherwise.
   */
 
   public boolean isBlockCaret() {
     return mbBlock;
   }
 
   /**
   Sets the block caret highlight position.
   @param aiBracketPosition The offset of the other bracket in the document.
   */
   public void setBlockCaretHighlight( int aiPosition ) {
     if( moBlockCaretHighlightTag == null ) return;
 
     try {
       if( aiPosition == -1 ) {
         getHighlighter().changeHighlight( moBlockCaretHighlightTag, 0, 0 );
       } else {
         getHighlighter().changeHighlight( moBlockCaretHighlightTag, aiPosition, aiPosition + 1 );
       }
     } catch( BadLocationException aoException ) {
       Log.write( Log.ERROR, aoException );
     }
   }
 
   /**
   Set the caret on time.
   */
   public void setCaretOnDelay( int aiDelay ) {
     ((EditorCaret)getCaret()).setBlinkOnDelay( aiDelay );
   }
 
   /**
   Get the caret on time.
   */
   public int getCaretOnDelay() {
     return ((EditorCaret)getCaret()).getBlinkOnDelay();
   }
 
   /**
   Set the caret off time.
   */
   public void setCaretOffDelay( int aiDelay ) {
     ((EditorCaret)getCaret()).setBlinkOffDelay( aiDelay );
   }
 
   /**
   Get the caret off time.
   */
   public int getCaretOffDelay() {
     return ((EditorCaret)getCaret()).getBlinkOffDelay();
   }
 
   /**
   Set the tab size for the editor.
   */
   public void setTabSize( int aiTabSize ) {
     miTabSize = aiTabSize;
     getSyntaxDocument().setTabSize( aiTabSize );
 
     revalidate();
     repaint();
   }
 
   /**
   Get the tab size for the editor.
   */
   public int getTabSize() {
     return miTabSize;
   }
 
   /**
   Sets the overwrite syntax.
   @param abOverwrite True if newly inserted characters should
   overwrite existing ones, false if they should be inserted.
   */
 
   public void setOverwrite( boolean abOverwrite ) {
     mbOverwrite = abOverwrite;
   }
 
   /**
   Returns true if overwrite syntax is enabled, false otherwise.
   */
 
   public boolean getOverwrite() {
     return mbOverwrite;
   }
 
   /**
   Sets the overwrite syntax flag to the opposite of it's
   current value.
   */
 
   public boolean toggleOverwrite() {
     return mbOverwrite = !mbOverwrite;
   }
 
   /**
   Set the block select flag.
   */
   public void setBlockSelect( boolean abBlockSelect ) {
     mbBlockSelect = abBlockSelect;
   }
 
   /**
   Get the block select flag.
   */
   public boolean isBlockSelect() {
     return mbBlockSelect;
   }
 
   /**
   Toggle the block select flag.
   */
   public boolean toggleBlockSelect() {
     return mbBlockSelect = !mbBlockSelect;
   }
 
   /**
   A unit is the height of one line of text.
   */
   public int getScrollableUnitIncrement( Rectangle aoVisibleArea, int aiOrientation, int aiDirection) {
     return getLineHeight();
   }
 
   /**
   Updates the highlighters.
   */
   public void updateHighlighters() {
     Document oDocument = getDocument();
     int iCaretPosition = getCaretPosition();
     Element oMap = oDocument.getDefaultRootElement();
     int iLineNumber = oMap.getElementIndex( iCaretPosition );
     Element oLineElement = oMap.getElement( iLineNumber );
     int iStart = oLineElement.getStartOffset();
     int iEnd = oLineElement.getEndOffset();
 
     // Set the caret highlight.
     setBlockCaretHighlight( iCaretPosition );
 
     // Set the current line highlight.
     if( getSelectionStart() == getSelectionEnd() ) {
       if( iLineNumber != miLastLine ) {
         setHighlightedLine( iStart, iEnd);
         miLastLine = iLineNumber;
       }
     }
 
     // Set the bracket highlight.
     try {
       int iOffset = -1;
       char cBracket = ' ';
       Segment oSegment = new Segment();
 
       if( iCaretPosition >= 0 && iOffset < 0 ) {
         oDocument.getText( iCaretPosition, 1, oSegment);
         cBracket = oSegment.array[ oSegment.offset ];
         switch( cBracket ) {
           case '(' : case ')' :
           case '{' : case '}' :
           case '[' : case ']' :
             iOffset = iCaretPosition;
         }
       }
 
       if( iCaretPosition > 0 && iOffset < 0 ) {
         oDocument.getText( iCaretPosition - 1, 1, oSegment);
         cBracket = oSegment.array[ oSegment.offset ];
         switch( cBracket ) {
           case '(' : case ')' :
           case '{' : case '}' :
           case '[' : case ']' :
             iOffset = iCaretPosition - 1;
         }
       }
 
       int iOtherOffset = -1;
       if( iOffset >= 0 ) {
         switch( cBracket ) {
         case '(':
           iOtherOffset = SyntaxUtilities.locateBracketForward( oDocument, iOffset, '(', ')' );
           break;
         case ')':
           iOtherOffset = SyntaxUtilities.locateBracketBackward( oDocument, iOffset, '(', ')');
           break;
         case '[':
           iOtherOffset = SyntaxUtilities.locateBracketForward( oDocument, iOffset, '[', ']');
           break;
         case ']':
           iOtherOffset = SyntaxUtilities.locateBracketBackward( oDocument, iOffset, '[', ']');
           break;
         case '{':
           iOtherOffset = SyntaxUtilities.locateBracketForward( oDocument, iOffset, '{', '}');
           break;
         case '}':
           iOtherOffset = SyntaxUtilities.locateBracketBackward( oDocument, iOffset, '{', '}');
           break;
         }
 
         // Set the highlight on the bracket if the other bracket was found.
         if( iOtherOffset >= 0 ) {
           setHighlightedBracket( iOffset );
           setOtherHighlightedBracket( iOtherOffset );
           int iBracketLine = getLineIndexForOffset( iOffset );
           int iOtherBracketLine = getLineIndexForOffset( iOtherOffset );
           miBracketLine = Math.min( iBracketLine, iOtherBracketLine );
           miOtherBracketLine = Math.max( iBracketLine, iOtherBracketLine );
         } else {
           setHighlightedBracket( -1 );
           setOtherHighlightedBracket( -1 );
           miBracketLine = -1;
           miOtherBracketLine = -1;
         }
       } else {
         setHighlightedBracket( -1 );
         setOtherHighlightedBracket( -1 );
         miBracketLine = -1;
         miOtherBracketLine = -1;
       }
     } catch(BadLocationException aoException ) {
       Log.write( Log.ERROR, aoException );
     }
   }
 
   /**
   Get the current row.
   */
   public int getCurrentRow() {
     return getCaretLineIndex() + 1;
   }
 
   /**
   Get the current column.
   */
   public int getCurrentColumn() {
     return ( getCaret().getDot() - getStartOffsetForLineIndex( getCaretLineIndex() ) ) + 1;
   }
 
   /**
   Get the line index of the upper bracket.
   */
   public int getBracketLineIndex() {
     return miBracketLine;
   }
 
   /**
   Get the line index of the lower bracket.
   */
   public int getOtherBracketLineIndex() {
     return miOtherBracketLine;
   }
 
   /**
   Get the line index of the caret.
   */
   public int getCaretLineIndex() {
     int iDot = getCaret().getDot();
     return getLineIndexForOffset( iDot );
   }
 
   /**
   Get the number of lines in the document.
   */
   public int getLineCount() {
     return getSyntaxDocument().getLineCount();
   }
 
   /**
   Get the line index for the specified offset.
   */
   public int getLineIndexForOffset( int aiOffset ) {
     return getSyntaxDocument().getLineIndexForOffset( aiOffset );
   }
 
   /**
   Get the start offset for the specified line index.
   */
   public int getStartOffsetForLineIndex( int aiIndex ) {
     return getSyntaxDocument().getStartOffsetForLineIndex( aiIndex );
   }
 
   /**
   Get the end offset for the specified line index.
   */
   public int getEndOffsetForLineIndex( int aiIndex ) {
     return getSyntaxDocument().getEndOffsetForLineIndex( aiIndex );
   }
 
   /**
   Sets the document edited by this text area. This method
   makes sure that it implements the <code>SyntaxDocument</code> interface.
   @param aoDocument The document.
   @see novaworx.textpane.SyntaxDocument
   */
 
   public void setDocument( Document aoDocument ) {
     if( !( aoDocument instanceof SyntaxDocument ) ) throw new IllegalArgumentException( "Document is not an instance of SyntaxDocument" );
 
     invalidate();
     super.setDocument( aoDocument );
     ((SyntaxDocument)aoDocument).setTabSize( miTabSize );
   }
 
   /**
   Returns the text area's document, typecast to a
   <code>SyntaxDocument</code>.
   @see novaworx.textpane.SyntaxDocument
   */
 
   public SyntaxDocument getSyntaxDocument() {
     return (SyntaxDocument)getDocument();
   }
 
   /**
   Sets the syntax that is to be used to split lines of
   this document up into tokens.
   @param asSyntax The name of the syntax.
   */
   public void setSyntax( String asSyntax ) {
     getSyntaxDocument().setSyntax( SyntaxFactory.getSyntax( asSyntax ) );
   }
 
   /**
   Sets the syntax that is to be used to split lines of
   this document up into tokens.
   @param aoSyntax The syntax.
   */
   public void setSyntax( Syntax aoSyntax ) {
     getSyntaxDocument().setSyntax( aoSyntax );
   }
 
   /**
   Returns the syntax that is to be used to split lines
   of this document up into tokens.
   @return The syntax.
   */
   public Syntax getSyntax() {
     return getSyntaxDocument().getSyntax();
   }
 
   /**
   Get the name of the syntax being used.
   @return The name of the syntax.
   */
   public String getSyntaxName() {
     Syntax oSyntax = getSyntax();
     String sName = oSyntax == null ? "text" : oSyntax.getName();
     return sName;
   }
 
   /**
   Sets the style array.
   @param aaStyles The new style list.
   */
   public void setSyntaxStyles( SyntaxStyle[] aaStyles ) {
     putClientProperty( STYLES_ATTRIBUTE, aaStyles );
   }
 
   /**
   Returns the style array.
   @return The style list.
   */
   public SyntaxStyle[] getSyntaxStyles() {
     return (SyntaxStyle[])getClientProperty( STYLES_ATTRIBUTE );
   }
 
   public void doElectricScroll( Rectangle aoArea ) {
     FontRenderContext oContext = new FontRenderContext( null, false, false );
     LineMetrics oMetrics = getFont().getLineMetrics( "This is a test.", oContext );
 
     int iHeight = (int)oMetrics.getHeight();
     int iY = Math.max( 0, aoArea.y - iHeight * miElectricLines );
     int iLines = iHeight * miElectricLines * 2;
     if( iY + iLines + aoArea.height <= getHeight() ) {
       aoArea.y = iY;
       aoArea.height += iLines;
     }
     scrollRectToVisible( aoArea );
   }
 
   public int getLineHeight() {
     return getFontMetrics( getFont() ).getHeight();
   }
 
   /**
   Paint the component.
   */
   public void paint( Graphics aoGraphics ) {
     if( mbAntiAlias ) {
       Graphics2D oGraphics = (Graphics2D)aoGraphics;
       oGraphics.setRenderingHint( RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON );
       //oGraphics.setRenderingHint( RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON );
     }
     super.paint( aoGraphics );
   }
 
   /**
   Set the foreground color.
   */
   public void setForeground( Color aoColor ) {
     super.setForeground( aoColor );
     SyntaxStyle[] aStyles = getSyntaxStyles();
     if( aStyles != null ) {
       SyntaxStyle oStyle = aStyles[ Token.NULL ];
       if( oStyle != null ) oStyle.setForeground( aoColor );
     }
   }
 
   /**
   Set the background color.
   */
   public void setBackground( Color aoColor ) {
     super.setBackground( aoColor );
     SyntaxStyle[] aStyles = getSyntaxStyles();
     if( aStyles != null ) {
       SyntaxStyle oStyle = aStyles[ Token.NULL ];
       if( oStyle != null ) oStyle.setBackground( aoColor );
     }
   }
 
   /**
   Returns the default style table. This can be passed to
   <code>SyntaxTextPane.setStyles()</code>.
   */
 
   public static SyntaxStyle[] getDefaultSyntaxStyles() {
     SyntaxStyle[] aStyles = new SyntaxStyle[ Token.ID_COUNT ];
 
     aStyles[ Token.NULL ] = new SyntaxStyle( new Color( 0, 0, 0 ) );
     aStyles[ Token.COMMENT1 ] = new SyntaxStyle( new Color( 128, 128, 128 ) );
     aStyles[ Token.COMMENT2 ] = new SyntaxStyle( new Color( 128, 128, 128 ) );
     aStyles[ Token.COMMENT3 ] = new SyntaxStyle( new Color( 0, 0, 160 ) );
     aStyles[ Token.DIGIT ] = new SyntaxStyle( new Color( 0, 160, 0) );
     aStyles[ Token.LITERAL1 ] = new SyntaxStyle( new Color( 64, 128, 255 ) );
     aStyles[ Token.LITERAL2 ] = new SyntaxStyle( new Color( 96, 96, 255 ) );
     aStyles[ Token.KEYWORD1 ] = new SyntaxStyle( new Color( 0, 96, 160 ) );
     aStyles[ Token.KEYWORD2 ] = new SyntaxStyle( new Color( 0, 160, 96 ) );
     aStyles[ Token.KEYWORD3 ] = new SyntaxStyle( new Color( 0, 160, 192 ) );
     aStyles[ Token.KEYWORD4 ] = new SyntaxStyle( new Color( 192, 160, 192 ) );
     aStyles[ Token.KEYWORD5 ] = new SyntaxStyle( new Color( 0, 192, 192 ) );
     aStyles[ Token.FUNCTION ] = new SyntaxStyle( new Color( 128, 32, 255 ) );
     aStyles[ Token.OPERATOR ] = new SyntaxStyle( new Color( 0, 0, 0 ) );
     aStyles[ Token.MARKUP ] = new SyntaxStyle( new Color( 64, 64, 128 ) );
     aStyles[ Token.LABEL ] = new SyntaxStyle( new Color( 0, 96, 96 ) );
     aStyles[ Token.INVALID ] = new SyntaxStyle( new Color( 255, 0, 0 ) );
 
     return aStyles;
   }
 
   /**
   Overrides scrollRectToVisible( moArea )</code>.
   */
   public void scrollRectToVisible( Rectangle moArea ) {
     new SafeScroller( moArea );
   }
 
   /**
   Set the scroll to percent from top.
   @param adPercent Range is 0.0 to 1.0.
   */
   public void setScrollToPercentFromTop( double adPercent ) {
     mdScrollToPercentFromTop = adPercent;
   }
 
   /**
   Set the scroll to percent from top.
   @return The scroll to percent from top value.
   */
   public double getScrollToPercentFromTop() {
     return mdScrollToPercentFromTop;
   }
 
   /**
   Scroll to the specified offset.
   */
   public void scrollToOffset( int aiOffset ) {
     double dPercent = mdScrollToPercentFromTop;
 
     if( aiOffset < 0 || aiOffset > getDocument().getLength() ) return;
 
     Container oParent = getParent();
     while( oParent != null && !( oParent instanceof JViewport ) ) {
       System.out.println( "Parent: " + oParent.getClass().getName() );
       oParent = oParent.getParent();
     }
     if( oParent == null ) return;
 
     Rectangle oViewArea = ((JViewport)oParent).getViewRect();
     Rectangle oLineArea = null;
     try {
       oLineArea = modelToView( aiOffset );
     } catch( BadLocationException aoException ) {
       Log.write( Log.ERROR, aoException );
       return;
     }
 
     int iNetHeight = oViewArea.height - oLineArea.height;
     int iTopHeight = (int)( iNetHeight * dPercent );
     int iBotHeight = iNetHeight - iTopHeight;
 
     Rectangle oScrollArea = new Rectangle( 0, oLineArea.y - iTopHeight, oViewArea.width, oViewArea.height );
 
     if( oScrollArea != null ) scrollRectToVisible( oScrollArea );
   }
 
   /**
   Jump to the specified offset.
   */
   public void jumpToOffset( int aiOffset ) {
     if( aiOffset < 0 || aiOffset > getDocument().getLength() ) return;
     requestFocusInWindow();
     scrollToOffset( aiOffset );
     setCaretPosition( aiOffset );
   }
 
   /**
   Jump to the specified offset.
   */
   public void moveToOffset( int aiOffset ) {
     if( aiOffset < 0 || aiOffset > getDocument().getLength() ) return;
     requestFocusInWindow();
     scrollToOffset( aiOffset );
     moveCaretPosition( aiOffset );
   }
 
   /**
   Jump to the specified line number.
   @param aiLineNumber The line number, not line index, to jump to.
   @return True if the caret was jumped to the specified line number.
   */
   public boolean jumpToLineNumber( int aiLineNumber ) {
     int iOffset = getStartOffsetForLineIndex( aiLineNumber - 1 );
     if( iOffset < 0 || iOffset > getDocument().getLength() ) return false;
     requestFocusInWindow();
     scrollToOffset( iOffset );
     setCaretPosition( iOffset );
     return true;
   }
 
   /**
   Move to the specified line number.
   @param aiLineNumber The line number, not line index, to move to.
   @return True if the caret was moved to the specified line number.
   */
   public boolean moveToLineNumber( int aiLineNumber ) {
     int iOffset = getStartOffsetForLineIndex( aiLineNumber - 1 );
     if( iOffset < 0 || iOffset > getDocument().getLength() ) return false;
     requestFocusInWindow();
     scrollToOffset( iOffset );
     moveCaretPosition( iOffset );
     return true;
   }
 
   /**
   Find the next occurance of the search expression starting at the specified offset.
   @param asExpression The search expression.
   @return True if an occurance was found.
   */
   public boolean findNext( String asExpression ) {
     return findNext( asExpression, Math.max( getCaret().getDot(), getCaret().getMark() ) );
   }
 
   /**
   Find the next occurance of the search expression starting at the specified offset.
   @param asExpression The search expression.
   @param aiOffset The start offset.
   @return True if an occurance was found.
   */
   public boolean findNext( String asExpression, int aiOffset ) {
     return findNext( asExpression, aiOffset, false );
   }
 
   /**
   Find the next occurance of the search expression starting at the specified offset.
   @param asExpression The search expression.
   @param aiOffset The start offset.
   @param abWrap The wrap flag.
   @return True if an occurance was found.
   */
   public boolean findNext( String asExpression, int aiOffset, boolean abWrap ) {
     String sSearch = null;
     try {
       sSearch = getDocument().getText( 0, getDocument().getLength() );
     } catch( BadLocationException aoException ) {
       return false;
     }
 
     int iStart = -1;
     int iLength = sSearch.length();
     StringBuffer oSearchBuffer = null;
     StringBuffer oExpression = new StringBuffer( asExpression );
 
     if( abWrap ) {
       oSearchBuffer = new StringBuffer( sSearch.substring( aiOffset ) );
       oSearchBuffer.append( sSearch.substring( 0, iLength - aiOffset ) );
     } else {
       oSearchBuffer = new StringBuffer( sSearch.substring( aiOffset ) );
     }
 
     // Find the occurance.
     iStart = oSearchBuffer.indexOf( oExpression.toString() );
     if( iStart < 0 ) return false;
 
     // Recalculate the start position.
     iStart = ( aiOffset + iStart ) % iLength;

    // Jump to the offset.
    setCaretPosition( iStart );

    // Select the find.
    moveCaretPosition( iStart + oExpression.length() );

    return true;
  }

  /**
  Find the previous occurance of the search expression starting at the specified offset.
  @param asExpression The search expression.
  @param abRegex Regular expression flag.
  @param abWrap The wrap flag.
  @return True if an occurance was found.
  */
  public boolean findPrevious( String asExpression ) {
    return findPrevious( asExpression, Math.min( getCaret().getDot(), getCaret().getMark() ) );
  }

  /**
  Find the previous occurance of the search expression starting at the specified offset.
  @param asExpression The search expression.
  @param aiOffset The start offset.
  @param abRegex Regular expression flag.
  @param abWrap The wrap flag.
  @return True if an occurance was found.
  */
  public boolean findPrevious( String asExpression, int aiOffset ) {
    return findPrevious( asExpression, aiOffset, false );
  }

  /**
  Find the previous occurance of the search expression starting at the specified offset.
  @param asExpression The search expression.
  @param aiOffset The start offset.
  @param abWrap The wrap flag.
  @return True if an occurance was found.
  */
  public boolean findPrevious( String asExpression, int aiOffset, boolean abWrap ) {
    String sSearch = null;
    try {
      sSearch = getDocument().getText( 0, getDocument().getLength() );
    } catch( BadLocationException aoException ) {
      return false;
    }

    int iStart = -1;
    int iLength = sSearch.length();
    StringBuffer oSearchBuffer = null;
    StringBuffer oExpression = new StringBuffer( asExpression );

    if( abWrap ) {
      oSearchBuffer = new StringBuffer( sSearch.substring( aiOffset ) );
      oSearchBuffer.append( sSearch.substring( 0, iLength - aiOffset ) );
    } else {
      oSearchBuffer = new StringBuffer( sSearch.substring( 0, aiOffset ) );
    }
    oSearchBuffer.reverse();
    oExpression.reverse();

    // Find the occurance.
    iStart = oSearchBuffer.indexOf( oExpression.toString() );
    if( iStart < 0 ) return false;

    // Recalculate the start position.
    iStart = ( aiOffset - iStart - oExpression.length() ) % iLength;

    // Jump to the offset.
    setCaretPosition( iStart );

    // Select the find.
    moveCaretPosition( iStart + oExpression.length() );

    return true;
  }

  /**
  Another implementation of the <code>replaceSelection</code> method
  made specifically for the <code>Syntax</code>.
  */
  private void _replaceSelection( String asContent ) {
    if( !mbOverwrite || getSelectionStart() != getSelectionEnd() ) {
      replaceSelection( asContent );
      return;
    }

    int iCaretPosition = getCaretPosition();
    Document oDocument = getDocument();
    Element oMap = oDocument.getDefaultRootElement();
    Element oLine = oMap.getElement( oMap.getElementIndex( iCaretPosition ) );

    if( oLine.getEndOffset() - iCaretPosition <= asContent.length() ) {
      replaceSelection( asContent );
      return;
    }

    try {
      oDocument.remove( iCaretPosition, asContent.length() );
      oDocument.insertString(  iCaretPosition, asContent, null );
    } catch( BadLocationException aoException ) {
      Log.write( Log.ERROR, aoException );
    }
  }

  /**
  The default action for typing a key, modified for the <code>Syntax</code>.
  */
  private static class DefaultKeyTypedAction extends TextAction {

    public DefaultKeyTypedAction() {
      super("text.editor.default.key.typed.action");
    }

    public void actionPerformed( ActionEvent aoEvent ) {
      JTextComponent oComponent = getTextComponent( aoEvent );
      String sContent = aoEvent.getActionCommand();
      int iModifiers = aoEvent.getModifiers();

      if( oComponent.getCursor() != moNoCursor ) oComponent.setCursor( moNoCursor );

      if( sContent != null && sContent.length() != 0 && ( iModifiers & ActionEvent.ALT_MASK ) == 0 ) {
        char cChar = sContent.charAt(0);
        if ( ( cChar >= 0x20 ) && ( cChar != 0x7F ) ) {
          if( oComponent instanceof SyntaxTextPane ) {
            ((SyntaxTextPane)oComponent)._replaceSelection( sContent );
          } else {
            oComponent.replaceSelection( sContent );
          }
        }
      }
    }
  }

  private static class InsertKeyAction extends TextAction {

    public InsertKeyAction() {
      super( "insert.key" );
    }

    public void actionPerformed( ActionEvent aoEvent ) {
      JComponent oComponent = getTextComponent( aoEvent );
      if( oComponent instanceof SyntaxTextPane ) {
        ((SyntaxTextPane)oComponent).toggleOverwrite();
        oComponent.repaint();
      }
    }

  }

  /**
  The delete action.
  */
  private static class DeleteAction extends TextAction {

    public DeleteAction() {
      super( "delete" );
    }

    public void actionPerformed( ActionEvent aoEvent ) {
      // Delete the current selection.
      JTextComponent oTextComponent = getTextComponent( aoEvent );
      int iDot = oTextComponent.getCaret().getDot();
      int iMark = oTextComponent.getCaret().getMark();

      try {
        oTextComponent.getDocument().remove( iDot, iMark - iDot );
      } catch( BadLocationException aoException ) {
        Log.write( Log.ERROR, aoException );
      }
    }

  }

  /**
  The indent action.
  */
  private static class IndentAction extends TextAction {

    public IndentAction() {
      super( "indent" );
    }

    public void actionPerformed( ActionEvent aoEvent ) {
      // Indent the current selection.
    }

  }

  /**
  The unindent action.
  */
  private static class UnindentAction extends TextAction {

    public UnindentAction() {
      super( "unindent" );
    }

    public void actionPerformed( ActionEvent aoEvent ) {
      // Unindent the current selection.
    }

  }

  /**
  The undo action.
  */
  private static class UndoAction extends TextAction {

    public UndoAction() {
      super( "undo" );
    }

    public void actionPerformed( ActionEvent aoEvent ) {
      JTextComponent oTextComponent = getTextComponent( aoEvent );
      UndoManager oUndoManager = (UndoManager)oTextComponent.getDocument().getProperty( "text.undo.manager" );
      if( oUndoManager != null ) oUndoManager.undo();
    }

  }

  /**
  The redo action.
  */
  private static class RedoAction extends TextAction {

    public RedoAction() {
      super( "redo" );
    }

    public void actionPerformed( ActionEvent aoEvent ) {
      JTextComponent oTextComponent = getTextComponent( aoEvent );
      UndoManager oUndoManager = (UndoManager)oTextComponent.getDocument().getProperty( "text.undo.manager" );
      if( oUndoManager != null ) oUndoManager.redo();
    }

  }

  /**
  A mouse listener to set the cursor back to a text cursor.
  */
  private static class MouseMotionHandler extends MouseMotionAdapter {

    public void mouseMoved( MouseEvent aoEvent ) {
      JTextComponent oComponent = (JTextComponent)aoEvent.getSource();
      if( oComponent.getCursor() != moTextCursor ) oComponent.setCursor( moTextCursor );
    }

  }

  /**
  The <code>Caret</code> for the <code>SyntaxTextPane</code>.
  */
  class EditorCaret extends DefaultCaret {

    /**
    The shown flag.  This is used to cause the caret to blink.
    */
    private boolean mbShown;

    /**
    The blinking flag.
    */
    private boolean mbBlinking;

    /**
    The delay in milliseconds the caret is shown in a blink cycle.
    */
    private int miBlinkOnDelay;

    /**
    The delay in milliseconds the caret is shown in a blink cycle.
    */
    private int miBlinkOffDelay;

    /**
    The blink cycle timer.
    */
    private Timer moBlinkTimer;

    /**
    The blink cycle off timer.
    */
    private Timer moBlinkOffTimer;

    /**
    The blink cycle handler.
    */
    //private BlinkHandler moBlinkHandler;

    /**
    The blink off handler.
    */
    //private BlinkOffHandler moBlinkOffHandler;

    /**
    The selection highlight painter.
    */
    Highlighter.HighlightPainter moSelectionPainter;

    /**
    The block caret painter.
    */
    Highlighter.HighlightPainter moBlockCaretPainter;

    //private long mlLastTick;

    /**
    Construct the caret.
    */
    public EditorCaret() {
      super();
      mbShown = true;
      moSelectionPainter = new SelectionHighlighter();
      moBlockCaretPainter = new BlockCaretHighlighter();

      // Set up the blinking facilities.
      moBlinkTimer = new Timer( 1000, new BlinkHandler() );
      moBlinkTimer.setInitialDelay( 0 );
      moBlinkOffTimer = new Timer( 500, new BlinkOffHandler() );
      moBlinkOffTimer.setInitialDelay( 500 );
      moBlinkOffTimer.setRepeats( false );

      startBlinking();
    }

    /**
    Called when the state of the caret has changed.
    */
    public void fireStateChanged() {
      updateHighlighters();
      super.fireStateChanged();
    }

    /**
    Get the selection highlighter.
    */
    public Highlighter.HighlightPainter getSelectionPainter() {
      return moSelectionPainter;
    }

    /**
    Ensure that the caret is visible.
    */
    public void adjustVisibility( Rectangle aoArea ) {
      doElectricScroll( aoArea );
    }

    /**
    Don't delete this method.  Save it for later.
    */
    public void focusGained( FocusEvent aoEvent ) {
      setSelectionVisible( true );

      if( !mbBlinking ) {
        mbShown = true;
        repaint();
      }
    }

    /**
    Don't delete this method.  Save it for later.
    */
    public void focusLost( FocusEvent aoEvent ) {
      if( !mbBlinking ) {
        mbShown = false;
        repaint();
      }
    }

    /**
    Start the blink timer.
    */
    protected void startBlinking() {
      if( miBlinkOnDelay <= 0 || miBlinkOffDelay <= 0 ) return;
      moBlinkTimer.restart();
      mbBlinking = true;
    }

    /**
    Stop the blink timer.
    */
    protected void stopBlinking() {
      mbBlinking = false;
      moBlinkTimer.stop();
      moBlinkOffTimer.stop();

      // Show the caret.
      mbShown = true;
      repaint();
    }

    /**
    Set the blinking flag.
    */
    public void setBlinking( boolean abBlinking ) {
      if( abBlinking ) {
        startBlinking();
      } else {
        stopBlinking();
      }
    }

    /**
    Is the caret blinking?
    */
    public boolean isBlinking() {
      return mbBlinking;
    }

    /**
    Override default <code>setBlinkRate()</code>.
    */
    public void setBlinkRate( int aiRate ) {
      setBlinkOnDelay( aiRate );
      setBlinkOffDelay( aiRate );
    }

    /**
    Override the default <code>getBlinkRate()</code> to keep the
    text component from running the blink cycle by returning 0.
    */
    public int getBlinkRate() {
      return 0;
    }

    /**
    Set the amout of time in milliseconds the caret is painted in a blink cycle.
    */
    public void setBlinkOnDelay( int aiDelay ) {
      stopBlinking();
      miBlinkOnDelay = aiDelay;
      moBlinkTimer.setDelay( miBlinkOnDelay + miBlinkOffDelay );
      moBlinkOffTimer.setInitialDelay( miBlinkOnDelay );
      moBlinkOffTimer.setDelay( miBlinkOnDelay );
      startBlinking();
    }

    /**
    Get the blink on delay.
    */
    public int getBlinkOnDelay() {
      return miBlinkOnDelay;
    }

    /**
    Set the amount of time in milliseconds the caret is not painted in a blink cycle.
    */
    public void setBlinkOffDelay( int aiDelay ) {
      stopBlinking();
      miBlinkOffDelay = aiDelay;
      moBlinkTimer.setDelay( miBlinkOnDelay + miBlinkOffDelay );
      startBlinking();
    }

    /**
    Get the blink off delay.
    */
    public int getBlinkOffDelay() {
      return miBlinkOffDelay;
    }

    protected void damage( Rectangle aoArea ) {
      if ( aoArea == null ) return;

      Rectangle oTextAreaBounds = SyntaxTextPane.this.getBounds();

      // Mark, this works correctly as is.  Don't break it.
      x = 0;
      y = aoArea.y;
      width = oTextAreaBounds.width;
      height = aoArea.height;
    }

    public void paint( Graphics aoGraphics ) {
      if( !mbShown & getComponent().hasFocus() ) return;

      Graphics2D oGraphics = (