Application: gvSIG desktop » gvSIG tools: Expression Field

package org.gvsig.expressionfield.project.documents.table.gui.syntaxhighlight;

import java.awt.event.ActionListener;

import java.awt.event.KeyListener;

import javax.swing.JScrollPane;

import javax.swing.text.JTextComponent;

public interface SyntaxtHighlightTextComponent {

	public interface UpdateCaretPositionActionEvent {

		public int getLine();

		public int getColumn();

		public boolean hasLineAndColumn();

	}

	public JTextComponent getJTextComponent();

	public JScrollPane getJScrollPane();

	public void setText(String text);

	public String getText();

	public void setContentType(String contentType);

	public String getContentType();

	public void addUpdateCaretPositionActionListener(ActionListener updateCaretPosition);

	public void addKeyListener(KeyListener keyListener);

}

package org.gvsig.expressionfield.project.documents.table.gui.syntaxhighlight;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyListener;

import javax.swing.JScrollPane;

import javax.swing.event.CaretEvent;

import javax.swing.event.CaretListener;

import javax.swing.text.JTextComponent;

import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;

import org.fife.ui.rsyntaxtextarea.SyntaxConstants;

import org.fife.ui.rtextarea.RTextScrollPane;

public class JRSyntaxTextArea implements SyntaxtHighlightTextComponent {

	public class DefaultUpdateCaretPositionActionEvent extends ActionEvent implements UpdateCaretPositionActionEvent {

		/**

		 * 

		 */

		private static final long serialVersionUID = 8238486105726094074L;

		int line = -1;

		int column = -1;

		public DefaultUpdateCaretPositionActionEvent(Object source, int id,

				String command, int line, int column) {

			super(source, id, command);

			this.line = line;

			this.column = column;

		}

		public int getLine() {

			return this.line+1;

		}

		public int getColumn() {

			return this.column;

		}

		public boolean hasLineAndColumn() {

			return this.line >=0 && this.column >= 0;

		}

	}

	protected ActionListener updateCaretPosition = null;

	protected RSyntaxTextArea textArea = null;

	public JRSyntaxTextArea() {

		this.textArea = new RSyntaxTextArea(20, 60);

		this.init();

	}

	protected void init() {

		textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_PYTHON);

		textArea.setCodeFoldingEnabled(true);

		textArea.setClearWhitespaceLinesEnabled(true);

		textArea.setAutoIndentEnabled(true);

		textArea.setCloseCurlyBraces(true);

		textArea.setWhitespaceVisible(true);

		textArea.setAnimateBracketMatching(true);

		textArea.setBracketMatchingEnabled(true);

		textArea.setAutoIndentEnabled(true);

		textArea.setTabsEmulated(true);

		textArea.setTabSize(2);

		textArea.setAntiAliasingEnabled(true);

		textArea.addCaretListener(new CaretListener() {

			public void caretUpdate(CaretEvent e) {

				if( updateCaretPosition== null ) {

					return;

				}

				updateCaretPosition.actionPerformed(

						new DefaultUpdateCaretPositionActionEvent(textArea, 1, "position", textArea.getCaretLineNumber(), textArea.getCaretOffsetFromLineStart() ) 

				);

			}

		});

	}

	public void setContentType(String contentType) {

		this.textArea.setSyntaxEditingStyle(contentType);

	}

	public JScrollPane getJScrollPane() {

		return  new RTextScrollPane(this.textArea);

	}

	public JTextComponent getJTextComponent() {

		return this.textArea;

	}

	public String getContentType() {

		return this.textArea.getSyntaxEditingStyle();

	}

	public void addUpdateCaretPositionActionListener(ActionListener updateCaretPosition) {

		this.updateCaretPosition = updateCaretPosition;  

	}

	public void setText(String text) {

		this.textArea.setText(text);

	}

	public String getText() {

		return this.textArea.getText();

	}

	public void addKeyListener(KeyListener keyListener) {

		this.textArea.addKeyListener(keyListener);

	}

}

package org.gvsig.expressionfield.project.documents.table.gui.syntaxhighlight.styles;

import java.awt.Color;

import java.util.HashSet;

import java.util.Set;

import javax.swing.text.AttributeSet;

import javax.swing.text.BadLocationException;

import javax.swing.text.DefaultEditorKit;

import javax.swing.text.DefaultStyledDocument;

import javax.swing.text.Element;

import javax.swing.text.MutableAttributeSet;

import javax.swing.text.SimpleAttributeSet;

import javax.swing.text.StyleConstants;

