public EditorView<T> getView(String viewId) {
for (EditorView<T> view : views) {
if (view.getViewId().equals(viewId)) return view;
}
return null;
}
private void paintSelectionOnFirstSoftWrapLineIfNecessary(
Graphics2D g, int columnStart, float xStart, float xEnd, int y) {
VisualPosition selectionStartPosition =
myEditor.getSelectionModel().getSelectionStartPosition();
VisualPosition selectionEndPosition = myEditor.getSelectionModel().getSelectionEndPosition();
int visualLine = myView.yToVisualLine(y);
if (selectionStartPosition.equals(selectionEndPosition)
|| visualLine < selectionStartPosition.line
|| visualLine > selectionEndPosition.line
|| visualLine == selectionEndPosition.line && selectionEndPosition.column <= columnStart) {
return;
}
float startX =
selectionStartPosition.line == visualLine && selectionStartPosition.column > columnStart
? myView.visualPositionToXY(selectionStartPosition).x
: xStart;
float endX =
selectionEndPosition.line == visualLine
? myView.visualPositionToXY(selectionEndPosition).x
: xEnd;
paintBackground(
g,
myEditor.getColorsScheme().getColor(EditorColors.SELECTION_BACKGROUND_COLOR),
startX,
y,
endX - startX);
}
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);
}
public final void setDocument(T document) {
if (this.document != null) this.document.release();
this.document = document;
for (EditorView<T> view : views) {
view.setDocument(document);
}
}
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 paintBackground(
Graphics2D g, Rectangle clip, int startVisualLine, int endVisualLine) {
int lineCount = myEditor.getVisibleLineCount();
final Map<Integer, Couple<Integer>> virtualSelectionMap =
createVirtualSelectionMap(startVisualLine, endVisualLine);
for (int visualLine = startVisualLine; visualLine <= endVisualLine; visualLine++) {
int y = myView.visualLineToY(visualLine);
LineLayout prefixLayout = myView.getPrefixLayout();
if (visualLine == 0 && prefixLayout != null) {
paintBackground(g, myView.getPrefixAttributes(), 0, y, prefixLayout.getWidth());
}
if (visualLine >= lineCount) break;
paintLineFragments(
g,
clip,
visualLine,
y,
new LineFragmentPainter() {
@Override
public void paintBeforeLineStart(
Graphics2D g, TextAttributes attributes, int columnEnd, float xEnd, int y) {
paintBackground(g, attributes, 0, y, xEnd);
paintSelectionOnSecondSoftWrapLineIfNecessary(g, columnEnd, xEnd, y);
}
@Override
public void paint(
Graphics2D g,
VisualLineFragmentsIterator.Fragment fragment,
int start,
int end,
TextAttributes attributes,
float xStart,
float xEnd,
int y) {
paintBackground(g, attributes, xStart, y, xEnd - xStart);
}
@Override
public void paintAfterLineEnd(
Graphics2D g, Rectangle clip, IterationState it, int columnStart, float x, int y) {
paintBackground(
g, it.getPastLineEndBackgroundAttributes(), x, y, clip.x + clip.width - x);
int offset = it.getEndOffset();
SoftWrap softWrap = myEditor.getSoftWrapModel().getSoftWrap(offset);
if (softWrap == null) {
paintVirtualSelectionIfNecessary(
g, virtualSelectionMap, columnStart, x, clip.x + clip.width, y);
} else {
paintSelectionOnFirstSoftWrapLineIfNecessary(
g, columnStart, x, clip.x + clip.width, y);
}
}
});
}
}
@SuppressWarnings("unchecked")
public void stateChanged(ChangeEvent e) {
int currentViewIndex = views.indexOf(currentView);
if (currentView != null) {
if (inputTabs.getSelectedIndex() == currentViewIndex) return;
if (!currentView.deactivate()) {
inputTabs.setSelectedIndex(currentViewIndex);
return;
}
}
EditorView<T> previousView = currentView;
int selectedIndex = inputTabs.getSelectedIndex();
if (selectedIndex == -1) {
currentView = null;
return;
}
currentView = views.get(selectedIndex);
if (currentView != null
&& !currentView.activate(
previousView == null ? null : previousView.getEditorLocation())) {
inputTabs.setSelectedIndex(currentViewIndex);
if (currentViewIndex == -1) return;
}
EditorInspector<T> currentInspector =
(EditorInspector<T>) inspectorPanel.getCurrentInspector();
if (currentInspector != null) {
lastDividerLocation = inspectorPanel.getDividerLocation();
}
for (Inspector inspector : inspectorPanel.getInspectors()) {
inspectorPanel.setInspectorVisible(
inspector, ((EditorInspector<T>) inspector).isEnabledFor(currentView));
}
if (currentInspector != null
&& ((EditorInspector<T>) currentInspector).isEnabledFor(currentView)) {
if (lastDividerLocation == 0) inspectorPanel.setResetDividerLocation();
else inspectorPanel.setDividerLocation(lastDividerLocation);
} else currentInspector = null;
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
if (currentView != null) currentView.getComponent().requestFocus();
}
});
}
public void addEditorView(EditorView<T> editorView) {
views.add(editorView);
inputTabs.addTab(
null,
new VTextIcon(inputTabs, editorView.getTitle(), VTextIcon.ROTATE_LEFT),
editorView.getComponent());
editorView.addPropertyChangeListener(this);
editorView.addLocationListener(this);
editorView.setDocument(document);
}
public void release() {
for (EditorView<T> view : views) {
view.release();
view.removePropertyChangeListener(this);
}
views.clear();
inputTabs.removeChangeListener(inputTabsChangeListener);
inputTabs.removeAll();
inspectorPanel.release();
document.release();
}
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 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 paintRightMargin(Graphics g, Rectangle clip) {
EditorSettings settings = myEditor.getSettings();
Color rightMargin = myEditor.getColorsScheme().getColor(EditorColors.RIGHT_MARGIN_COLOR);
if (!settings.isRightMarginShown() || rightMargin == null) return;
int x = settings.getRightMargin(myEditor.getProject()) * myView.getPlainSpaceWidth();
g.setColor(rightMargin);
UIUtil.drawLine(g, x, clip.y, x, clip.y + clip.height);
}
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);
}
}
private void paintHighlighterAfterEndOfLine(Graphics2D g, RangeHighlighterEx highlighter) {
if (!highlighter.isAfterEndOfLine()) {
return;
}
int startOffset = highlighter.getStartOffset();
int lineEndOffset = myDocument.getLineEndOffset(myDocument.getLineNumber(startOffset));
if (myEditor.getFoldingModel().isOffsetCollapsed(lineEndOffset)) return;
Point lineEnd = myView.offsetToXY(lineEndOffset, true, false);
int x = lineEnd.x;
int y = lineEnd.y;
TextAttributes attributes = highlighter.getTextAttributes();
paintBackground(g, attributes, x, y, myView.getPlainSpaceWidth());
if (attributes != null
&& hasTextEffect(attributes.getEffectColor(), attributes.getEffectType())) {
paintTextEffect(
g,
x,
x + myView.getPlainSpaceWidth() - 1,
y + myView.getAscent(),
attributes.getEffectColor(),
attributes.getEffectType());
}
}
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 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);
}
}
}
}
}
public void setEditable(boolean enabled) {
for (EditorView<T> view : views) {
view.setEditable(enabled);
}
}
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());
}
}
});
}
}
public boolean hasFocus() {
return currentView == null ? false : currentView.getComponent().hasFocus();
}
public void requestFocus() {
if (currentView != null) currentView.getComponent().requestFocus();
}
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);
}
}
}
}
EditorPainter(EditorView view) {
myView = view;
myEditor = view.getEditor();
myDocument = myEditor.getDocument();
}
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);
}
}