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 boolean paintPlaceholderText(Graphics2D g) {
CharSequence hintText = myEditor.getPlaceholder();
EditorComponentImpl editorComponent = myEditor.getContentComponent();
if (myDocument.getTextLength() > 0
|| hintText == null
|| hintText.length() == 0
|| KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner() == editorComponent
&& !myEditor.getShowPlaceholderWhenFocused()) {
return false;
}
hintText =
SwingUtilities.layoutCompoundLabel(
g.getFontMetrics(),
hintText.toString(),
null,
0,
0,
0,
0,
editorComponent.getBounds(),
new Rectangle(),
new Rectangle(),
0);
g.setColor(myEditor.getFoldingModel().getPlaceholderAttributes().getForegroundColor());
g.setFont(myEditor.getColorsScheme().getFont(EditorFontType.PLAIN));
g.drawString(hintText.toString(), 0, myView.getAscent());
return true;
}
private void paintBackground(Graphics2D g, Color color, float x, int y, float width) {
if (width <= 0
|| color == null
|| color.equals(myEditor.getColorsScheme().getDefaultBackground())
|| color.equals(myEditor.getBackgroundColor())) return;
g.setColor(color);
g.fillRect((int) x, y, (int) width, myView.getLineHeight());
}
private void paintWhitespace(
Graphics2D g,
CharSequence text,
float x,
int y,
int start,
int end,
EditorImpl.LineWhitespacePaintingStrategy whitespacePaintingStrategy,
VisualLineFragmentsIterator.Fragment fragment) {
g.setColor(myEditor.getColorsScheme().getColor(EditorColors.WHITESPACES_COLOR));
boolean isRtl = fragment.isRtl();
int baseStartOffset = fragment.getStartOffset();
int startOffset = isRtl ? baseStartOffset - start : baseStartOffset + start;
for (int i = start; i < end; i++) {
int charOffset = isRtl ? baseStartOffset - i - 1 : baseStartOffset + i;
char c = text.charAt(charOffset);
if (" \t\u3000".indexOf(c) >= 0
&& whitespacePaintingStrategy.showWhitespaceAtOffset(charOffset)) {
int startX =
(int)
fragment.offsetToX(
x, startOffset, isRtl ? baseStartOffset - i : baseStartOffset + i);
int endX =
(int)
fragment.offsetToX(
x, startOffset, isRtl ? baseStartOffset - i - 1 : baseStartOffset + i + 1);
if (c == ' ') {
g.fillRect((startX + endX) / 2, y, 1, 1);
} else if (c == '\t') {
endX -= myView.getPlainSpaceWidth() / 4;
int height = myView.getCharHeight();
int halfHeight = height / 2;
int mid = y - halfHeight;
int top = y - height;
UIUtil.drawLine(g, startX, mid, endX, mid);
UIUtil.drawLine(g, endX, y, endX, top);
g.fillPolygon(
new int[] {endX - halfHeight, endX - halfHeight, endX},
new int[] {y, y - height, y - halfHeight},
3);
} else if (c == '\u3000') { // ideographic space
final int charHeight = myView.getCharHeight();
g.drawRect(startX + 2, y - charHeight, endX - startX - 4, charHeight);
}
}
}
}
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 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 paintLineExtensions(Graphics2D g, int line, float x, int y) {
Project project = myEditor.getProject();
VirtualFile virtualFile = myEditor.getVirtualFile();
if (project == null || virtualFile == null) return;
for (EditorLinePainter painter : EditorLinePainter.EP_NAME.getExtensions()) {
Collection<LineExtensionInfo> extensions =
painter.getLineExtensions(project, virtualFile, line);
if (extensions != null) {
for (LineExtensionInfo info : extensions) {
LineLayout layout =
new LineLayout(myView, info.getText(), info.getFontType(), g.getFontRenderContext());
g.setColor(info.getColor());
x =
paintLineLayoutWithEffect(
g, layout, x, y, info.getEffectColor(), info.getEffectType());
int currentLineWidth = (int) x;
EditorSizeManager sizeManager = myView.getSizeManager();
if (currentLineWidth > sizeManager.getMaxLineWithExtensionWidth()) {
sizeManager.setMaxLineWithExtensionWidth(line, currentLineWidth);
}
}
}
}
}
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);
}
}
}
}
private void paintTextWithEffects(
Graphics2D g, Rectangle clip, int startVisualLine, int endVisualLine) {
final CharSequence text = myDocument.getImmutableCharSequence();
final EditorImpl.LineWhitespacePaintingStrategy whitespacePaintingStrategy =
myEditor.new LineWhitespacePaintingStrategy();
int lineCount = myEditor.getVisibleLineCount();
for (int visualLine = startVisualLine; visualLine <= endVisualLine; visualLine++) {
int y = myView.visualLineToY(visualLine) + myView.getAscent();
LineLayout prefixLayout = myView.getPrefixLayout();
if (visualLine == 0 && prefixLayout != null) {
g.setColor(myView.getPrefixAttributes().getForegroundColor());
paintLineLayoutWithEffect(
g,
prefixLayout,
0,
y,
myView.getPrefixAttributes().getEffectColor(),
myView.getPrefixAttributes().getEffectType());
}
if (visualLine >= lineCount) break;
final int[] currentLogicalLine = new int[] {-1};
paintLineFragments(
g,
clip,
visualLine,
y,
new LineFragmentPainter() {
@Override
public void paintBeforeLineStart(
Graphics2D g, TextAttributes attributes, int columnEnd, float xEnd, int y) {
SoftWrapModelImpl softWrapModel = myEditor.getSoftWrapModel();
int symbolWidth =
softWrapModel.getMinDrawingWidthInPixels(SoftWrapDrawingType.AFTER_SOFT_WRAP);
softWrapModel.paint(
g,
SoftWrapDrawingType.AFTER_SOFT_WRAP,
(int) xEnd - symbolWidth,
y - myView.getAscent(),
myView.getLineHeight());
}
@Override
public void paint(
Graphics2D g,
VisualLineFragmentsIterator.Fragment fragment,
int start,
int end,
TextAttributes attributes,
float xStart,
float xEnd,
int y) {
if (attributes != null && attributes.getForegroundColor() != null) {
g.setColor(attributes.getForegroundColor());
fragment.draw(g, xStart, y, start, end);
}
if (fragment.getCurrentFoldRegion() == null) {
int logicalLine = fragment.getStartLogicalLine();
if (logicalLine != currentLogicalLine[0]) {
whitespacePaintingStrategy.update(
text,
myDocument.getLineStartOffset(logicalLine),
myDocument.getLineEndOffset(logicalLine));
currentLogicalLine[0] = logicalLine;
}
paintWhitespace(
g, text, xStart, y, start, end, whitespacePaintingStrategy, fragment);
}
if (attributes != null
&& hasTextEffect(attributes.getEffectColor(), attributes.getEffectType())) {
paintTextEffect(
g, xStart, xEnd, y, attributes.getEffectColor(), attributes.getEffectType());
}
}
@Override
public void paintAfterLineEnd(
Graphics2D g,
Rectangle clip,
IterationState iterationState,
int columnStart,
float x,
int y) {
int offset = iterationState.getEndOffset();
SoftWrapModelImpl softWrapModel = myEditor.getSoftWrapModel();
if (softWrapModel.getSoftWrap(offset) == null) {
int logicalLine = myDocument.getLineNumber(offset);
paintLineExtensions(g, logicalLine, x, y);
} else {
softWrapModel.paint(
g,
SoftWrapDrawingType.BEFORE_SOFT_WRAP_LINE_FEED,
(int) x,
y - myView.getAscent(),
myView.getLineHeight());
}
}
});
}
}
private void paintTextEffect(
Graphics2D g, float xFrom, float xTo, int y, Color effectColor, EffectType effectType) {
int xStart = (int) xFrom;
int xEnd = (int) xTo;
g.setColor(effectColor);
if (effectType == EffectType.LINE_UNDERSCORE) {
UIUtil.drawLine(g, xStart, y + 1, xEnd, y + 1);
} else if (effectType == EffectType.BOLD_LINE_UNDERSCORE) {
int height = JBUI.scale(Registry.intValue("editor.bold.underline.height", 2));
g.fillRect(xStart, y, xEnd - xStart, height);
} else if (effectType == EffectType.STRIKEOUT) {
int y1 = y - myView.getCharHeight() / 2;
UIUtil.drawLine(g, xStart, y1, xEnd, y1);
} else if (effectType == EffectType.WAVE_UNDERSCORE) {
UIUtil.drawWave(g, new Rectangle(xStart, y + 1, xEnd - xStart, myView.getDescent() - 1));
} else if (effectType == EffectType.BOLD_DOTTED_LINE) {
UIUtil.drawBoldDottedLine(
g,
xStart,
xEnd,
SystemInfo.isMac ? y : y + 1,
myEditor.getBackgroundColor(),
g.getColor(),
false);
}
}