/**
* Returns a list of pairs of x coordinates for visual ranges representing given logical range. If
* <code>startOffset == endOffset</code>, a pair of equal numbers is returned, corresponding to
* target position. Target offsets are supposed to be located on the same visual line.
*/
private TFloatArrayList logicalRangeToVisualRanges(int startOffset, int endOffset) {
assert startOffset <= endOffset;
TFloatArrayList result = new TFloatArrayList();
for (VisualLineFragmentsIterator.Fragment fragment :
VisualLineFragmentsIterator.create(myView, startOffset, false)) {
int minOffset = fragment.getMinOffset();
int maxOffset = fragment.getMaxOffset();
if (startOffset == endOffset) {
if (startOffset >= minOffset && startOffset <= maxOffset) {
float x = fragment.offsetToX(startOffset);
result.add(x);
result.add(x);
break;
}
} else if (startOffset < maxOffset && endOffset > minOffset) {
float x1 = fragment.offsetToX(Math.max(minOffset, startOffset));
float x2 = fragment.offsetToX(Math.min(maxOffset, endOffset));
if (x1 > x2) {
float tmp = x1;
x1 = x2;
x2 = tmp;
}
if (result.isEmpty() || x1 > result.get(result.size() - 1)) {
result.add(x1);
result.add(x2);
} else {
result.set(result.size() - 1, x2);
}
}
}
return result;
}
private void paintVirtualSelectionIfNecessary(
Graphics2D g,
Map<Integer, Couple<Integer>> virtualSelectionMap,
int columnStart,
float xStart,
float xEnd,
int y) {
int visualLine = myView.yToVisualLine(y);
Couple<Integer> selectionRange = virtualSelectionMap.get(visualLine);
if (selectionRange == null || selectionRange.second <= columnStart) return;
float startX =
selectionRange.first <= columnStart
? xStart
: myView.visualPositionToXY(new VisualPosition(visualLine, selectionRange.first)).x;
float endX =
Math.min(
xEnd,
myView.visualPositionToXY(new VisualPosition(visualLine, selectionRange.second)).x);
paintBackground(
g,
myEditor.getColorsScheme().getColor(EditorColors.SELECTION_BACKGROUND_COLOR),
startX,
y,
endX - startX);
}
private void paintCaret(Graphics2D g_) {
EditorImpl.CaretRectangle[] locations = myEditor.getCaretLocations(true);
if (locations == null) return;
Graphics2D g = IdeBackgroundUtil.getOriginalGraphics(g_);
int lineHeight = myView.getLineHeight();
EditorSettings settings = myEditor.getSettings();
Color caretColor = myEditor.getColorsScheme().getColor(EditorColors.CARET_COLOR);
if (caretColor == null) caretColor = new JBColor(CARET_DARK, CARET_LIGHT);
g.setColor(caretColor);
for (EditorImpl.CaretRectangle location : locations) {
int x = location.myPoint.x;
int y = location.myPoint.y;
Caret caret = location.myCaret;
boolean isRtl = location.myIsRtl;
if (myEditor.isInsertMode() != settings.isBlockCursor()) {
int lineWidth = JBUI.scale(settings.getLineCursorWidth());
g.fillRect(x, y, lineWidth, lineHeight);
if (myDocument.getTextLength() > 0
&& caret != null
&& !myView.getLineLayout(caret.getLogicalPosition().line).isLtr()) {
g.fillPolygon(
new int[] {
isRtl ? x + lineWidth : x,
isRtl ? x + lineWidth - CARET_DIRECTION_MARK_SIZE : x + CARET_DIRECTION_MARK_SIZE,
isRtl ? x + lineWidth : x
},
new int[] {y, y, y + CARET_DIRECTION_MARK_SIZE},
3);
}
} else {
int width = location.myWidth;
int startX = Math.max(0, isRtl ? x - width : x);
g.fillRect(startX, y, width, lineHeight - 1);
if (myDocument.getTextLength() > 0 && caret != null) {
int targetVisualColumn = caret.getVisualPosition().column;
for (VisualLineFragmentsIterator.Fragment fragment :
VisualLineFragmentsIterator.create(myView, caret.getVisualLineStart(), false)) {
int startVisualColumn = fragment.getStartVisualColumn();
int endVisualColumn = fragment.getEndVisualColumn();
if (startVisualColumn < targetVisualColumn && endVisualColumn > targetVisualColumn
|| startVisualColumn == targetVisualColumn && !isRtl
|| endVisualColumn == targetVisualColumn && isRtl) {
g.setColor(ColorUtil.isDark(caretColor) ? CARET_LIGHT : CARET_DARK);
fragment.draw(
g,
startX,
y + myView.getAscent(),
targetVisualColumn - startVisualColumn - (isRtl ? 1 : 0),
targetVisualColumn - startVisualColumn + (isRtl ? 0 : 1));
break;
}
}
}
}
}
}
private void paintComposedTextDecoration(Graphics2D g) {
TextRange composedTextRange = myEditor.getComposedTextRange();
if (composedTextRange != null) {
Point p1 =
myView.offsetToXY(
Math.min(composedTextRange.getStartOffset(), myDocument.getTextLength()),
true,
false);
Point p2 =
myView.offsetToXY(
Math.min(composedTextRange.getEndOffset(), myDocument.getTextLength()), false, true);
int y = p1.y + myView.getAscent() + 1;
g.setStroke(IME_COMPOSED_TEXT_UNDERLINE_STROKE);
g.setColor(myEditor.getColorsScheme().getDefaultForeground());
UIUtil.drawLine(g, p1.x, y, p2.x, y);
}
}
void repaintCarets() {
EditorImpl.CaretRectangle[] locations = myEditor.getCaretLocations(false);
if (locations == null) return;
int lineHeight = myView.getLineHeight();
for (EditorImpl.CaretRectangle location : locations) {
int x = location.myPoint.x;
int y = location.myPoint.y;
int width = Math.max(location.myWidth, CARET_DIRECTION_MARK_SIZE);
myEditor.getContentComponent().repaintEditorComponent(x - width, y, width * 2, lineHeight);
}
}
void paint(Graphics2D g) {
Rectangle clip = g.getClipBounds();
if (myEditor.getContentComponent().isOpaque()) {
g.setColor(myEditor.getBackgroundColor());
g.fillRect(clip.x, clip.y, clip.width, clip.height);
}
if (paintPlaceholderText(g)) {
paintCaret(g);
return;
}
int startLine = myView.yToVisualLine(Math.max(clip.y, 0));
int endLine = myView.yToVisualLine(Math.max(clip.y + clip.height, 0));
int startOffset = myView.visualPositionToOffset(new VisualPosition(startLine, 0));
int endOffset = myView.visualPositionToOffset(new VisualPosition(endLine + 1, 0, true));
ClipDetector clipDetector = new ClipDetector(myEditor, clip);
paintBackground(g, clip, startLine, endLine);
paintRightMargin(g, clip);
paintCustomRenderers(g, startOffset, endOffset);
MarkupModelEx docMarkup =
(MarkupModelEx) DocumentMarkupModel.forDocument(myDocument, myEditor.getProject(), true);
paintLineMarkersSeparators(g, clip, docMarkup, startOffset, endOffset);
paintLineMarkersSeparators(g, clip, myEditor.getMarkupModel(), startOffset, endOffset);
paintTextWithEffects(g, clip, startLine, endLine);
paintHighlightersAfterEndOfLine(g, docMarkup, startOffset, endOffset);
paintHighlightersAfterEndOfLine(g, myEditor.getMarkupModel(), startOffset, endOffset);
paintBorderEffect(g, clipDetector, myEditor.getHighlighter(), startOffset, endOffset);
paintBorderEffect(g, clipDetector, docMarkup, startOffset, endOffset);
paintBorderEffect(g, clipDetector, myEditor.getMarkupModel(), startOffset, endOffset);
paintCaret(g);
paintComposedTextDecoration(g);
}
private void paintLineMarkerSeparator(RangeHighlighter marker, Rectangle clip, Graphics g) {
Color separatorColor = marker.getLineSeparatorColor();
LineSeparatorRenderer lineSeparatorRenderer = marker.getLineSeparatorRenderer();
if (separatorColor == null && lineSeparatorRenderer == null) {
return;
}
int line =
myDocument.getLineNumber(
marker.getLineSeparatorPlacement() == SeparatorPlacement.TOP
? marker.getStartOffset()
: marker.getEndOffset());
int visualLine =
myView.logicalToVisualPosition(
new LogicalPosition(
line + (marker.getLineSeparatorPlacement() == SeparatorPlacement.TOP ? 0 : 1),
0),
false)
.line;
int y = myView.visualLineToY(visualLine) - 1;
int endShift = clip.x + clip.width;
EditorSettings settings = myEditor.getSettings();
if (settings.isRightMarginShown()
&& myEditor.getColorsScheme().getColor(EditorColors.RIGHT_MARGIN_COLOR) != null) {
endShift =
Math.min(
endShift,
settings.getRightMargin(myEditor.getProject()) * myView.getPlainSpaceWidth());
}
g.setColor(separatorColor);
if (lineSeparatorRenderer != null) {
lineSeparatorRenderer.drawLine(g, 0, endShift, y);
} else {
UIUtil.drawLine(g, 0, y, endShift, y);
}
}
private void paintLineFragments(
Graphics2D g, Rectangle clip, int visualLine, int y, LineFragmentPainter painter) {
float x = visualLine == 0 ? myView.getPrefixTextWidthInPixels() : 0;
int offset = myView.visualPositionToOffset(new VisualPosition(visualLine, 0));
int visualLineEndOffset =
myView.visualPositionToOffset(new VisualPosition(visualLine, Integer.MAX_VALUE, true));
IterationState it = null;
int prevEndOffset = -1;
boolean firstFragment = true;
int maxColumn = 0;
for (VisualLineFragmentsIterator.Fragment fragment :
VisualLineFragmentsIterator.create(myView, offset, false)) {
int fragmentStartOffset = fragment.getStartOffset();
int start = fragmentStartOffset;
int end = fragment.getEndOffset();
x = fragment.getStartX();
if (firstFragment) {
firstFragment = false;
SoftWrap softWrap = myEditor.getSoftWrapModel().getSoftWrap(offset);
if (softWrap != null) {
prevEndOffset = offset;
it =
new IterationState(
myEditor,
offset == 0 ? 0 : offset - 1,
visualLineEndOffset,
true,
false,
false,
false);
if (it.getEndOffset() <= offset) {
it.advance();
}
painter.paintBeforeLineStart(
g,
it.getStartOffset() == offset
? it.getBeforeLineStartBackgroundAttributes()
: it.getMergedAttributes(),
fragment.getStartVisualColumn(),
fragment.getStartX(),
y);
}
}
FoldRegion foldRegion = fragment.getCurrentFoldRegion();
if (foldRegion == null) {
if (start != prevEndOffset) {
it =
new IterationState(
myEditor,
start,
fragment.isRtl() ? offset : visualLineEndOffset,
true,
false,
false,
fragment.isRtl());
}
prevEndOffset = end;
assert it != null;
while (fragment.isRtl() ? start > end : start < end) {
if (fragment.isRtl() ? it.getEndOffset() >= start : it.getEndOffset() <= start) {
assert !it.atEnd();
it.advance();
}
TextAttributes attributes = it.getMergedAttributes();
int curEnd =
fragment.isRtl()
? Math.max(it.getEndOffset(), end)
: Math.min(it.getEndOffset(), end);
float xNew = fragment.offsetToX(x, start, curEnd);
painter.paint(
g,
fragment,
fragment.isRtl() ? fragmentStartOffset - start : start - fragmentStartOffset,
fragment.isRtl() ? fragmentStartOffset - curEnd : curEnd - fragmentStartOffset,
attributes,
x,
xNew,
y);
x = xNew;
start = curEnd;
}
} else {
float xNew = fragment.getEndX();
painter.paint(
g,
fragment,
0,
fragment.getEndVisualColumn() - fragment.getStartVisualColumn(),
getFoldRegionAttributes(foldRegion),
x,
xNew,
y);
x = xNew;
prevEndOffset = -1;
it = null;
}
maxColumn = fragment.getEndVisualColumn();
}
if (it == null || it.getEndOffset() != visualLineEndOffset) {
it =
new IterationState(
myEditor,
visualLineEndOffset == offset ? visualLineEndOffset : visualLineEndOffset - 1,
visualLineEndOffset,
true,
false,
false,
false);
}
if (!it.atEnd()) {
it.advance();
}
assert it.atEnd();
painter.paintAfterLineEnd(g, clip, it, maxColumn, x, y);
}
private void paintBorderEffect(
Graphics2D g,
ClipDetector clipDetector,
int startOffset,
int endOffset,
TextAttributes attributes) {
if (!clipDetector.rangeCanBeVisible(startOffset, endOffset)) return;
int startLine = myDocument.getLineNumber(startOffset);
int endLine = myDocument.getLineNumber(endOffset);
if (startLine + 1 == endLine
&& startOffset == myDocument.getLineStartOffset(startLine)
&& endOffset == myDocument.getLineStartOffset(endLine)) {
// special case of line highlighters
endLine--;
endOffset = myDocument.getLineEndOffset(endLine);
}
boolean rounded = attributes.getEffectType() == EffectType.ROUNDED_BOX;
int lineHeight = myView.getLineHeight() - 1;
g.setColor(attributes.getEffectColor());
VisualPosition startPosition = myView.offsetToVisualPosition(startOffset, true, false);
VisualPosition endPosition = myView.offsetToVisualPosition(endOffset, false, true);
if (startPosition.line == endPosition.line) {
int y = myView.visualLineToY(startPosition.line);
TFloatArrayList ranges = adjustedLogicalRangeToVisualRanges(startOffset, endOffset);
for (int i = 0; i < ranges.size() - 1; i += 2) {
int startX = (int) ranges.get(i);
int endX = (int) ranges.get(i + 1);
if (rounded) {
UIUtil.drawRectPickedOut(g, startX, y, endX - startX, lineHeight);
} else {
g.drawRect(startX, y, endX - startX, lineHeight);
}
}
} else {
int maxWidth = myView.getMaxWidthInLineRange(startPosition.line, endPosition.line) - 1;
TFloatArrayList leadingRanges =
adjustedLogicalRangeToVisualRanges(
startOffset,
myView.visualPositionToOffset(
new VisualPosition(startPosition.line, Integer.MAX_VALUE, true)));
TFloatArrayList trailingRanges =
adjustedLogicalRangeToVisualRanges(
myView.visualPositionToOffset(new VisualPosition(endPosition.line, 0)), endOffset);
if (!leadingRanges.isEmpty() && !trailingRanges.isEmpty()) {
boolean containsInnerLines = endPosition.line > startPosition.line + 1;
int leadingTopY = myView.visualLineToY(startPosition.line);
int leadingBottomY = leadingTopY + lineHeight;
int trailingTopY = myView.visualLineToY(endPosition.line);
int trailingBottomY = trailingTopY + lineHeight;
float start = 0;
float end = 0;
float leftGap = leadingRanges.get(0) - (containsInnerLines ? 0 : trailingRanges.get(0));
int adjustY =
leftGap == 0 ? 2 : leftGap > 0 ? 1 : 0; // avoiding 1-pixel gap between aligned lines
for (int i = 0; i < leadingRanges.size() - 1; i += 2) {
start = leadingRanges.get(i);
end = leadingRanges.get(i + 1);
if (i > 0) {
drawLine(g, leadingRanges.get(i - 1), leadingBottomY, start, leadingBottomY, rounded);
}
drawLine(g, start, leadingBottomY + (i == 0 ? adjustY : 0), start, leadingTopY, rounded);
if ((i + 2) < leadingRanges.size()) {
drawLine(g, start, leadingTopY, end, leadingTopY, rounded);
drawLine(g, end, leadingTopY, end, leadingBottomY, rounded);
}
}
end = Math.max(end, maxWidth);
drawLine(g, start, leadingTopY, end, leadingTopY, rounded);
drawLine(g, end, leadingTopY, end, trailingTopY - 1, rounded);
float targetX = trailingRanges.get(trailingRanges.size() - 1);
drawLine(g, end, trailingTopY - 1, targetX, trailingTopY - 1, rounded);
adjustY =
end == targetX
? -2
: -1; // for lastX == targetX we need to avoid a gap when rounding is used
for (int i = trailingRanges.size() - 2; i >= 0; i -= 2) {
start = trailingRanges.get(i);
end = trailingRanges.get(i + 1);
drawLine(g, end, trailingTopY + (i == 0 ? adjustY : 0), end, trailingBottomY, rounded);
drawLine(g, end, trailingBottomY, start, trailingBottomY, rounded);
drawLine(g, start, trailingBottomY, start, trailingTopY, rounded);
if (i > 0) {
drawLine(g, start, trailingTopY, trailingRanges.get(i - 1), trailingTopY, rounded);
}
}
float lastX = start;
if (containsInnerLines) {
if (start > 0) {
drawLine(g, start, trailingTopY, start, trailingTopY - 1, rounded);
drawLine(g, start, trailingTopY - 1, 0, trailingTopY - 1, rounded);
drawLine(g, 0, trailingTopY - 1, 0, leadingBottomY + 1, rounded);
} else {
drawLine(g, start, trailingTopY, 0, leadingBottomY + 1, rounded);
}
lastX = 0;
}
targetX = leadingRanges.get(0);
if (lastX < targetX) {
drawLine(g, lastX, leadingBottomY + 1, targetX, leadingBottomY + 1, rounded);
} else {
drawLine(g, lastX, leadingBottomY + 1, lastX, leadingBottomY, rounded);
drawLine(g, lastX, leadingBottomY, targetX, leadingBottomY, rounded);
}
}
}
}