private void updateCursorHighlighting(boolean scroll) {
hideBalloon();
if (myCursorHighlighter != null) {
HighlightManager.getInstance(mySearchResults.getProject())
.removeSegmentHighlighter(mySearchResults.getEditor(), myCursorHighlighter);
myCursorHighlighter = null;
}
final FindResult cursor = mySearchResults.getCursor();
Editor editor = mySearchResults.getEditor();
SelectionModel selection = editor.getSelectionModel();
if (cursor != null) {
Set<RangeHighlighter> dummy = new HashSet<RangeHighlighter>();
highlightRange(
cursor, new TextAttributes(null, null, Color.BLACK, EffectType.ROUNDED_BOX, 0), dummy);
if (!dummy.isEmpty()) {
myCursorHighlighter = dummy.iterator().next();
}
if (scroll) {
if (mySearchResults.getFindModel().isGlobal()) {
FoldingModel foldingModel = editor.getFoldingModel();
final FoldRegion[] allRegions = editor.getFoldingModel().getAllFoldRegions();
foldingModel.runBatchFoldingOperation(
new Runnable() {
@Override
public void run() {
for (FoldRegion region : allRegions) {
if (!region.isValid()) continue;
if (cursor.intersects(TextRange.create(region))) {
region.setExpanded(true);
}
}
}
});
selection.setSelection(cursor.getStartOffset(), cursor.getEndOffset());
editor.getCaretModel().moveToOffset(cursor.getEndOffset());
editor.getScrollingModel().scrollToCaret(ScrollType.CENTER);
} else {
if (!SearchResults.insideVisibleArea(editor, cursor)) {
LogicalPosition pos = editor.offsetToLogicalPosition(cursor.getStartOffset());
editor.getScrollingModel().scrollTo(pos, ScrollType.CENTER);
}
}
}
editor
.getScrollingModel()
.runActionOnScrollingFinished(
new Runnable() {
@Override
public void run() {
showReplacementPreview();
}
});
}
}
/**
* Emulates pressing <code>Enter</code> at current caret position.
*
* @param editor target editor
* @param project target project
* @param shifts two-elements array which is expected to be filled with the following info: 1. The
* first element holds added lines number; 2. The second element holds added symbols number;
*/
private static void emulateEnter(
@NotNull final Editor editor, @NotNull Project project, int[] shifts) {
final DataContext dataContext = prepareContext(editor.getComponent(), project);
int caretOffset = editor.getCaretModel().getOffset();
Document document = editor.getDocument();
SelectionModel selectionModel = editor.getSelectionModel();
int startSelectionOffset = 0;
int endSelectionOffset = 0;
boolean restoreSelection = selectionModel.hasSelection();
if (restoreSelection) {
startSelectionOffset = selectionModel.getSelectionStart();
endSelectionOffset = selectionModel.getSelectionEnd();
selectionModel.removeSelection();
}
int textLengthBeforeWrap = document.getTextLength();
int lineCountBeforeWrap = document.getLineCount();
DataManager.getInstance()
.saveInDataContext(dataContext, WRAP_LONG_LINE_DURING_FORMATTING_IN_PROGRESS_KEY, true);
CommandProcessor commandProcessor = CommandProcessor.getInstance();
try {
Runnable command =
new Runnable() {
@Override
public void run() {
EditorActionManager.getInstance()
.getActionHandler(IdeActions.ACTION_EDITOR_ENTER)
.execute(editor, dataContext);
}
};
if (commandProcessor.getCurrentCommand() == null) {
commandProcessor.executeCommand(editor.getProject(), command, WRAP_LINE_COMMAND_NAME, null);
} else {
command.run();
}
} finally {
DataManager.getInstance()
.saveInDataContext(dataContext, WRAP_LONG_LINE_DURING_FORMATTING_IN_PROGRESS_KEY, null);
}
int symbolsDiff = document.getTextLength() - textLengthBeforeWrap;
if (restoreSelection) {
int newSelectionStart = startSelectionOffset;
int newSelectionEnd = endSelectionOffset;
if (startSelectionOffset >= caretOffset) {
newSelectionStart += symbolsDiff;
}
if (endSelectionOffset >= caretOffset) {
newSelectionEnd += symbolsDiff;
}
selectionModel.setSelection(newSelectionStart, newSelectionEnd);
}
shifts[0] = document.getLineCount() - lineCountBeforeWrap;
shifts[1] = symbolsDiff;
}
public void testRegularSelection() {
// We want to exclude unnecessary indents from the pasted results.
String text =
"package org;\n"
+ "\n"
+ "public class TestClass {\n"
+ "\n"
+ " int field;\n"
+ "\n"
+ " public int getField() {\n"
+ " return field;\n"
+ " }\n"
+ "}";
init(text);
int selectionStart = text.indexOf("public int");
int selectionEnd = text.indexOf('}', selectionStart) + 1;
SelectionModel selectionModel = myFixture.getEditor().getSelectionModel();
selectionModel.setSelection(selectionStart, selectionEnd);
String expected =
"foreground=java.awt.Color[r=0,g=0,b=128],fontStyle=1,text=public int \n"
+ "foreground=java.awt.Color[r=0,g=0,b=0],fontStyle=0,text=getField() {\n"
+ "\n"
+ "text= \n"
+ "foreground=java.awt.Color[r=0,g=0,b=128],fontStyle=1,text=return \n"
+ "foreground=java.awt.Color[r=102,g=14,b=122],text=field\n"
+ "foreground=java.awt.Color[r=0,g=0,b=0],fontStyle=0,text=;\n"
+ "\n"
+ "text=}\n";
TestCase.assertEquals(expected, getSyntaxInfo());
selectionModel.setSelection(selectionStart - 2, selectionEnd);
TestCase.assertEquals(expected, getSyntaxInfo());
selectionModel.setSelection(selectionStart - 4, selectionEnd);
TestCase.assertEquals(expected, getSyntaxInfo());
}
private void handleSelection(Editor editor, SelectionModel selectionModel) {
Document doc = editor.getDocument();
if (doc == null) {
return;
}
int start = selectionModel.getSelectionStart();
int end = selectionModel.getSelectionEnd();
char[] allChars = doc.getChars();
StringBuffer selection = new StringBuffer();
selection.append(allChars, start, end - start);
this.m_transformer.transform(selection);
doc.replaceString(start, end, selection.toString());
selectionModel.setSelection(start, start + selection.length());
}
protected void setTextToEditor(String text) {
myEditor.getMarkupModel().removeAllHighlighters();
myEditor.getDocument().setText(text);
((EditorImpl) myEditor).resetSizes();
myEditor.getHighlighter().setText(text);
if (myTextAttributes != null) {
myEditor
.getMarkupModel()
.addRangeHighlighter(
0,
myEditor.getDocument().getTextLength(),
HighlighterLayer.ADDITIONAL_SYNTAX,
myTextAttributes,
HighlighterTargetArea.EXACT_RANGE);
}
((EditorImpl) myEditor).setPaintSelection(mySelected);
SelectionModel selectionModel = myEditor.getSelectionModel();
selectionModel.setSelection(0, mySelected ? myEditor.getDocument().getTextLength() : 0);
}
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);
}
public void invoke(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) {
myProject = project;
myFile = file.getViewProvider().getPsi(file.getViewProvider().getBaseLanguage());
myEditor = editor;
PsiElement context = myFile.getContext();
if (context != null && (context.textContains('\'') || context.textContains('\"'))) {
String s = context.getText();
if (StringUtil.startsWith(s, "\"") || StringUtil.startsWith(s, "\'")) {
myFile = context.getContainingFile();
myEditor = editor instanceof EditorWindow ? ((EditorWindow) editor).getDelegate() : editor;
}
}
myDocument = myEditor.getDocument();
if (!FileDocumentManager.getInstance().requestWriting(myDocument, project)) {
return;
}
PsiDocumentManager.getInstance(project).commitDocument(myDocument);
FeatureUsageTracker.getInstance().triggerFeatureUsed("codeassists.comment.line");
myCodeStyleManager = CodeStyleManager.getInstance(myProject);
final SelectionModel selectionModel = myEditor.getSelectionModel();
boolean hasSelection = selectionModel.hasSelection();
myStartOffset = selectionModel.getSelectionStart();
myEndOffset = selectionModel.getSelectionEnd();
FoldRegion fold = myEditor.getFoldingModel().getCollapsedRegionAtOffset(myStartOffset);
if (fold != null
&& fold.shouldNeverExpand()
&& fold.getStartOffset() == myStartOffset
&& fold.getEndOffset() == myEndOffset) {
// Foldings that never expand are automatically selected, so the fact it is selected must not
// interfer with commenter's logic
hasSelection = false;
}
if (myDocument.getTextLength() == 0) return;
while (true) {
int lastLineEnd = myDocument.getLineEndOffset(myDocument.getLineNumber(myEndOffset));
FoldRegion collapsedAt = myEditor.getFoldingModel().getCollapsedRegionAtOffset(lastLineEnd);
if (collapsedAt != null) {
final int endOffset = collapsedAt.getEndOffset();
if (endOffset <= myEndOffset) {
break;
}
myEndOffset = endOffset;
} else {
break;
}
}
boolean wholeLinesSelected =
!hasSelection
|| myStartOffset
== myDocument.getLineStartOffset(myDocument.getLineNumber(myStartOffset))
&& myEndOffset
== myDocument.getLineEndOffset(myDocument.getLineNumber(myEndOffset - 1)) + 1;
boolean startingNewLineComment =
!hasSelection
&& isLineEmpty(myDocument.getLineNumber(myStartOffset))
&& !Comparing.equal(
IdeActions.ACTION_COMMENT_LINE,
ActionManagerEx.getInstanceEx().getPrevPreformedActionId());
doComment();
if (startingNewLineComment) {
final Commenter commenter = myCommenters[0];
if (commenter != null) {
String prefix;
if (commenter instanceof SelfManagingCommenter) {
prefix =
((SelfManagingCommenter) commenter)
.getCommentPrefix(
myStartLine,
myDocument,
myCommenterStateMap.get((SelfManagingCommenter) commenter));
if (prefix == null) prefix = ""; // TODO
} else {
prefix = commenter.getLineCommentPrefix();
if (prefix == null) prefix = commenter.getBlockCommentPrefix();
}
int lineStart = myDocument.getLineStartOffset(myStartLine);
lineStart = CharArrayUtil.shiftForward(myDocument.getCharsSequence(), lineStart, " \t");
lineStart += prefix.length();
lineStart = CharArrayUtil.shiftForward(myDocument.getCharsSequence(), lineStart, " \t");
if (lineStart > myDocument.getTextLength()) lineStart = myDocument.getTextLength();
myEditor.getCaretModel().moveToOffset(lineStart);
myEditor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
}
} else {
if (!hasSelection) {
// Don't tweak caret position if we're already located on the last document line.
LogicalPosition position = myEditor.getCaretModel().getLogicalPosition();
if (position.line < myDocument.getLineCount() - 1) {
int verticalShift =
1
+ myEditor.getSoftWrapModel().getSoftWrapsForLine(position.line).size()
- position.softWrapLinesOnCurrentLogicalLine;
myEditor.getCaretModel().moveCaretRelatively(0, verticalShift, false, false, true);
}
} else {
if (wholeLinesSelected) {
selectionModel.setSelection(myStartOffset, selectionModel.getSelectionEnd());
}
}
}
}
