// Filename: SyntaxDocument.java
// http://forums.sun.com/thread.jspa?threadID=743407&messageID=9497681
// http://www.dound.com/src/MultiSyntaxDocument.java
/**
* (C) camickr (primary author; java sun forums user)
* (C) David Underhill
* (C) 2009 University of Waikato, Hamilton, New Zealand
*/
package weka.gui.scripting;
import weka.gui.visualize.VisualizeUtils;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Toolkit;
import java.util.HashMap;
import java.util.Properties;
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;
import javax.swing.text.TabSet;
import javax.swing.text.TabStop;
/**
* Highlights syntax in a DefaultStyledDocument. Allows any number of keywords
* to be formatted in any number of user-defined styles.
*
* @author camickr (primary author; java sun forums user)
* @author David Underhill
* @author FracPete (fracpete at waikato dot ac dot nz) - use of a properties file to setup syntax highlighting instead of hard-coded
*/
public class SyntaxDocument
extends DefaultStyledDocument {
/** for serialization. */
protected static final long serialVersionUID = -3642426465631271381L;
/** the maximum number of tabs. */
public static final int MAX_TABS = 35;
/** the font family. */
public static final String DEFAULT_FONT_FAMILY = "monospaced";
/** the font size. */
public static final int DEFAULT_FONT_SIZE = 12;
/** the attribute set for normal code. */
public static final SimpleAttributeSet DEFAULT_NORMAL;
/** the attribute set for comments. */
public static final SimpleAttributeSet DEFAULT_COMMENT;
/** the attribute set for strings. */
public static final SimpleAttributeSet DEFAULT_STRING;
/** the attribute set for keywords. */
public static final SimpleAttributeSet DEFAULT_KEYWORD;
static {
DEFAULT_NORMAL = new SimpleAttributeSet();
StyleConstants.setForeground(DEFAULT_NORMAL, Color.BLACK);
StyleConstants.setFontFamily(DEFAULT_NORMAL, DEFAULT_FONT_FAMILY);
StyleConstants.setFontSize(DEFAULT_NORMAL, DEFAULT_FONT_SIZE);
DEFAULT_COMMENT = new SimpleAttributeSet();
StyleConstants.setForeground(DEFAULT_COMMENT, Color.GRAY);
StyleConstants.setFontFamily(DEFAULT_COMMENT, DEFAULT_FONT_FAMILY);
StyleConstants.setFontSize(DEFAULT_COMMENT, DEFAULT_FONT_SIZE);
DEFAULT_STRING = new SimpleAttributeSet();
StyleConstants.setForeground(DEFAULT_STRING, Color.RED);
StyleConstants.setFontFamily(DEFAULT_STRING, DEFAULT_FONT_FAMILY);
StyleConstants.setFontSize(DEFAULT_STRING, DEFAULT_FONT_SIZE);
// default style for new keyword types
DEFAULT_KEYWORD = new SimpleAttributeSet();
StyleConstants.setForeground(DEFAULT_KEYWORD, Color.BLUE);
StyleConstants.setBold(DEFAULT_KEYWORD, false);
StyleConstants.setFontFamily(DEFAULT_KEYWORD, DEFAULT_FONT_FAMILY);
StyleConstants.setFontSize(DEFAULT_KEYWORD, DEFAULT_FONT_SIZE);
}
/**
* The attribute type.
*/
public enum ATTR_TYPE {
/** normal string. */
Normal,
/** a comment. */
Comment,
/** a quoted string. */
Quote;
}
/** the document. */
protected DefaultStyledDocument m_Self;
/** the root element. */
protected Element m_RootElement;
/** whether we're currently in a multi-line comment. */
protected boolean m_InsideMultiLineComment;
/** the keywords. */
protected HashMap<String, MutableAttributeSet> m_Keywords;
/** the delimiters. */
protected String m_Delimiters;
/** the quote delimiter. */
protected String m_QuoteDelimiters;
/** the quote escape. */
protected String m_QuoteEscape;
/** the multi-line comment start. */
protected String m_MultiLineCommentStart;
/** the multi-line comment end. */
protected String m_MultiLineCommentEnd;
/** the single-line comment start. */
protected String m_SingleLineCommentStart;
/** the start of a block. */
protected String m_BlockStart;
/** the end of a block. */
protected String m_BlockEnd;
/** the font size. */
protected int m_FontSize;
/** the font name. */
protected String m_FontName;
/** the background color. */
protected Color m_BackgroundColor;
/** the number of spaces used for indentation. */
protected String m_Indentation;
/** whether to add matching brackets. */
protected boolean m_AddMatchingEndBlocks;
/** whether to use blanks instead of tabs. */
protected boolean m_UseBlanks;
/** whether multi-line comments are enabled. */
protected boolean m_MultiLineComment;
/** whether keywords are case-sensitive. */
protected boolean m_CaseSensitive;
/**
* Initializes the document.
*
* @param props the properties to obtain the setup from
*/
public SyntaxDocument(Properties props) {
m_Self = this;
m_RootElement = m_Self.getDefaultRootElement();
m_Keywords = new HashMap<String, MutableAttributeSet>();
m_FontSize = DEFAULT_FONT_SIZE;
m_FontName = DEFAULT_FONT_FAMILY;
putProperty(DefaultEditorKit.EndOfLineStringProperty, "\n");
setup(props);
}
/**
* Sets up the document according to the properties.
*
* @param props the properties to use
*/
protected void setup(Properties props) {
setDelimiters(props.getProperty("Delimiters", ";:{}()[]+-/%<=>!&|^~*"));
setQuoteDelimiters(props.getProperty("QuoteDelimiters", "\"\'"));
setQuoteEscape(props.getProperty("QuoteEscape", "\\"));
setSingleLineCommentStart(props.getProperty("SingleLineCommentStart", "//"));
setMultiLineComment(props.getProperty("MultiLineComment", "false").equals("true"));
setMultiLineCommentStart(props.getProperty("MultiLineCommentStart", "/*"));
setMultiLineCommentEnd(props.getProperty("MultiLineCommentEnd", "*/"));
setBlockStart(props.getProperty("BlockStart", "{"));
setBlockEnd(props.getProperty("BlockEnd", "}"));
setAddMatchingEndBlocks(props.getProperty("AddMatchingBlockEnd", "false").equals("true"));
setUseBlanks(props.getProperty("UseBlanks", "false").equals("true"));
setCaseSensitive(props.getProperty("CaseSensitive", "true").equals("true"));
addKeywords(props.getProperty("Keywords", "").trim().replaceAll(" ", "").split(","), DEFAULT_KEYWORD);
setTabs(Integer.parseInt(props.getProperty("Tabs", "2")));
setAttributeColor(DEFAULT_NORMAL, VisualizeUtils.processColour(props.getProperty("ForegroundColor", "black"), Color.BLACK));
setAttributeColor(DEFAULT_COMMENT, VisualizeUtils.processColour(props.getProperty("CommentColor", "gray"), Color.GRAY));
setAttributeColor(DEFAULT_STRING, VisualizeUtils.processColour(props.getProperty("StringColor", "red"), Color.RED));
setAttributeColor(DEFAULT_KEYWORD, VisualizeUtils.processColour(props.getProperty("KeywordColor", "blue"), Color.BLUE));
setBackgroundColor(VisualizeUtils.processColour(props.getProperty("BackgroundColor", "white"), Color.WHITE));
setFontName(props.getProperty("FontName", "monospaced"));
setFontSize(Integer.parseInt(props.getProperty("FontSize", "12")));
setIndentationSize(Integer.parseInt(props.getProperty("Indentation", "2")));
}
/**
* Sets the font of the specified attribute.
*
* @param attr
* the attribute to apply this font to (normal, comment, string)
* @param style
* font style (Font.BOLD, Font.ITALIC, Font.PLAIN)
*/
public void setAttributeFont(ATTR_TYPE attr, int style) {
Font f = new Font(m_FontName, style, m_FontSize);
if (attr == ATTR_TYPE.Comment)
setAttributeFont(DEFAULT_COMMENT, f);
else if (attr == ATTR_TYPE.Quote)
setAttributeFont(DEFAULT_STRING, f);
else
setAttributeFont(DEFAULT_NORMAL, f);
}
/**
* Sets the font of the specified attribute.
*
* @param attr
* attribute to apply this font to
* @param f
* the font to use
*/
public static void setAttributeFont(MutableAttributeSet attr, Font f) {
StyleConstants.setBold(attr, f.isBold());
StyleConstants.setItalic(attr, f.isItalic());
StyleConstants.setFontFamily(attr, f.getFamily());
StyleConstants.setFontSize(attr, f.getSize());
}
/**
* Sets the foreground (font) color of the specified attribute.
*
* @param attr
* the attribute to apply this font to (normal, comment, string)
* @param c
* the color to use
*/
public void setAttributeColor(ATTR_TYPE attr, Color c) {
if (attr == ATTR_TYPE.Comment)
setAttributeColor(DEFAULT_COMMENT, c);
else if (attr == ATTR_TYPE.Quote)
setAttributeColor(DEFAULT_STRING, c);
else
setAttributeColor(DEFAULT_NORMAL, c);
}
/**
* Sets the foreground (font) color of the specified attribute.
*
* @param attr
* attribute to apply this color to
* @param c
* the color to use
*/
public static void setAttributeColor(MutableAttributeSet attr, Color c) {
StyleConstants.setForeground(attr, c);
}
/**
* Associates the keywords with a particular formatting style.
*
* @param keywords
* the tokens or words to format
* @param attr
* how to format the keywords
*/
public void addKeywords(String[] keywords, MutableAttributeSet attr) {
int i;
for (i = 0; i < keywords.length; i++)
addKeyword(keywords[i], attr);
}
/**
* Associates a keyword with a particular formatting style.
*
* @param keyword
* the token or word to format
* @param attr
* how to format keyword
*/
public void addKeyword(String keyword, MutableAttributeSet attr) {
if (m_CaseSensitive)
m_Keywords.put(keyword, attr);
else
m_Keywords.put(keyword.toLowerCase(), attr);
}
/**
* Gets the formatting for a keyword.
*
* @param keyword
* the token or word to stop formatting
*
* @return how keyword is formatted, or null if no formatting is applied to it
*/
public MutableAttributeSet getKeywordFormatting(String keyword) {
if (m_CaseSensitive)
return m_Keywords.get(keyword);
else
return m_Keywords.get(keyword.toLowerCase());
}
/**
* Removes an association between a keyword with a particular formatting style.
*
* @param keyword
* the token or word to stop formatting
*/
public void removeKeyword(String keyword) {
if (m_CaseSensitive)
m_Keywords.remove(keyword);
else
m_Keywords.remove(keyword.toLowerCase());
}
/**
* sets the number of characters per tab.
*
* @param charactersPerTab
* the characters per tab
*/
public void setTabs(int charactersPerTab) {
Font f = new Font(m_FontName, Font.PLAIN, m_FontSize);
FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(f);
int charWidth = fm.charWidth('w');
int tabWidth = charWidth * charactersPerTab;
TabStop[] tabs = new TabStop[MAX_TABS];
for (int j = 0; j < tabs.length; j++)
tabs[j] = new TabStop((j+1) * tabWidth);
TabSet tabSet = new TabSet(tabs);
SimpleAttributeSet attributes = new SimpleAttributeSet();
StyleConstants.setTabSet(attributes, tabSet);
int length = getLength();
setParagraphAttributes(0, length, attributes, false);
}
/**
* Override to apply syntax highlighting after the document has been updated.
*
* @param offset
* the offset
* @param str
* the string to insert
* @param a
* the attribute set, can be null
* @throws BadLocationException
* if offset is invalid
*/
public void insertString(int offset, String str, AttributeSet a)
throws BadLocationException {
if (m_AddMatchingEndBlocks && (m_BlockStart.length() > 0) && str.equals(m_BlockStart))
str = addMatchingBlockEnd(offset);
else if (m_UseBlanks && str.equals("\t"))
str = m_Indentation;
super.insertString(offset, str, a);
processChangedLines(offset, str.length());
}
/**
* Applies syntax highlighting after the document has been updated.
*
* @param offset
* the offset of the deletion
* @param length
* the length of the deletion
* @throws BadLocationException
* if offsets are invalid
*/
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.
*
* @param offset
* the offset of the changed lines
* @param length
* the length of the change
* @throws BadLocationException
* if offset is invalid
*/
public void processChangedLines(int offset, int length)
throws BadLocationException {
String content = m_Self.getText(0, m_Self.getLength());
// The lines affected by the latest document update
int startLine = m_RootElement.getElementIndex(offset);
int endLine = m_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
if (getMultiLineComment())
setInsideMultiLineComment(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).
*
* @param content
* the content to check
* @param line
* the line number
* @return
* true if there are comment lines before
*/
protected boolean commentLinesBefore(String content, int line) {
int offset = m_RootElement.getElement(line).getStartOffset();
// Start of comment not found, nothing to do
int startDelimiter = -1;
if (getMultiLineComment())
startDelimiter = lastIndexOf(content, getMultiLineCommentStart(), offset - 2);
if (startDelimiter < 0)
return false;
// Matching start/end of comment found, nothing to do
int endDelimiter = indexOf(content, getMultiLineCommentEnd(), startDelimiter);
if (endDelimiter < offset & endDelimiter != -1)
return false;
// End of comment not found, highlight the lines
m_Self.setCharacterAttributes(startDelimiter, offset - startDelimiter + 1,
DEFAULT_COMMENT, false);
return true;
}
/**
* Highlight comment lines to matching end delimiter.
*
* @param content
* the content to parse
* @param line
* the line number
*/
protected void commentLinesAfter(String content, int line) {
int offset = m_RootElement.getElement(line).getEndOffset();
// End of comment not found, nothing to do
int endDelimiter = -1;
if (getMultiLineComment())
endDelimiter = indexOf(content, getMultiLineCommentEnd(), offset);
if (endDelimiter < 0)
return;
// Matching start/end of comment found, comment the lines
int startDelimiter = lastIndexOf(content, getMultiLineCommentStart(), endDelimiter);
if (startDelimiter < 0 || startDelimiter <= offset) {
m_Self.setCharacterAttributes(offset, endDelimiter - offset + 1, DEFAULT_COMMENT,
false);
}
}
/**
* Highlight lines to start or end delimiter.
*
* @param content
* the content to parse
* @param line
* the line number
* @throws BadLocationException
* if offsets are wrong
*/
protected void highlightLinesAfter(String content, int line)
throws BadLocationException {
int offset = m_RootElement.getElement(line).getEndOffset();
// Start/End delimiter not found, nothing to do
int startDelimiter = -1;
int endDelimiter = -1;
if (getMultiLineComment()) {
startDelimiter = indexOf(content, getMultiLineCommentStart(), offset);
endDelimiter = indexOf(content, getMultiLineCommentEnd(), 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 = m_RootElement.getElementIndex(delimiter);
for (int i = line + 1; i < endLine; i++) {
Element branch = m_RootElement.getElement(i);
Element leaf = m_Self.getCharacterElement(branch.getStartOffset());
AttributeSet as = leaf.getAttributes();
if (as.isEqual(DEFAULT_COMMENT))
applyHighlighting(content, i);
}
}
/**
* Parse the line to determine the appropriate highlighting.
*
* @param content
* the content to parse
* @param line
* the line number
* @throws BadLocationException
* if offsets are invalid
*/
protected void applyHighlighting(String content, int line)
throws BadLocationException {
int startOffset = m_RootElement.getElement(line).getStartOffset();
int endOffset = m_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 (getMultiLineComment()) {
if (endingMultiLineComment(content, startOffset, endOffset)
|| isMultiLineComment()
|| startingMultiLineComment(content, startOffset, endOffset)) {
m_Self.setCharacterAttributes(startOffset, endOffset - startOffset + 1,
DEFAULT_COMMENT, false);
return;
}
}
// set normal attributes for the line
m_Self.setCharacterAttributes(startOffset, lineLength, DEFAULT_NORMAL, true);
// check for single line comment
int index = content.indexOf(getSingleLineCommentStart(), startOffset);
if ((index > -1) && (index < endOffset)) {
m_Self.setCharacterAttributes(index, endOffset - index + 1, DEFAULT_COMMENT, false);
endOffset = index - 1;
}
// check for tokens
checkForTokens(content, startOffset, endOffset);
}
/**
* Does this line contain the start of a multi-line comment.
*
* @param content
* the content to search
* @param startOffset
* the start of the search
* @param endOffset
* the end of the search
* @return
* true if it contains the start delimiter
* @throws BadLocationException
* if offsets are invalid
*/
protected boolean startingMultiLineComment(String content, int startOffset,
int endOffset) throws BadLocationException {
if (!getMultiLineComment())
return false;
int index = indexOf(content, getMultiLineCommentStart(), startOffset);
if ((index < 0) || (index > endOffset))
return false;
else {
setInsideMultiLineComment(true);
return true;
}
}
/**
* Does this line contain the end delimiter of a multi-line comment.
*
* @param content
* the content to search
* @param startOffset
* the start of the search
* @param endOffset
* the end of the search
* @return
* true if the line contains the end delimiter
* @throws BadLocationException
* if offsets are invalid
*/
protected boolean endingMultiLineComment(String content, int startOffset,
int endOffset) throws BadLocationException {
if (!getMultiLineComment())
return false;
int index = indexOf(content, getMultiLineCommentEnd(), startOffset);
if ((index < 0) || (index > endOffset))
return false;
else {
setInsideMultiLineComment(false);
return true;
}
}
/**
* We have found a start delimiter and are still searching for the end
* delimiter.
*
* @return
* true if currently within a multi-line comment
*/
protected boolean isMultiLineComment() {
return m_InsideMultiLineComment;
}
/**
* Sets whether we're currently within a multi-line comment or not.
*
* @param value
* true if currently within a multi-line comment
*/
protected void setInsideMultiLineComment(boolean value) {
m_InsideMultiLineComment = value;
}
/**
* Parse the line for tokens to highlight.
*
* @param content
* the content to parse
* @param startOffset
* the start position
* @param endOffset
* the end position
*/
protected 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);
}
}
/**
* Searches for a quote token.
*
* @param content
* the content to search
* @param startOffset
* the start of the search
* @param endOffset
* the end of the search
* @return
* the new position
*/
protected int getQuoteToken(String content, int startOffset, int endOffset) {
String quoteDelimiter = content.substring(startOffset, startOffset + 1);
String escapeString = escapeQuote(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;
m_Self.setCharacterAttributes(startOffset, endOfQuote - startOffset + 1,
DEFAULT_STRING, false);
return endOfQuote + 1;
}
/**
* Searches for a keyword token.
*
* @param content
* the content to search in
* @param startOffset
* the position to start the search fromm
* @param endOffset
* the position to end the search
* @return
* the new position
*/
protected 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);
// see if this token has a highlighting format associated with it
MutableAttributeSet attr = getKeywordFormatting(token);
if (attr != null)
m_Self.setCharacterAttributes(startOffset, endOfToken - startOffset, attr, false);
return endOfToken + 1;
}
/**
* Assume the needle will the found at the start/end of the line.
*
* @param content
* the content to search
* @param needle
* the string to look for
* @param offset
* the offset to start at
* @return
* the index
*/
protected 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.
*
* @param content
* the content search
* @param needle
* what to look for
* @param offset
* the offset to start
* @return
* the index
*/
protected 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;
}
/**
* Returns the line.
*
* @param content
* the content
* @param offset
* the offset to start at
* @return
* the line
*/
protected String getLine(String content, int offset) {
int line = m_RootElement.getElementIndex(offset);
Element lineElement = m_RootElement.getElement(line);
int start = lineElement.getStartOffset();
int end = lineElement.getEndOffset();
return content.substring(start, end - 1);
}
/**
* Checks whether the character is a delimiter.
*
* @param character
* the character to check
* @return
* true if a delimiter
*/
public boolean isDelimiter(String character) {
return Character.isWhitespace(character.charAt(0)) || (m_Delimiters.indexOf(character.charAt(0)) > -1);
}
/**
* Checks whether the character is quote delimiter.
*
* @param character
* the character to check
* @return
* true if a quote delimiter
*/
public boolean isQuoteDelimiter(String character) {
return (m_QuoteDelimiters.indexOf(character.charAt(0)) > -1);
}
/**
* Escapes the quote delimiter.
*
* @param quoteDelimiter
* the string to escape
* @return
* the escaped string
*/
public String escapeQuote(String quoteDelimiter) {
return m_QuoteEscape + quoteDelimiter;
}
/**
* Adds the matching block end.
*
* @param offset
* the offset
* @return
* the string after adding the matching block end
* @throws BadLocationException
* if the offset is invalid
*/
protected String addMatchingBlockEnd(int offset) throws BadLocationException {
StringBuffer result;
StringBuffer whiteSpace = new StringBuffer();
int line = m_RootElement.getElementIndex(offset);
int i = m_RootElement.getElement(line).getStartOffset();
while (true) {
String temp = m_Self.getText(i, 1);
if (temp.equals(" ") || temp.equals("\t")) {
whiteSpace.append(temp);
i++;
}
else {
break;
}
}
// assemble string
result = new StringBuffer();
result.append(m_BlockStart);
result.append("\n");
result.append(whiteSpace.toString());
if (m_UseBlanks)
result.append(m_Indentation);
else
result.append("\t");
result.append("\n");
result.append(whiteSpace.toString());
result.append(m_BlockEnd);
return result.toString();
}
/**
* gets the current font size.
*
* @return
* the font size
*/
public int getFontSize() {
return m_FontSize;
}
/**
* sets the current font size (affects all built-in styles).
*
* @param fontSize
* the size
*/
public void setFontSize(int fontSize) {
m_FontSize = fontSize;
StyleConstants.setFontSize(DEFAULT_NORMAL, fontSize);
StyleConstants.setFontSize(DEFAULT_STRING, fontSize);
StyleConstants.setFontSize(DEFAULT_COMMENT, fontSize);
}
/**
* gets the current font family.
*
* @return
* the font name
*/
public String getFontName() {
return m_FontName;
}
/**
* sets the current font family (affects all built-in styles).
*
* @param fontName
* the font name
*/
public void setFontName(String fontName) {
m_FontName = fontName;
StyleConstants.setFontFamily(DEFAULT_NORMAL, fontName);
StyleConstants.setFontFamily(DEFAULT_STRING, fontName);
StyleConstants.setFontFamily(DEFAULT_COMMENT, fontName);
}
/**
* Sets the number of blanks to use for indentation.
*
* @param value
* the number of blanks
*/
public void setIndentationSize(int value) {
int i;
m_Indentation = "";
for (i = 0; i < value; i++)
m_Indentation += " ";
}
/**
* Returns the number of blanks used for indentation.
*
* @return
* the number of blanks
*/
public int getIndentationSize() {
return m_Indentation.length();
}
/**
* Sets the delimiter characters to use.
*
* @param value
* the characters
*/
public void setDelimiters(String value) {
m_Delimiters = value;
}
/**
* Returns the delimiter characters to use.
*
* @return
* the characters
*/
public String getDelimiters() {
return m_Delimiters;
}
/**
* Sets the quote delimiter characters to use.
*
* @param value
* the characters
*/
public void setQuoteDelimiters(String value) {
m_QuoteDelimiters = value;
}
/**
* Returns the quote delimiter characters to use.
*
* @return
* the characters
*/
public String getQuoteDelimiters() {
return m_QuoteDelimiters;
}
/**
* Sets the character to use for escaping a quote character.
*
* @param value
* the character
*/
public void setQuoteEscape(String value) {
m_QuoteEscape = value;
}
/**
* Returns the character for escaping a quote delimiter.
*
* @return
* the character
*/
public String getQuoteEscape() {
return m_QuoteEscape;
}
/**
* Sets the string that is the start of a single-line comment.
*
* @param value
* the string
*/
public void setSingleLineCommentStart(String value) {
m_SingleLineCommentStart = value;
}
/**
* Retrusn the single line comment start string.
*
* @return
* the start string
*/
public String getSingleLineCommentStart() {
return m_SingleLineCommentStart;
}
/**
* Sets the string that is the start of a multi-line comment.
*
* @param value
* the string
*/
public void setMultiLineCommentStart(String value) {
m_MultiLineCommentStart = value;
}
/**
* Returns the string that is the start of a multi-line comment.
*
* @return
* the string
*/
public String getMultiLineCommentStart() {
return m_MultiLineCommentStart;
}
/**
* Sets the string that is the end of a multi-line comment.
*
* @param value the string
*/
public void setMultiLineCommentEnd(String value) {
m_MultiLineCommentEnd = value;
}
/**
* Returns the end of a multi-line comment.
*
* @return
* the end string
*/
public String getMultiLineCommentEnd() {
return m_MultiLineCommentEnd;
}
/**
* Sets the string that is the start of a block.
*
* @param value
* the string
*/
public void setBlockStart(String value) {
m_BlockStart = value;
}
/**
* Returns the start of a block.
*
* @return
* the end string
*/
public String getBlockStart() {
return m_BlockStart;
}
/**
* Sets the string that is the end of a block.
*
* @param value
* the string
*/
public void setBlockEnd(String value) {
m_BlockEnd = value;
}
/**
* Returns the end of a block.
*
* @return
* the end string
*/
public String getBlockEnd() {
return m_BlockEnd;
}
/**
* Sets whether matching block ends are inserted or not.
*
* @param value
* if true then matching block ends are inserted
*/
public void setAddMatchingEndBlocks(boolean value) {
m_AddMatchingEndBlocks = value;
}
/**
* Returns whether matching block ends are inserted or not.
*
* @return
* true if matching block ends are inserted
*/
public boolean getAddMatchingEndBlocks() {
return m_AddMatchingEndBlocks;
}
/**
* Sets whether to use blanks instead of tabs.
*
* @param value
* if true then blanks are used instead of tabs
*/
public void setUseBlanks(boolean value) {
m_UseBlanks = value;
}
/**
* Returns whether blanks are used instead of tabs.
*
* @return
* true if blanks are used instead of tabs
*/
public boolean getUseBlanks() {
return m_UseBlanks;
}
/**
* Sets the background color.
*
* @param value
* the background color
*/
public void setBackgroundColor(Color value) {
m_BackgroundColor = value;
}
/**
* Returns the background color.
*
* @return
* the background color
*/
public Color getBackgroundColor() {
return m_BackgroundColor;
}
/**
* Sets whether to enable multi-line comments.
*
* @param value
* if true then multi-line comments are enabled
*/
public void setMultiLineComment(boolean value) {
m_MultiLineComment = value;
}
/**
* Returns whether multi-line comments are enabled.
*
* @return
* true if multi-line comments are enabled
*/
public boolean getMultiLineComment() {
return m_MultiLineComment;
}
/**
* Sets whether the keywords are case-sensitive or not.
*
* @param value
* if true then keywords are treated case-sensitive
*/
public void setCaseSensitive(boolean value) {
m_CaseSensitive = value;
}
/**
* Returns whether blanks are used instead of tabs.
*
* @return
* true if keywords are case-sensitive
*/
public boolean getCaseSensitive() {
return m_CaseSensitive;
}
}