private VerticalInfo createVerticalInfo(LogicalPosition position) {
Document document = myEditor.getDocument();
int logicalLine = position.line;
if (logicalLine >= document.getLineCount()) {
logicalLine = Math.max(0, document.getLineCount() - 1);
}
int startOffset = document.getLineStartOffset(logicalLine);
int endOffset = document.getLineEndOffset(logicalLine);
// There is a possible case that active logical line is represented on multiple lines due to
// soft wraps processing.
// We want to highlight those visual lines as 'active' then, so, we calculate 'y' position for
// the logical line start
// and height in accordance with the number of occupied visual lines.
VisualPosition visualPosition =
myEditor.offsetToVisualPosition(document.getLineStartOffset(logicalLine));
int y = myEditor.visualPositionToXY(visualPosition).y;
int lineHeight = myEditor.getLineHeight();
int height = lineHeight;
List<? extends SoftWrap> softWraps =
myEditor.getSoftWrapModel().getSoftWrapsForRange(startOffset, endOffset);
for (SoftWrap softWrap : softWraps) {
height += StringUtil.countNewLines(softWrap.getText()) * lineHeight;
}
return new VerticalInfo(y, height);
}
public void documentChanged(DocumentEvent e) {
finishUpdate();
DocumentEventImpl event = (DocumentEventImpl) e;
final Document document = myEditor.getDocument();
boolean performSoftWrapAdjustment =
e.getNewLength() > 0 // We want to put caret just after the last added symbol
// There is a possible case that the user removes text just before the soft wrap. We
// want to keep caret
// on a visual line with soft wrap start then.
|| myEditor.getSoftWrapModel().getSoftWrap(e.getOffset()) != null;
if (event.isWholeTextReplaced()) {
int newLength = document.getTextLength();
if (myOffset == newLength - e.getNewLength() + e.getOldLength() || newLength == 0) {
moveToOffset(newLength, performSoftWrapAdjustment);
} else {
final int line;
try {
line = event.translateLineViaDiff(myLogicalCaret.line);
moveToLogicalPosition(
new LogicalPosition(line, myLogicalCaret.column), performSoftWrapAdjustment);
} catch (FilesTooBigForDiffException e1) {
LOG.info(e1);
moveToOffset(0);
}
}
} else {
if (document instanceof DocumentEx && ((DocumentEx) document).isInBulkUpdate()) return;
int startOffset = e.getOffset();
int oldEndOffset = startOffset + e.getOldLength();
int newOffset = myOffset;
if (myOffset > oldEndOffset || myOffset == oldEndOffset && needToShiftWhiteSpaces(e)) {
newOffset += e.getNewLength() - e.getOldLength();
} else if (myOffset >= startOffset && myOffset <= oldEndOffset) {
newOffset = Math.min(newOffset, startOffset + e.getNewLength());
}
newOffset = Math.min(newOffset, document.getTextLength());
// if (newOffset != myOffset) {
moveToOffset(newOffset, performSoftWrapAdjustment);
// }
// else {
// moveToVisualPosition(oldPosition);
// }
}
myVisualLineStart =
myEditor.logicalPositionToOffset(
myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line, 0)));
myVisualLineEnd =
myEditor.logicalPositionToOffset(
myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line + 1, 0)));
}
private boolean isInsideSoftWrap(@NotNull VisualPosition visual, boolean countBeforeSoftWrap) {
if (!isSoftWrappingEnabled()) {
return false;
}
SoftWrapModel model = myEditor.getSoftWrapModel();
if (!model.isSoftWrappingEnabled()) {
return false;
}
LogicalPosition logical = myEditor.visualToLogicalPosition(visual);
int offset = myEditor.logicalPositionToOffset(logical);
if (offset <= 0) {
// Never expect to be here, just a defensive programming.
return false;
}
SoftWrap softWrap = model.getSoftWrap(offset);
if (softWrap == null) {
return false;
}
// We consider visual positions that point after the last symbol before soft wrap and the first
// symbol after soft wrap to not
// belong to soft wrap-introduced virtual space.
VisualPosition visualAfterSoftWrap = myEditor.offsetToVisualPosition(offset);
if (visualAfterSoftWrap.line == visual.line && visualAfterSoftWrap.column <= visual.column) {
return false;
}
if (myEditor.myUseNewRendering) {
VisualPosition beforeSoftWrap = myEditor.offsetToVisualPosition(offset, true, true);
return visual.line > beforeSoftWrap.line
|| visual.column > beforeSoftWrap.column
|| visual.column == beforeSoftWrap.column && countBeforeSoftWrap;
} else {
VisualPosition visualBeforeSoftWrap = myEditor.offsetToVisualPosition(offset - 1);
int x = 0;
LogicalPosition logLineStart =
myEditor.visualToLogicalPosition(new VisualPosition(visualBeforeSoftWrap.line, 0));
if (logLineStart.softWrapLinesOnCurrentLogicalLine > 0) {
int offsetLineStart = myEditor.logicalPositionToOffset(logLineStart);
softWrap = model.getSoftWrap(offsetLineStart);
if (softWrap != null) {
x = softWrap.getIndentInPixels();
}
}
int width =
EditorUtil.textWidthInColumns(
myEditor, myEditor.getDocument().getCharsSequence(), offset - 1, offset, x);
int softWrapStartColumn = visualBeforeSoftWrap.column + width;
if (visual.line > visualBeforeSoftWrap.line) {
return true;
}
return countBeforeSoftWrap
? visual.column >= softWrapStartColumn
: visual.column > softWrapStartColumn;
}
}
public void moveToOffset(int offset, boolean locateBeforeSoftWrap) {
assertIsDispatchThread();
validateCallContext();
moveToLogicalPosition(myEditor.offsetToLogicalPosition(offset), locateBeforeSoftWrap);
if (!ignoreWrongMoves
&& !myEditor
.offsetToLogicalPosition(myOffset)
.equals(myEditor.offsetToLogicalPosition(offset))) {
LOG.error(
"caret moved to wrong offset. Requested:"
+ offset
+ " but actual:"
+ myOffset
+ ". Soft wraps data: "
+ myEditor.getSoftWrapModel()
+ ", folding data: "
+ myEditor.getFoldingModel());
}
}
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);
}
public void moveCaretRelatively(
int columnShift,
int lineShift,
boolean withSelection,
boolean blockSelection,
boolean scrollToCaret) {
assertIsDispatchThread();
SelectionModel selectionModel = myEditor.getSelectionModel();
int selectionStart = selectionModel.getLeadSelectionOffset();
LogicalPosition blockSelectionStart =
selectionModel.hasBlockSelection() ? selectionModel.getBlockStart() : getLogicalPosition();
EditorSettings editorSettings = myEditor.getSettings();
VisualPosition visualCaret = getVisualPosition();
int desiredX = myDesiredX;
if (columnShift == 0) {
if (myDesiredX < 0) {
desiredX = myEditor.visualPositionToXY(visualCaret).x;
}
} else {
myDesiredX = desiredX = -1;
}
int newLineNumber = visualCaret.line + lineShift;
int newColumnNumber = visualCaret.column + columnShift;
if (desiredX >= 0 && !ApplicationManager.getApplication().isUnitTestMode()) {
newColumnNumber =
myEditor.xyToVisualPosition(
new Point(desiredX, Math.max(0, newLineNumber) * myEditor.getLineHeight()))
.column;
}
Document document = myEditor.getDocument();
if (!editorSettings.isVirtualSpace()
&& columnShift == 0
&& getLogicalPosition().softWrapLinesOnCurrentLogicalLine <= 0) {
newColumnNumber = myEditor.getLastColumnNumber();
} else if (!editorSettings.isVirtualSpace() && lineShift == 0 && columnShift == 1) {
int lastLine = document.getLineCount() - 1;
if (lastLine < 0) lastLine = 0;
if (EditorModificationUtil.calcAfterLineEnd(myEditor) >= 0
&& newLineNumber
< myEditor.logicalToVisualPosition(new LogicalPosition(lastLine, 0)).line) {
newColumnNumber = 0;
newLineNumber++;
}
} else if (!editorSettings.isVirtualSpace() && lineShift == 0 && columnShift == -1) {
if (newColumnNumber < 0 && newLineNumber > 0) {
newLineNumber--;
newColumnNumber = EditorUtil.getLastVisualLineColumnNumber(myEditor, newLineNumber);
}
}
if (newColumnNumber < 0) newColumnNumber = 0;
// There is a possible case that caret is located at the first line and user presses 'Shift+Up'.
// We want to select all text
// from the document start to the current caret position then. So, we have a dedicated flag for
// tracking that.
boolean selectToDocumentStart = false;
if (newLineNumber < 0) {
selectToDocumentStart = true;
newLineNumber = 0;
// We want to move caret to the first column if it's already located at the first line and
// 'Up' is pressed.
newColumnNumber = 0;
desiredX = -1;
}
VisualPosition pos = new VisualPosition(newLineNumber, newColumnNumber);
int lastColumnNumber = newColumnNumber;
if (!editorSettings.isCaretInsideTabs() && !myEditor.getSoftWrapModel().isInsideSoftWrap(pos)) {
LogicalPosition log =
myEditor.visualToLogicalPosition(new VisualPosition(newLineNumber, newColumnNumber));
int offset = myEditor.logicalPositionToOffset(log);
if (offset >= document.getTextLength()) {
int lastOffsetColumn = myEditor.offsetToVisualPosition(document.getTextLength()).column;
// We want to move caret to the last column if if it's located at the last line and 'Down'
// is pressed.
newColumnNumber = lastColumnNumber = Math.max(lastOffsetColumn, newColumnNumber);
desiredX = -1;
}
CharSequence text = document.getCharsSequence();
if (offset >= 0 && offset < document.getTextLength()) {
if (text.charAt(offset) == '\t' && (columnShift <= 0 || offset == myOffset)) {
if (columnShift <= 0) {
newColumnNumber = myEditor.offsetToVisualPosition(offset).column;
} else {
SoftWrap softWrap = myEditor.getSoftWrapModel().getSoftWrap(offset + 1);
// There is a possible case that tabulation symbol is the last document symbol
// represented on a visual line before
// soft wrap. We can't just use column from 'offset + 1' because it would point on a
// next visual line.
if (softWrap == null) {
newColumnNumber = myEditor.offsetToVisualPosition(offset + 1).column;
} else {
newColumnNumber = EditorUtil.getLastVisualLineColumnNumber(myEditor, newLineNumber);
}
}
}
}
}
pos = new VisualPosition(newLineNumber, newColumnNumber);
if (columnShift != 0 && lineShift == 0 && myEditor.getSoftWrapModel().isInsideSoftWrap(pos)) {
LogicalPosition logical = myEditor.visualToLogicalPosition(pos);
int softWrapOffset = myEditor.logicalPositionToOffset(logical);
if (columnShift >= 0) {
moveToOffset(softWrapOffset);
} else {
int line = myEditor.offsetToVisualLine(softWrapOffset - 1);
moveToVisualPosition(
new VisualPosition(line, EditorUtil.getLastVisualLineColumnNumber(myEditor, line)));
}
} else {
moveToVisualPosition(pos);
if (!editorSettings.isVirtualSpace() && columnShift == 0) {
myEditor.setLastColumnNumber(lastColumnNumber);
}
}
if (withSelection) {
if (blockSelection) {
selectionModel.setBlockSelection(blockSelectionStart, getLogicalPosition());
} else {
if (selectToDocumentStart) {
selectionModel.setSelection(selectionStart, 0);
} else if (pos.line >= myEditor.getVisibleLineCount()) {
if (selectionStart < document.getTextLength()) {
selectionModel.setSelection(selectionStart, document.getTextLength());
}
} else {
selectionModel.setSelection(selectionStart, getVisualPosition(), getOffset());
}
}
} else {
selectionModel.removeSelection();
}
if (scrollToCaret) {
myEditor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
}
if (desiredX >= 0) {
myDesiredX = desiredX;
}
EditorActionUtil.selectNonexpandableFold(myEditor);
}