private ProperTextRange offsetToYPosition(int start, int end) {
if (myEditorScrollbarTop == -1 || myEditorTargetHeight == -1) {
recalcEditorDimensions();
}
Document document = myEditor.getDocument();
int startLineNumber = offsetToLine(start, document);
int startY;
int lineCount;
if (myEditorSourceHeight < myEditorTargetHeight) {
lineCount = 0;
startY = myEditorScrollbarTop + startLineNumber * myEditor.getLineHeight();
} else {
lineCount = myEditorSourceHeight / myEditor.getLineHeight();
startY =
myEditorScrollbarTop + (int) ((float) startLineNumber / lineCount * myEditorTargetHeight);
}
int endY;
if (document.getLineNumber(start) == document.getLineNumber(end)) {
endY = startY; // both offsets are on the same line, no need to recalc Y position
} else {
int endLineNumber = offsetToLine(end, document);
if (myEditorSourceHeight < myEditorTargetHeight) {
endY = myEditorScrollbarTop + endLineNumber * myEditor.getLineHeight();
} else {
endY =
myEditorScrollbarTop + (int) ((float) endLineNumber / lineCount * myEditorTargetHeight);
}
if (endY < startY) endY = startY;
}
return new ProperTextRange(startY, endY);
}
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 CaretModelImpl(EditorImpl editor) {
myEditor = editor;
myLogicalCaret = new LogicalPosition(0, 0);
myVisibleCaret = new VisualPosition(0, 0);
myCaretInfo = new VerticalInfo(0, 0);
myOffset = 0;
myVisualLineStart = 0;
Document doc = editor.getDocument();
myVisualLineEnd =
doc.getLineCount() > 1
? doc.getLineStartOffset(1)
: doc.getLineCount() == 0 ? 0 : doc.getLineEndOffset(0);
DocumentBulkUpdateListener bulkUpdateListener =
new DocumentBulkUpdateListener() {
@Override
public void updateStarted(Document doc) {
if (doc != myEditor.getDocument()) return;
savedBeforeBulkCaretMarker = doc.createRangeMarker(myOffset, myOffset);
}
@Override
public void updateFinished(Document doc) {
if (doc != myEditor.getDocument() || myIsInUpdate) return;
if (savedBeforeBulkCaretMarker != null && savedBeforeBulkCaretMarker.isValid()) {
moveToOffset(savedBeforeBulkCaretMarker.getStartOffset());
}
releaseBulkCaretMarker();
}
};
ApplicationManager.getApplication()
.getMessageBus()
.connect(this)
.subscribe(DocumentBulkUpdateListener.TOPIC, bulkUpdateListener);
}
public int getFoldedLinesCountBefore(int offset) {
if (!myDocumentChangeProcessed && myEditor.getDocument().isInEventsHandling()) {
// There is a possible case that this method is called on document update before fold regions
// are recalculated.
// We return zero in such situations then.
return 0;
}
return myFoldTree.getFoldedLinesCountBefore(offset);
}
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;
}
}
private boolean needToShiftWhiteSpaces(final DocumentEvent e) {
if (!CharArrayUtil.containsOnlyWhiteSpaces(e.getNewFragment())
|| CharArrayUtil.containLineBreaks(e.getNewFragment())) return e.getOldLength() > 0;
if (e.getOffset() == 0) return false;
final char charBefore = myEditor.getDocument().getCharsSequence().charAt(e.getOffset() - 1);
// final char charAfter = myEditor.getDocument().getCharsSequence().charAt(e.getOffset() +
// e.getNewLength());
return Character.isWhitespace(charBefore) /* || !Character.isWhitespace(charAfter)*/;
}
@Override
@Nullable
public FoldRegion getFoldingPlaceholderAt(Point p) {
assertReadAccess();
LogicalPosition pos = myEditor.xyToLogicalPosition(p);
int line = pos.line;
if (line >= myEditor.getDocument().getLineCount()) return null;
int offset = myEditor.logicalPositionToOffset(pos);
return myFoldTree.fetchOutermost(offset);
}
@Override
public List<? extends SoftWrap> getRegisteredSoftWraps() {
if (!isSoftWrappingEnabled()) {
return Collections.emptyList();
}
List<SoftWrapImpl> softWraps = myStorage.getSoftWraps();
if (!softWraps.isEmpty()
&& softWraps.get(softWraps.size() - 1).getStart()
>= myEditor.getDocument().getTextLength()) {
LOG.error(
"Unexpected soft wrap location", new Attachment("editorState.txt", myEditor.dumpState()));
}
return softWraps;
}
private boolean showToolTipByMouseMove(final MouseEvent e, final double width) {
MouseEvent me = e;
Set<RangeHighlighter> highlighters = new THashSet<RangeHighlighter>();
getNearestHighlighters(this, me, width, highlighters);
getNearestHighlighters(
(MarkupModelEx) myEditor.getDocument().getMarkupModel(getEditor().getProject()),
me,
width,
highlighters);
if (highlighters.isEmpty()) return false;
int minDelta = Integer.MAX_VALUE;
int y = e.getY();
for (RangeHighlighter each : highlighters) {
ProperTextRange range = offsetToYPosition(each.getStartOffset(), each.getEndOffset());
int eachStartY = range.getStartOffset();
int eachEndY = range.getEndOffset();
int eachY = eachStartY + (eachEndY - eachStartY) / 2;
if (Math.abs(e.getY() - eachY) < minDelta) {
y = eachY;
}
}
me =
new MouseEvent(
(Component) e.getSource(),
e.getID(),
e.getWhen(),
e.getModifiers(),
e.getX(),
y + 1,
e.getClickCount(),
e.isPopupTrigger());
TooltipRenderer bigRenderer = myTooltipRendererProvider.calcTooltipRenderer(highlighters);
if (bigRenderer != null) {
showTooltip(
me,
bigRenderer,
new HintHint(me).setAwtTooltip(true).setPreferredPosition(Balloon.Position.atLeft));
return true;
}
return false;
}
/**
* Encapsulates preparations for performing document dimension mapping (e.g. visual to logical
* position) and answers if soft wraps-aware processing should be used (e.g. there is no need to
* consider soft wraps if user configured them not to be used).
*
* @return <code>true</code> if soft wraps-aware processing should be used; <code>false</code>
* otherwise
*/
private boolean prepareToMapping() {
boolean useSoftWraps =
myActive <= 0 && isSoftWrappingEnabled() && myEditor.getDocument().getTextLength() > 0;
if (!useSoftWraps) {
return false;
}
if (myDirty) {
myApplianceManager.reset();
myDeferredFoldRegions.clear();
myDirty = false;
}
return myApplianceManager.recalculateIfNecessary();
}
/**
* Encapsulates preparations for performing document dimension mapping (e.g. visual to logical
* position) and answers if soft wraps-aware processing should be used (e.g. there is no need to
* consider soft wraps if user configured them not to be used).
*
* @return <code>true</code> if soft wraps-aware processing should be used; <code>false</code>
* otherwise
*/
private boolean prepareToMapping() {
if (myUpdateInProgress
|| myBulkUpdateInProgress
|| myActive > 0
|| !isSoftWrappingEnabled()
|| myEditor.getDocument().getTextLength() <= 0) {
return false;
}
if (myDirty) {
myApplianceManager.reset();
myDeferredFoldRegions.clear();
myDirty = false;
}
return myApplianceManager.recalculateIfNecessary();
}
@Override
@NotNull
public List<? extends SoftWrap> getSoftWrapsForLine(int documentLine) {
if (!isSoftWrappingEnabled() || documentLine < 0) {
return Collections.emptyList();
}
Document document = myEditor.getDocument();
if (documentLine >= document.getLineCount()) {
return Collections.emptyList();
}
int start = document.getLineStartOffset(documentLine);
int end = document.getLineEndOffset(documentLine);
return getSoftWrapsForRange(
start,
end
+ 1 /* it's theoretically possible that soft wrap is registered just before the line feed,
* hence, we add '1' here assuming that end line offset points to line feed symbol */);
}
@Override
public void beforeDocumentChangeAtCaret() {
CaretModel caretModel = myEditor.getCaretModel();
VisualPosition visualCaretPosition = caretModel.getVisualPosition();
if (!isInsideSoftWrap(visualCaretPosition)) {
return;
}
SoftWrap softWrap = myStorage.getSoftWrap(caretModel.getOffset());
if (softWrap == null) {
return;
}
myEditor
.getDocument()
.replaceString(softWrap.getStart(), softWrap.getEnd(), softWrap.getText());
caretModel.moveToVisualPosition(visualCaretPosition);
}
private int yPositionToOffset(int y, boolean beginLine) {
if (myEditorScrollbarTop == -1 || myEditorTargetHeight == -1) {
recalcEditorDimensions();
}
final int safeY = Math.max(0, y - myEditorScrollbarTop);
VisualPosition visual;
if (myEditorSourceHeight < myEditorTargetHeight) {
visual = myEditor.xyToVisualPosition(new Point(0, safeY));
} else {
float fraction = Math.max(0, Math.min(1, safeY / (float) myEditorTargetHeight));
final int lineCount = myEditorSourceHeight / myEditor.getLineHeight();
visual = new VisualPosition((int) (fraction * lineCount), 0);
}
int line = myEditor.visualToLogicalPosition(visual).line;
Document document = myEditor.getDocument();
if (line < 0) return 0;
if (line >= document.getLineCount()) return document.getTextLength();
return beginLine ? document.getLineStartOffset(line) : document.getLineEndOffset(line);
}
public void doClick(final MouseEvent e, final int width) {
RangeHighlighter marker = getNearestRangeHighlighter(e, width);
if (marker == null) return;
int offset = marker.getStartOffset();
final Document doc = myEditor.getDocument();
if (doc.getLineCount() > 0) {
// Necessary to expand folded block even if navigating just before one
// Very useful when navigating to first unused import statement.
int lineEnd = doc.getLineEndOffset(doc.getLineNumber(offset));
myEditor.getCaretModel().moveToOffset(lineEnd);
}
myEditor.getCaretModel().moveToOffset(offset);
myEditor.getSelectionModel().removeSelection();
ScrollingModel scrollingModel = myEditor.getScrollingModel();
scrollingModel.disableAnimation();
scrollingModel.scrollToCaret(ScrollType.CENTER);
scrollingModel.enableAnimation();
fireErrorMarkerClicked(marker, e);
}
public void paintHighlighters(EditorHighlighter highlighter) {
int startOffset = startOfLineByOffset(myStartOffset);
if (startOffset < 0 || startOffset >= myEditor.getDocument().getTextLength()) return;
RangeIterator iterator =
new RangeIterator(
new FoldingOrNewLineGaps(myEditor),
SAME_COLOR_BOXES,
highlighter.createIterator(startOffset),
BOX_FILTER);
iterator.init(myRange);
while (!iterator.atEnd()) {
iterator.advance();
paintBorder(
myGraphics,
myEditor,
iterator.getStart(),
iterator.getEnd(),
iterator.getTextAttributes().getEffectColor(),
iterator.getTextAttributes().getEffectType());
}
}
private RangeHighlighter getNearestRangeHighlighter(final MouseEvent e, final int width) {
List<RangeHighlighter> highlighters = new ArrayList<RangeHighlighter>();
getNearestHighlighters(this, e, width, highlighters);
getNearestHighlighters(
(MarkupModelEx) myEditor.getDocument().getMarkupModel(myEditor.getProject()),
e,
width,
highlighters);
RangeHighlighter nearestMarker = null;
int yPos = 0;
for (RangeHighlighter highlighter : highlighters) {
final int newYPos =
offsetToYPosition(highlighter.getStartOffset(), highlighter.getEndOffset())
.getStartOffset();
if (nearestMarker == null || Math.abs(yPos - e.getY()) > Math.abs(newYPos - e.getY())) {
nearestMarker = highlighter;
yPos = newYPos;
}
}
return nearestMarker;
}
private boolean areSoftWrapsEnabledInEditor() {
return myEditor.getSettings().isUseSoftWraps()
&& !myEditor.myUseNewRendering
&& (!(myEditor.getDocument() instanceof DocumentImpl)
|| !((DocumentImpl) myEditor.getDocument()).acceptsSlashR());
}
@Override
public void rebuild() {
if (!myEditor.getDocument().isInBulkUpdate()) {
myFoldTree.rebuild();
}
}
private void notifyBatchFoldingProcessingDone(final boolean moveCaretFromCollapsedRegion) {
rebuild();
for (FoldingListener listener : myListeners) {
listener.onFoldProcessingEnd();
}
myEditor.updateCaretCursor();
myEditor.recalculateSizeAndRepaint();
myEditor.getGutterComponentEx().updateSize();
myEditor.getGutterComponentEx().repaint();
for (Caret caret : myEditor.getCaretModel().getAllCarets()) {
// There is a possible case that caret position is already visual position aware. But visual
// position depends on number of folded
// logical lines as well, hence, we can't be sure that target logical position defines correct
// visual position because fold
// regions have just changed. Hence, we use 'raw' logical position instead.
LogicalPosition caretPosition = caret.getLogicalPosition().withoutVisualPositionInfo();
int caretOffset = myEditor.logicalPositionToOffset(caretPosition);
int selectionStart = caret.getSelectionStart();
int selectionEnd = caret.getSelectionEnd();
LogicalPosition positionToUse = null;
int offsetToUse = -1;
FoldRegion collapsed = myFoldTree.fetchOutermost(caretOffset);
LogicalPosition savedPosition = caret.getUserData(SAVED_CARET_POSITION);
if (savedPosition != null) {
int savedOffset = myEditor.logicalPositionToOffset(savedPosition);
FoldRegion collapsedAtSaved = myFoldTree.fetchOutermost(savedOffset);
if (collapsedAtSaved == null) {
positionToUse = savedPosition;
} else {
offsetToUse = collapsedAtSaved.getStartOffset();
}
}
if (collapsed != null && positionToUse == null) {
positionToUse = myEditor.offsetToLogicalPosition(collapsed.getStartOffset());
}
if (moveCaretFromCollapsedRegion && caret.isUpToDate()) {
if (offsetToUse >= 0) {
caret.moveToOffset(offsetToUse);
} else if (positionToUse != null) {
caret.moveToLogicalPosition(positionToUse);
} else {
caret.moveToLogicalPosition(caretPosition);
}
}
caret.putUserData(SAVED_CARET_POSITION, savedPosition);
if (isOffsetInsideCollapsedRegion(selectionStart)
|| isOffsetInsideCollapsedRegion(selectionEnd)) {
caret.removeSelection();
} else if (selectionStart < myEditor.getDocument().getTextLength()) {
caret.setSelection(selectionStart, selectionEnd);
}
}
if (mySavedCaretShift > 0) {
final ScrollingModel scrollingModel = myEditor.getScrollingModel();
scrollingModel.disableAnimation();
scrollingModel.scrollVertically(
myEditor.visibleLineToY(myEditor.getCaretModel().getVisualPosition().line)
- mySavedCaretShift);
scrollingModel.enableAnimation();
}
}
EditorMarkupModelImpl(@NotNull EditorImpl editor) {
super((DocumentImpl) editor.getDocument());
myEditor = editor;
}
public FoldingOrNewLineGaps(EditorImpl editor) {
this(
editor.getDocument().getCharsSequence(),
new RangeIterator.FoldingGaps(editor.getFoldingModel()));
}
private int startOfLineByOffset(int offset) {
int line = myEditor.offsetToLogicalLine(offset);
if (line >= myEditor.getDocument().getLineCount()) return -1;
return myEditor.getDocument().getLineStartOffset(line);
}
EditorPainter(EditorView view) {
myView = view;
myEditor = view.getEditor();
myDocument = myEditor.getDocument();
}
private void doNotifyBatchFoldingProcessingDone() {
myFoldTree.rebuild();
for (FoldingListener listener : myListeners) {
listener.onFoldProcessingEnd();
}
myEditor.updateCaretCursor();
myEditor.recalculateSizeAndRepaint();
if (myEditor.getGutterComponentEx().isFoldingOutlineShown()) {
myEditor.getGutterComponentEx().repaint();
}
LogicalPosition caretPosition = myEditor.getCaretModel().getLogicalPosition();
// There is a possible case that caret position is already visual position aware. But visual
// position depends on number of folded
// logical lines as well, hence, we can't be sure that target logical position defines correct
// visual position because fold
// regions have just changed. Hence, we use 'raw' logical position instead.
if (caretPosition.visualPositionAware) {
caretPosition = new LogicalPosition(caretPosition.line, caretPosition.column);
}
int caretOffset = myEditor.logicalPositionToOffset(caretPosition);
boolean hasBlockSelection = myEditor.getSelectionModel().hasBlockSelection();
int selectionStart = myEditor.getSelectionModel().getSelectionStart();
int selectionEnd = myEditor.getSelectionModel().getSelectionEnd();
int column = -1;
int line = -1;
int offsetToUse = -1;
FoldRegion collapsed = myFoldTree.fetchOutermost(caretOffset);
if (myCaretPositionSaved) {
int savedOffset =
myEditor.logicalPositionToOffset(new LogicalPosition(mySavedCaretY, mySavedCaretX));
FoldRegion collapsedAtSaved = myFoldTree.fetchOutermost(savedOffset);
if (collapsedAtSaved == null) {
column = mySavedCaretX;
line = mySavedCaretY;
} else {
offsetToUse = collapsedAtSaved.getStartOffset();
}
}
if (collapsed != null && column == -1) {
line = collapsed.getDocument().getLineNumber(collapsed.getStartOffset());
column = myEditor.offsetToLogicalPosition(collapsed.getStartOffset()).column;
}
boolean oldCaretPositionSaved = myCaretPositionSaved;
if (offsetToUse >= 0) {
myEditor.getCaretModel().moveToOffset(offsetToUse);
} else if (column != -1) {
myEditor.getCaretModel().moveToLogicalPosition(new LogicalPosition(line, column));
} else {
myEditor.getCaretModel().moveToLogicalPosition(caretPosition);
}
myCaretPositionSaved = oldCaretPositionSaved;
if (!hasBlockSelection && selectionStart < myEditor.getDocument().getTextLength()) {
myEditor.getSelectionModel().setSelection(selectionStart, selectionEnd);
}
if (mySavedCaretShift > 0) {
myEditor.getScrollingModel().disableAnimation();
int scrollTo =
myEditor.visibleLineToY(myEditor.getCaretModel().getVisualPosition().line)
- mySavedCaretShift;
myEditor.getScrollingModel().scrollVertically(scrollTo);
myEditor.getScrollingModel().enableAnimation();
}
}
public void moveToVisualPosition(@NotNull VisualPosition pos) {
assertIsDispatchThread();
validateCallContext();
myDesiredX = -1;
int column = pos.column;
int line = pos.line;
if (column < 0) column = 0;
if (line < 0) line = 0;
int lastLine = myEditor.getVisibleLineCount() - 1;
if (lastLine <= 0) {
lastLine = 0;
}
if (line > lastLine) {
line = lastLine;
}
EditorSettings editorSettings = myEditor.getSettings();
if (!editorSettings.isVirtualSpace() && line <= lastLine) {
int lineEndColumn = EditorUtil.getLastVisualLineColumnNumber(myEditor, line);
if (column > lineEndColumn) {
column = lineEndColumn;
}
if (column < 0 && line > 0) {
line--;
column = EditorUtil.getLastVisualLineColumnNumber(myEditor, line);
}
}
myVisibleCaret = new VisualPosition(line, column);
VerticalInfo oldInfo = myCaretInfo;
LogicalPosition oldPosition = myLogicalCaret;
setCurrentLogicalCaret(myEditor.visualToLogicalPosition(myVisibleCaret));
myOffset = myEditor.logicalPositionToOffset(myLogicalCaret);
LOG.assertTrue(myOffset >= 0 && myOffset <= myEditor.getDocument().getTextLength());
myVisualLineStart =
myEditor.logicalPositionToOffset(
myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line, 0)));
myVisualLineEnd =
myEditor.logicalPositionToOffset(
myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line + 1, 0)));
((FoldingModelImpl) myEditor.getFoldingModel()).flushCaretPosition();
myEditor.setLastColumnNumber(myVisibleCaret.column);
myEditor.updateCaretCursor();
requestRepaint(oldInfo);
if (oldPosition.column != myLogicalCaret.column || oldPosition.line != myLogicalCaret.line) {
CaretEvent event = new CaretEvent(myEditor, oldPosition, myLogicalCaret);
for (CaretListener listener : myCaretListeners) {
listener.caretPositionChanged(event);
}
}
}
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);
}
private void moveToLogicalPosition(LogicalPosition pos, boolean locateBeforeSoftWrap) {
assertIsDispatchThread();
myDesiredX = -1;
validateCallContext();
int column = pos.column;
int line = pos.line;
int softWrapLinesBefore = pos.softWrapLinesBeforeCurrentLogicalLine;
int softWrapLinesCurrent = pos.softWrapLinesOnCurrentLogicalLine;
int softWrapColumns = pos.softWrapColumnDiff;
Document doc = myEditor.getDocument();
if (column < 0) {
column = 0;
softWrapColumns = 0;
}
if (line < 0) {
line = 0;
softWrapLinesBefore = 0;
softWrapLinesCurrent = 0;
}
int lineCount = doc.getLineCount();
if (lineCount == 0) {
line = 0;
} else if (line > lineCount - 1) {
line = lineCount - 1;
softWrapLinesBefore = 0;
softWrapLinesCurrent = 0;
}
EditorSettings editorSettings = myEditor.getSettings();
if (!editorSettings.isVirtualSpace()
&& line < lineCount
&& !myEditor.getSelectionModel().hasBlockSelection()) {
int lineEndOffset = doc.getLineEndOffset(line);
int lineEndColumnNumber = myEditor.offsetToLogicalPosition(lineEndOffset).column;
if (column > lineEndColumnNumber) {
column = lineEndColumnNumber;
if (softWrapColumns != 0) {
softWrapColumns -= column - lineEndColumnNumber;
}
}
}
((FoldingModelImpl) myEditor.getFoldingModel()).flushCaretPosition();
VerticalInfo oldInfo = myCaretInfo;
LogicalPosition oldCaretPosition = myLogicalCaret;
LogicalPosition logicalPositionToUse;
if (pos.visualPositionAware) {
logicalPositionToUse =
new LogicalPosition(
line,
column,
softWrapLinesBefore,
softWrapLinesCurrent,
softWrapColumns,
pos.foldedLines,
pos.foldingColumnDiff);
} else {
logicalPositionToUse = new LogicalPosition(line, column);
}
setCurrentLogicalCaret(logicalPositionToUse);
final int offset = myEditor.logicalPositionToOffset(myLogicalCaret);
FoldRegion collapsedAt = myEditor.getFoldingModel().getCollapsedRegionAtOffset(offset);
if (collapsedAt != null && offset > collapsedAt.getStartOffset()) {
Runnable runnable =
new Runnable() {
public void run() {
FoldRegion[] allCollapsedAt =
((FoldingModelImpl) myEditor.getFoldingModel()).fetchCollapsedAt(offset);
for (FoldRegion foldRange : allCollapsedAt) {
foldRange.setExpanded(true);
}
}
};
myEditor.getFoldingModel().runBatchFoldingOperation(runnable);
}
myEditor.setLastColumnNumber(myLogicalCaret.column);
myVisibleCaret = myEditor.logicalToVisualPosition(myLogicalCaret);
myOffset = myEditor.logicalPositionToOffset(myLogicalCaret);
LOG.assertTrue(myOffset >= 0 && myOffset <= myEditor.getDocument().getTextLength());
myVisualLineStart =
myEditor.logicalPositionToOffset(
myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line, 0)));
myVisualLineEnd =
myEditor.logicalPositionToOffset(
myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line + 1, 0)));
myEditor.updateCaretCursor();
requestRepaint(oldInfo);
if (locateBeforeSoftWrap && SoftWrapHelper.isCaretAfterSoftWrap(myEditor)) {
int lineToUse = myVisibleCaret.line - 1;
if (lineToUse >= 0) {
moveToVisualPosition(
new VisualPosition(
lineToUse, EditorUtil.getLastVisualLineColumnNumber(myEditor, lineToUse)));
return;
}
}
if (!oldCaretPosition.toVisualPosition().equals(myLogicalCaret.toVisualPosition())) {
CaretEvent event = new CaretEvent(myEditor, oldCaretPosition, myLogicalCaret);
for (CaretListener listener : myCaretListeners) {
listener.caretPositionChanged(event);
}
}
}