public class JavaStyledDocument extends DefaultStyledDocument {

	/**

	 * 

	 */

	private static final long serialVersionUID = 2859530660266127826L;

	private final DefaultStyledDocument doc;

	private final Element rootElement;

	private boolean multiLineComment;

	private final MutableAttributeSet normal;

	private final MutableAttributeSet keyword;

	private final MutableAttributeSet comment;

	private final MutableAttributeSet quote;

    private final Set<String> keywords;

	public JavaStyledDocument()

	{

		doc = this;

		rootElement = doc.getDefaultRootElement();

		putProperty( DefaultEditorKit.EndOfLineStringProperty, "\n" );

		normal = new SimpleAttributeSet();

		StyleConstants.setForeground(normal, Color.black);

		comment = new SimpleAttributeSet();

		StyleConstants.setForeground(comment, Color.gray);

		StyleConstants.setItalic(comment, true);

		keyword = new SimpleAttributeSet();

		StyleConstants.setForeground(keyword, Color.blue);

		quote = new SimpleAttributeSet();

		StyleConstants.setForeground(quote, Color.red);

        keywords = new HashSet<String>();

		keywords.add( "abstract" );

		keywords.add( "boolean" );

		keywords.add( "break" );

		keywords.add( "byte" );

		keywords.add( "byvalue" );

		keywords.add( "case" );

		keywords.add( "cast" );

		keywords.add( "catch" );

		keywords.add( "char" );

		keywords.add( "class" );

		keywords.add( "const" );

		keywords.add( "continue" );

		keywords.add( "default" );

		keywords.add( "do" );

		keywords.add( "double" );

		keywords.add( "else" );

		keywords.add( "extends" );

		keywords.add( "false" );

		keywords.add( "final" );

		keywords.add( "finally" );

		keywords.add( "float" );

		keywords.add( "for" );

		keywords.add( "future" );

		keywords.add( "generic" );

		keywords.add( "goto" );

		keywords.add( "if" );

		keywords.add( "implements" );

		keywords.add( "import" );

		keywords.add( "inner" );

		keywords.add( "instanceof" );

		keywords.add( "int" );

		keywords.add( "interface" );

		keywords.add( "long" );

		keywords.add( "native" );

		keywords.add( "new" );

		keywords.add( "null" );

		keywords.add( "operator" );

		keywords.add( "outer" );

		keywords.add( "package" );

		keywords.add( "private" );

		keywords.add( "protected" );

		keywords.add( "public" );

		keywords.add( "rest" );

		keywords.add( "return" );

		keywords.add( "short" );

		keywords.add( "static" );

		keywords.add( "super" );

		keywords.add( "switch" );

		keywords.add( "synchronized" );

		keywords.add( "this" );

		keywords.add( "throw" );

		keywords.add( "throws" );

		keywords.add( "transient" );

		keywords.add( "true" );

		keywords.add( "try" );

		keywords.add( "var" );

		keywords.add( "void" );

		keywords.add( "volatile" );

		keywords.add( "while" );

	}

	/*

	 *  Override to apply syntax highlighting after the document has been updated

	 */

	@Override

    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

	 */

	@Override

    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

	 */

	public 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'

	 *  (ie. matching end delimiter has not yet been encountered)

	 */

	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);

		//  check for single line comment

		int index = content.indexOf(getSingleLineDelimiter(), startOffset);

		if ( (index > -1) && (index < endOffset) )

		{

			doc.setCharacterAttributes(index, endOffset - index + 1, comment, false);

			endOffset = index - 1;

		}

		//  check for tokens

		checkForTokens(content, startOffset, endOffset);

	}

	/*

	 *  Does 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;

	}

	/*

	 *	Parse the line for tokens to highlight

	 */

	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);

		if ( isKeyword( token ) )

		{

			doc.setCharacterAttributes(startOffset, endOfToken - startOffset, keyword, false);

		}

		return endOfToken + 1;

	}

	/*

	 *  Assume the needle will the found at the start/end of the line

	 */

	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;

	}

	/*

	 *  Assume the needle will the found at the start/end of the line

	 */

	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);

	}

	/*

	 *  Override for other languages

	 */

	protected boolean isDelimiter(String character)

	{

		String operands = ";:{}()[]+-/%<=>!&|^~*";

		if (Character.isWhitespace( character.charAt(0) ) ||

			operands.indexOf(character) != -1 )

			return true;

		else

			return false;

	}

	/*

	 *  Override for other languages

	 */

	protected boolean isQuoteDelimiter(String character)

	{

		String quoteDelimiters = "\"'";

		if (quoteDelimiters.indexOf(character) < 0)

			return false;

		else

			return true;

	}

	/*

	 *  Override for other languages

	 */

	protected boolean isKeyword(String token)

	{

		return keywords.contains( token );

	}

	/*

	 *  Override for other languages

	 */

	protected String getStartDelimiter()

	{

		return "/*";

	}

	/*

	 *  Override for other languages

	 */

	protected String getEndDelimiter()

	{

		return "*/";

	}

	/*

	 *  Override for other languages

	 */

	protected String getSingleLineDelimiter()

	{

		return "//";

	}

	/*

	 *  Override for other languages

	 */

	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() + "\t\n" + whiteSpace.toString() + "}";

	}

}

