/**
* This is called by the nested wrapped line views to determine the break location. This can be
* reimplemented to alter the breaking behavior. It will either break at word or character
* boundaries depending upon the break argument given at construction.
*/
protected int calculateBreakPosition(int p0, Token tokenList, float x0) {
// System.err.println("------ beginning calculateBreakPosition() --------");
int p = p0;
RSyntaxTextArea textArea = (RSyntaxTextArea) getContainer();
float currentWidth = getWidth();
if (currentWidth == Integer.MAX_VALUE) currentWidth = getPreferredSpan(X_AXIS);
// Make sure width>0; this is a huge hack to fix a bug where
// loading text into an RTextArea before it is visible if word wrap
// is enabled causes an infinite loop in calculateBreakPosition()
// because of the 0-width! We cannot simply check in setSize()
// because the width is set to 0 somewhere else too somehow...
currentWidth = Math.max(currentWidth, MIN_WIDTH);
Token t = tokenList;
while (t != null && t.isPaintable()) {
// FIXME: Replace the code below with the commented-out line below. This will
// allow long tokens to be broken at embedded spaces (such as MLC's). But it
// currently throws BadLocationExceptions sometimes...
float tokenWidth = t.getWidth(textArea, this, x0);
if (tokenWidth > currentWidth) {
// If the current token alone is too long for this line,
// break at a character boundary.
if (p == p0) {
return t.getOffsetBeforeX(textArea, this, 0, currentWidth);
}
// Return the first non-whitespace char (i.e., don't start
// off the continuation of a wrapped line with whitespace).
return t.isWhitespace() ? p + t.length() : p;
// return getBreakLocation(t, fm, x0, currentWidth, this);
}
currentWidth -= tokenWidth;
x0 += tokenWidth;
p += t.length();
// System.err.println("*** *** *** token fit entirely (width==" + tokenWidth + "), adding " +
// t.textCount + " to p, now p==" + p);
t = t.getNextToken();
}
// System.err.println("... ... whole line fits; returning p==" + p);
// System.err.println("------ ending calculateBreakPosition() --------");
// return p;
return p + 1;
}
/**
* Draws a single view (i.e., a line of text for a wrapped view), wrapping the text onto multiple
* lines if necessary. Any selected text is rendered with the editor's "selected text" color.
*
* @param painter The painter to use to render tokens.
* @param g The graphics context in which to paint.
* @param r The rectangle in which to paint.
* @param view The <code>View</code> to paint.
* @param fontHeight The height of the font being used.
* @param y The y-coordinate at which to begin painting.
* @param selStart The start of the selection.
* @param selEnd The end of the selection.
*/
protected void drawViewWithSelection(
TokenPainter painter,
Graphics2D g,
Rectangle r,
View view,
int fontHeight,
int y,
int selStart,
int selEnd) {
float x = r.x;
LayeredHighlighter h = (LayeredHighlighter) host.getHighlighter();
RSyntaxDocument document = (RSyntaxDocument) getDocument();
Element map = getElement();
int p0 = view.getStartOffset();
int lineNumber = map.getElementIndex(p0);
int p1 = view.getEndOffset(); // - 1;
setSegment(p0, p1 - 1, document, drawSeg);
// System.err.println("drawSeg=='" + drawSeg + "' (p0/p1==" + p0 + "/" + p1 + ")");
int start = p0 - drawSeg.offset;
Token token = document.getTokenListForLine(lineNumber);
// If this line is an empty line, then the token list is simply a
// null token. In this case, the line highlight will be skipped in
// the loop below, so unfortunately we must manually do it here.
if (token != null && token.getType() == Token.NULL) {
h.paintLayeredHighlights(g, p0, p1, r, host, this);
return;
}
// Loop through all tokens in this view and paint them!
while (token != null && token.isPaintable()) {
int p = calculateBreakPosition(p0, token, x);
x = r.x;
h.paintLayeredHighlights(g, p0, p, r, host, this);
while (token != null && token.isPaintable() && token.getEndOffset() - 1 < p) { // <=p) {
// Selection starts in this token
if (token.containsPosition(selStart)) {
if (selStart > token.getOffset()) {
tempToken.copyFrom(token);
tempToken.textCount = selStart - tempToken.getOffset();
x = painter.paint(tempToken, g, x, y, host, this);
tempToken.textCount = token.length();
tempToken.makeStartAt(selStart);
// Clone required since token and tempToken must be
// different tokens for else statement below
token = new TokenImpl(tempToken);
}
int selCount = Math.min(token.length(), selEnd - token.getOffset());
if (selCount == token.length()) {
x = painter.paintSelected(token, g, x, y, host, this);
} else {
tempToken.copyFrom(token);
tempToken.textCount = selCount;
x = painter.paintSelected(tempToken, g, x, y, host, this);
tempToken.textCount = token.length();
tempToken.makeStartAt(token.getOffset() + selCount);
token = tempToken;
x = painter.paint(token, g, x, y, host, this);
}
}
// Selection ends in this token
else if (token.containsPosition(selEnd)) {
tempToken.copyFrom(token);
tempToken.textCount = selEnd - tempToken.getOffset();
x = painter.paintSelected(tempToken, g, x, y, host, this);
tempToken.textCount = token.length();
tempToken.makeStartAt(selEnd);
token = tempToken;
x = painter.paint(token, g, x, y, host, this);
}
// This token is entirely selected
else if (token.getOffset() >= selStart && token.getEndOffset() <= selEnd) {
x = painter.paintSelected(token, g, x, y, host, this);
}
// This token is entirely unselected
else {
x = painter.paint(token, g, x, y, host, this);
}
token = token.getNextToken();
}
// If there's a token that's going to be split onto the next line
if (token != null && token.isPaintable() && token.getOffset() < p) {
int tokenOffset = token.getOffset();
Token orig = token;
token =
new TokenImpl(
drawSeg, tokenOffset - start, p - 1 - start, tokenOffset, token.getType());
// Selection starts in this token
if (token.containsPosition(selStart)) {
if (selStart > token.getOffset()) {
tempToken.copyFrom(token);
tempToken.textCount = selStart - tempToken.getOffset();
x = painter.paint(tempToken, g, x, y, host, this);
tempToken.textCount = token.length();
tempToken.makeStartAt(selStart);
// Clone required since token and tempToken must be
// different tokens for else statement below
token = new TokenImpl(tempToken);
}
int selCount = Math.min(token.length(), selEnd - token.getOffset());
if (selCount == token.length()) {
x = painter.paintSelected(token, g, x, y, host, this);
} else {
tempToken.copyFrom(token);
tempToken.textCount = selCount;
x = painter.paintSelected(tempToken, g, x, y, host, this);
tempToken.textCount = token.length();
tempToken.makeStartAt(token.getOffset() + selCount);
token = tempToken;
x = painter.paint(token, g, x, y, host, this);
}
}
// Selection ends in this token
else if (token.containsPosition(selEnd)) {
tempToken.copyFrom(token);
tempToken.textCount = selEnd - tempToken.getOffset();
x = painter.paintSelected(tempToken, g, x, y, host, this);
tempToken.textCount = token.length();
tempToken.makeStartAt(selEnd);
token = tempToken;
x = painter.paint(token, g, x, y, host, this);
}
// This token is entirely selected
else if (token.getOffset() >= selStart && token.getEndOffset() <= selEnd) {
x = painter.paintSelected(token, g, x, y, host, this);
}
// This token is entirely unselected
else {
x = painter.paint(token, g, x, y, host, this);
}
token = new TokenImpl(orig);
((TokenImpl) token).makeStartAt(p);
}
p0 = (p == p0) ? p1 : p;
y += fontHeight;
} // End of while (token!=null && token.isPaintable()).
// NOTE: We should re-use code from Token (paintBackground()) here,
// but don't because I'm just too lazy.
if (host.getEOLMarkersVisible()) {
g.setColor(host.getForegroundForTokenType(Token.WHITESPACE));
g.setFont(host.getFontForTokenType(Token.WHITESPACE));
g.drawString("\u00B6", x, y - fontHeight);
}
}
/**
* Draws the passed-in text using syntax highlighting for the current language. Tokens are checked
* for being in a selected region, and are rendered appropriately if they are.
*
* @param painter The painter to render the tokens.
* @param token The list of tokens to draw.
* @param g The graphics context in which to draw.
* @param x The x-coordinate at which to draw.
* @param y The y-coordinate at which to draw.
* @param selStart The start of the selection.
* @param selEnd The end of the selection.
* @return The x-coordinate representing the end of the painted text.
*/
private float drawLineWithSelection(
TokenPainter painter, Token token, Graphics2D g, float x, float y, int selStart, int selEnd) {
float nextX = x; // The x-value at the end of our text.
boolean useSTC = host.getUseSelectedTextColor();
while (token != null && token.isPaintable() && nextX < clipEnd) {
// Selection starts in this token
if (token.containsPosition(selStart)) {
if (selStart > token.getOffset()) {
tempToken.copyFrom(token);
tempToken.textCount = selStart - tempToken.getOffset();
nextX = painter.paint(tempToken, g, nextX, y, host, this, clipStart);
tempToken.textCount = token.length();
tempToken.makeStartAt(selStart);
// Clone required since token and tempToken must be
// different tokens for else statement below
token = new TokenImpl(tempToken);
}
int tokenLen = token.length();
int selCount = Math.min(tokenLen, selEnd - token.getOffset());
if (selCount == tokenLen) {
nextX = painter.paintSelected(token, g, nextX, y, host, this, clipStart, useSTC);
} else {
tempToken.copyFrom(token);
tempToken.textCount = selCount;
nextX = painter.paintSelected(tempToken, g, nextX, y, host, this, clipStart, useSTC);
tempToken.textCount = token.length();
tempToken.makeStartAt(token.getOffset() + selCount);
token = tempToken;
nextX = painter.paint(token, g, nextX, y, host, this, clipStart);
}
}
// Selection ends in this token
else if (token.containsPosition(selEnd)) {
tempToken.copyFrom(token);
tempToken.textCount = selEnd - tempToken.getOffset();
nextX = painter.paintSelected(tempToken, g, nextX, y, host, this, clipStart, useSTC);
tempToken.textCount = token.length();
tempToken.makeStartAt(selEnd);
token = tempToken;
nextX = painter.paint(token, g, nextX, y, host, this, clipStart);
}
// This token is entirely selected
else if (token.getOffset() >= selStart && token.getEndOffset() <= selEnd) {
nextX = painter.paintSelected(token, g, nextX, y, host, this, clipStart, useSTC);
}
// This token is entirely unselected
else {
nextX = painter.paint(token, g, nextX, y, host, this, clipStart);
}
token = token.getNextToken();
}
// NOTE: We should re-use code from Token (paintBackground()) here,
// but don't because I'm just too lazy.
if (host.getEOLMarkersVisible()) {
g.setColor(host.getForegroundForTokenType(Token.WHITESPACE));
g.setFont(host.getFontForTokenType(Token.WHITESPACE));
g.drawString("\u00B6", nextX, y);
}
// Return the x-coordinate at the end of the painted text.
return nextX;
}