package org.gvsig.expressionfield.project.documents.table.gui.syntaxhighlight.styles;

import java.awt.Color;

import java.util.HashSet;

import java.util.Set;

import javax.swing.text.AttributeSet;

import javax.swing.text.BadLocationException;

import javax.swing.text.DefaultEditorKit;

import javax.swing.text.DefaultStyledDocument;

import javax.swing.text.Element;

import javax.swing.text.MutableAttributeSet;

import javax.swing.text.SimpleAttributeSet;

import javax.swing.text.StyleConstants;

public class PythonStyledDocument extends DefaultStyledDocument {

    /**

     * 

     */

    private static final long serialVersionUID = 2859530660266127826L;

    private static int TABSIZE = 4;

    private final DefaultStyledDocument doc;

    private final Element rootElement;

    private boolean multiLineComment;

    private final MutableAttributeSet normal;

    private final MutableAttributeSet keyword1;

    private final MutableAttributeSet keyword2;

    private final MutableAttributeSet keyword3;

    private final MutableAttributeSet keyword4;

    private final MutableAttributeSet builtin;

    private final MutableAttributeSet comment;

    private final MutableAttributeSet quote;

    private final MutableAttributeSet identifiers;

    private final Set<String> keywords1;

    private final Set<String> keywords2;

    private final Set<String> keywords3;

    private final Set<String> keywords4;

    private final Set<String> builtins;

//    private int lineNumber;

    private int columnNumber;

    public PythonStyledDocument() {

        doc = this;

        rootElement = doc.getDefaultRootElement();

        putProperty(DefaultEditorKit.EndOfLineStringProperty, "\n");

        int fontSize = 14;

        normal = new SimpleAttributeSet();

        StyleConstants.setForeground(normal, Color.BLACK);

        StyleConstants.setFontFamily(normal, "monospaced");

        StyleConstants.setBold(normal, true);

        StyleConstants.setFontSize(normal, fontSize);

        comment = new SimpleAttributeSet();

        StyleConstants.setForeground(comment,Color.GRAY);

        StyleConstants.setItalic(comment, true);

        StyleConstants.setBold(comment, true);

        StyleConstants.setFontFamily(comment, "monospaced");

        StyleConstants.setFontSize(comment, fontSize);

        keyword1 = new SimpleAttributeSet();

        StyleConstants.setForeground(keyword1, Color.BLACK);

        StyleConstants.setFontFamily(keyword1, "monospaced");

        StyleConstants.setBold(keyword1, true);

        StyleConstants.setFontSize(keyword1, fontSize);

        keyword2 = new SimpleAttributeSet();

        StyleConstants.setForeground(keyword2, Color.CYAN);

        StyleConstants.setFontFamily(keyword2, "monospaced");

        StyleConstants.setBold(keyword2, false);

        StyleConstants.setFontSize(keyword2, fontSize);

        keyword3 = new SimpleAttributeSet();

        StyleConstants.setForeground(keyword3, Color.GREEN.darker());

        StyleConstants.setFontFamily(keyword3, "monospaced");

        StyleConstants.setBold(keyword3, false);

        StyleConstants.setFontSize(keyword3, fontSize);

        keyword4 = new SimpleAttributeSet();

        StyleConstants.setForeground(keyword4, Color.BLUE.darker());

        StyleConstants.setFontFamily(keyword4, "monospaced");

        StyleConstants.setBold(keyword4, true);

        StyleConstants.setFontSize(keyword4, fontSize);

        builtin = new SimpleAttributeSet();

        StyleConstants.setForeground(builtin, Color.RED.darker());

        StyleConstants.setFontFamily(builtin, "monospaced");

        StyleConstants.setBold(builtin, false);

        StyleConstants.setFontSize(builtin, fontSize);

        identifiers = new SimpleAttributeSet();

        StyleConstants.setForeground(identifiers, Color.BLACK);

        StyleConstants.setFontFamily(identifiers, "monospaced");

        StyleConstants.setBold(identifiers, false);

        StyleConstants.setFontSize(identifiers, fontSize);

        quote = new SimpleAttributeSet();

        StyleConstants.setForeground(quote,  Color.RED.darker());

        StyleConstants.setFontFamily(quote, "monospaced");

        StyleConstants.setBold(quote, true);

        StyleConstants.setFontSize(quote, fontSize);

        keywords1 = new HashSet<String>();

        keywords1.add("except");

        keywords1.add("class");

        keywords1.add("continue");

        keywords1.add("else");

        keywords1.add("finally");

        keywords1.add("if");

        keywords1.add("elif");

        keywords1.add("in");

        keywords1.add("return");

        keywords1.add("raise");

        keywords1.add("try");

        keywords1.add("while");

        keywords1.add("def");

        keywords1.add("print");

        keywords1.add("globals");

        keywords1.add("for");

        keywords1.add("pass");

        keywords2 = new HashSet<String>();

        keywords2.add("from");

        keywords2.add("import");

        keywords3 = new HashSet<String>();

        keywords3.add("True");

        keywords3.add("False");

        keywords3.add("None");

        keywords3.add("self");

        keywords4 = new HashSet<String>();

        keywords4.add("__init__");

        keywords4.add("__len__");

        keywords4.add("__str__");

        keywords4.add("__repr__");

        keywords4.add("__call__");

        keywords4.add("__iter__");

        keywords4.add("__class__");

        keywords4.add("__getattr__");

        keywords4.add("__setattr__");

        keywords4.add("__delattr__");

        keywords4.add("__getitem__");

        keywords4.add("__setitem__");

        keywords4.add("__delitem__");

        keywords4.add("__getslice__");

        keywords4.add("__setslice__");

        keywords4.add("__delslice__");

        keywords4.add("__getattribute__");

        keywords4.add("__setattribute__");

        keywords4.add("__contains__");

        keywords4.add("__reduce__");

        keywords4.add("__cmp__");

        keywords4.add("__eq__");

        keywords4.add("__ne__");

        keywords4.add("__lt__");

        keywords4.add("__le__");

        keywords4.add("__gt__");

        keywords4.add("__ge__");

        keywords4.add("__mul__");

        keywords4.add("__imul__");

        keywords4.add("__rmul__");

        keywords4.add("__add__");

        keywords4.add("__iadd__");

        keywords4.add("__radd__");

        keywords4.add("__mod__");

        keywords4.add("__rmod__");

        builtins = new HashSet<String>();

        builtins.add("int");

        builtins.add("unicode");

        builtins.add("str");

        builtins.add("float");

        builtins.add("long");

        builtins.add("list");

        builtins.add("tuple");

        builtins.add("dict");

        builtins.add("iter");

        builtins.add("vars");

        builtins.add("isinstance");

        builtins.add("dir");

        builtins.add("repr");

        builtins.add("reduce");

        builtins.add("zip");

        builtins.add("chr");

        builtins.add("hex");

        builtins.add("id");

        builtins.add("max");

        builtins.add("min");

        builtins.add("oct");

        builtins.add("pow");

        builtins.add("ord");

        builtins.add("unichr");

        builtins.add("range");

        builtins.add("xrange");

        builtins.add("abs");

        builtins.add("len");

        builtins.add("apply");

        builtins.add("open");

        builtins.add("getattr");

        builtins.add("setattr");

        builtins.add("hasattr");

    }

    /*

     * Override to apply syntax highlighting after the document has been updated

     */

    @Override

    public void insertString(int offset, String str, AttributeSet a)

            throws BadLocationException {

        super.insertString(offset, processTab(offset, str, a), a);

        processChangedLines(offset, str.length());

    }

    public void setPosition(int lineNumber, int columnNumber) {

//        this.lineNumber= lineNumber;

        this.columnNumber= columnNumber; 

    }

    private String processTab(int offset, String str, AttributeSet a ) {

        if( !"\t".equals(str)) {

            return str;

        }

        try {

            int numberOfSpacesToInsert = (TABSIZE -((this.columnNumber -1)%TABSIZE));

            str = "                                                   ".substring(0, numberOfSpacesToInsert);

        } catch (Exception e) {

            return  "                    ".substring(0, TABSIZE);

        }

        return str; 

    }

    /*

     * Override to apply syntax highlighting after the document has been updated

     */

    @Override

    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

     */

    public 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' (ie. matching

     * end delimiter has not yet been encountered)

     */

    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);

        // check for single line comment

        int index = content.indexOf(getSingleLineDelimiter(), startOffset);

        if ((index > -1) && (index < endOffset)) {

            doc.setCharacterAttributes(index, endOffset - index + 1, comment,

                    false);

            endOffset = index - 1;

        }

        // check for tokens

        checkForTokens(content, startOffset, endOffset);

    }

    /*

     * Does 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;

    }

    /*

     * Parse the line for tokens to highlight

     */

    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);

        if (isKeyword(token)) {

            doc.setCharacterAttributes(startOffset, endOfToken - startOffset,

                    keyword1, false);

        } else if ( keywords2.contains(token) ) {

            doc.setCharacterAttributes(startOffset, endOfToken - startOffset,

                    keyword2, false);

        } else if ( keywords3.contains(token) ) {

            doc.setCharacterAttributes(startOffset, endOfToken - startOffset,

                    keyword3, false);

        } else if ( keywords4.contains(token) ) {

            doc.setCharacterAttributes(startOffset, endOfToken - startOffset,

                    keyword4, false);

        } else if (isBuiltin(token)) {

            doc.setCharacterAttributes(startOffset, endOfToken - startOffset,

                builtin, false);

        } else if (isIdentifier(token)) {

            doc.setCharacterAttributes(startOffset, endOfToken - startOffset,

                identifiers, false);

        }

        return endOfToken + 1;

    }

    private boolean isIdentifier(String token) {

        return token.matches("[A-Za-z_][A-Za-z0-9_]*");

    }

    /*

     * Assume the needle will the found at the start/end of the line

     */

    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;

    }

    /*

     * Assume the needle will the found at the start/end of the line

     */

    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);

    }

    /*

     * Override for other languages

     */

    protected boolean isDelimiter(String character) {

        String operands = ";:()[]+-/%<=>!&|^~*.,";

        if (Character.isWhitespace(character.charAt(0))

                || operands.indexOf(character) != -1)

            return true;

        else

            return false;

    }

    /*

     * Override for other languages

     */

    protected boolean isQuoteDelimiter(String character) {

        String quoteDelimiters = "\"'";

        if (quoteDelimiters.indexOf(character) < 0)

            return false;

        else

            return true;

    }

    /*

     * Override for other languages

     */

    protected boolean isKeyword(String token) {

        return keywords1.contains(token);

    }

    protected boolean isBuiltin(String token) {

        return builtins.contains(token);

    }

    /*

     * Override for other languages

     */

    protected String getStartDelimiter() {

        return "\"\"\"";

    }

    /*

     * Override for other languages

     */

    protected String getEndDelimiter() {

        return "\"\"\"";

    }

    /*

     * Override for other languages

     */

    protected String getSingleLineDelimiter() {

        return "#";

    }

    /*

     * Override for other languages

     */

    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() + "\t\n" + whiteSpace.toString()

                + "}";

    }

     */

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.expressionfield.project.documents.table.gui;

/**

 *

 * @author jjdelcerro

 */

public class AdvancedPanelLayout extends javax.swing.JPanel {

    /**

     * Creates new form AdvancedPanel

     */

    public AdvancedPanelLayout() {

        initComponents();

    }

    /**

     * This method is called from within the constructor to initialize the form.

     * WARNING: Do NOT modify this code. The content of this method is always

     * regenerated by the Form Editor.

     */

    @SuppressWarnings("unchecked")

    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents

    private void initComponents() {

        java.awt.GridBagConstraints gridBagConstraints;

        filler2 = new javax.swing.Box.Filler(new java.awt.Dimension(4, 4), new java.awt.Dimension(4, 4), new java.awt.Dimension(4, 4));

        butLoad = new javax.swing.JButton();

        butSave = new javax.swing.JButton();

        butTest = new javax.swing.JButton();

        filler3 = new javax.swing.Box.Filler(new java.awt.Dimension(0, 0), new java.awt.Dimension(0, 0), new java.awt.Dimension(32767, 0));

        filler4 = new javax.swing.Box.Filler(new java.awt.Dimension(4, 4), new java.awt.Dimension(4, 4), new java.awt.Dimension(4, 4));

        editorContainer = new javax.swing.JPanel();

        java.awt.GridBagLayout layout = new java.awt.GridBagLayout();

        layout.columnWidths = new int[] {0, 5, 0, 5, 0, 5, 0, 5, 0, 5, 0};

        layout.rowHeights = new int[] {0, 5, 0, 5, 0, 5, 0};