private void removeFromEditor() {
Editor editor = mySearchResults.getEditor();
if (myReplacementBalloon != null) {
myReplacementBalloon.hide();
}
if (editor != null) {
for (VisibleAreaListener visibleAreaListener : myVisibleAreaListenersToRemove) {
editor.getScrollingModel().removeVisibleAreaListener(visibleAreaListener);
}
myVisibleAreaListenersToRemove.clear();
Project project = mySearchResults.getProject();
if (project != null && !project.isDisposed()) {
for (RangeHighlighter h : myHighlighters) {
HighlightManager.getInstance(project).removeSegmentHighlighter(editor, h);
}
if (myCursorHighlighter != null) {
HighlightManager.getInstance(project)
.removeSegmentHighlighter(editor, myCursorHighlighter);
myCursorHighlighter = null;
}
}
myHighlighters.clear();
if (myListeningSelection) {
editor.getSelectionModel().removeSelectionListener(this);
myListeningSelection = false;
}
}
}
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;
}
/**
* Applies given caret/selection state to the editor. Editor text must have been set up
* previously.
*/
public static void setCaretsAndSelection(Editor editor, CaretAndSelectionState caretsState) {
CaretModel caretModel = editor.getCaretModel();
if (caretModel.supportsMultipleCarets()) {
List<CaretState> states = new ArrayList<CaretState>(caretsState.carets.size());
for (CaretInfo caret : caretsState.carets) {
states.add(
new CaretState(
caret.position == null
? null
: editor.offsetToLogicalPosition(caret.getCaretOffset(editor.getDocument())),
caret.selection == null
? null
: editor.offsetToLogicalPosition(caret.selection.getStartOffset()),
caret.selection == null
? null
: editor.offsetToLogicalPosition(caret.selection.getEndOffset())));
}
caretModel.setCaretsAndSelections(states);
} else {
assertEquals("Multiple carets are not supported by the model", 1, caretsState.carets.size());
CaretInfo caret = caretsState.carets.get(0);
if (caret.position != null) {
caretModel.moveToOffset(caret.getCaretOffset(editor.getDocument()));
}
if (caret.selection != null) {
editor
.getSelectionModel()
.setSelection(caret.selection.getStartOffset(), caret.selection.getEndOffset());
} else {
editor.getSelectionModel().removeSelection();
}
}
if (caretsState.blockSelection != null) {
editor
.getSelectionModel()
.setBlockSelection(
editor.offsetToLogicalPosition(caretsState.blockSelection.getStartOffset()),
editor.offsetToLogicalPosition(caretsState.blockSelection.getEndOffset()));
}
}
private void dumpEditorMarkupAndSelection(PrintStream dumpStream) {
dumpStream.println(mySearchResults.getFindModel());
if (myReplacementPreviewText != null) {
dumpStream.println("--");
dumpStream.println("Replacement Preview: " + myReplacementPreviewText);
}
dumpStream.println("--");
Editor editor = mySearchResults.getEditor();
RangeHighlighter[] highlighters = editor.getMarkupModel().getAllHighlighters();
List<Pair<Integer, Character>> ranges = new ArrayList<Pair<Integer, Character>>();
for (RangeHighlighter highlighter : highlighters) {
ranges.add(new Pair<Integer, Character>(highlighter.getStartOffset(), '['));
ranges.add(new Pair<Integer, Character>(highlighter.getEndOffset(), ']'));
}
SelectionModel selectionModel = editor.getSelectionModel();
if (selectionModel.getSelectionStart() != selectionModel.getSelectionEnd()) {
ranges.add(new Pair<Integer, Character>(selectionModel.getSelectionStart(), '<'));
ranges.add(new Pair<Integer, Character>(selectionModel.getSelectionEnd(), '>'));
}
ranges.add(new Pair<Integer, Character>(-1, '\n'));
ranges.add(new Pair<Integer, Character>(editor.getDocument().getTextLength() + 1, '\n'));
ContainerUtil.sort(
ranges,
new Comparator<Pair<Integer, Character>>() {
@Override
public int compare(Pair<Integer, Character> pair, Pair<Integer, Character> pair2) {
int res = pair.first - pair2.first;
if (res == 0) {
Character c1 = pair.second;
Character c2 = pair2.second;
if (c1 == '<' && c2 == '[') {
return 1;
} else if (c1 == '[' && c2 == '<') {
return -1;
}
return c1.compareTo(c2);
}
return res;
}
});
Document document = editor.getDocument();
for (int i = 0; i < ranges.size() - 1; ++i) {
Pair<Integer, Character> pair = ranges.get(i);
Pair<Integer, Character> pair1 = ranges.get(i + 1);
dumpStream.print(
pair.second
+ document.getText(
TextRange.create(
Math.max(pair.first, 0), Math.min(pair1.first, document.getTextLength()))));
}
dumpStream.println("\n--");
if (NotFound) {
dumpStream.println("Not Found");
dumpStream.println("--");
NotFound = false;
}
for (RangeHighlighter highlighter : highlighters) {
dumpStream.println(highlighter + " : " + highlighter.getTextAttributes());
}
dumpStream.println("------------");
}
private void addListeners() {
myEditor
.getDocument()
.addDocumentListener(
new DocumentAdapter() {
@Override
public void documentChanged(DocumentEvent e) {
if (!myChangeGuard && !myFinishing) {
hide();
}
}
},
this);
final CaretListener caretListener =
new CaretAdapter() {
@Override
public void caretPositionChanged(CaretEvent e) {
if (!myChangeGuard && !myFinishing) {
hide();
}
}
};
final SelectionListener selectionListener =
new SelectionListener() {
@Override
public void selectionChanged(final SelectionEvent e) {
if (!myChangeGuard && !myFinishing) {
hide();
}
}
};
final EditorMouseListener mouseListener =
new EditorMouseAdapter() {
@Override
public void mouseClicked(EditorMouseEvent e) {
e.consume();
hide();
}
};
myEditor.getCaretModel().addCaretListener(caretListener);
myEditor.getSelectionModel().addSelectionListener(selectionListener);
myEditor.addEditorMouseListener(mouseListener);
Disposer.register(
this,
new Disposable() {
@Override
public void dispose() {
myEditor.getCaretModel().removeCaretListener(caretListener);
myEditor.getSelectionModel().removeSelectionListener(selectionListener);
myEditor.removeEditorMouseListener(mouseListener);
}
});
JComponent editorComponent = myEditor.getContentComponent();
if (editorComponent.isShowing()) {
Disposer.register(
this,
new UiNotifyConnector(
editorComponent,
new Activatable() {
@Override
public void showNotify() {}
@Override
public void hideNotify() {
hideLookup(false);
}
}));
}
myList.addListSelectionListener(
new ListSelectionListener() {
private LookupElement oldItem = null;
@Override
public void valueChanged(@NotNull ListSelectionEvent e) {
if (!myUpdating) {
final LookupElement item = getCurrentItem();
fireCurrentItemChanged(oldItem, item);
oldItem = item;
}
}
});
new ClickListener() {
@Override
public boolean onClick(@NotNull MouseEvent e, int clickCount) {
setFocusDegree(FocusDegree.FOCUSED);
markSelectionTouched();
if (clickCount == 2) {
CommandProcessor.getInstance()
.executeCommand(
myProject,
new Runnable() {
@Override
public void run() {
finishLookup(NORMAL_SELECT_CHAR);
}
},
"",
null);
}
return true;
}
}.installOn(myList);
}
@Nullable
@Override
public TextBlockTransferableData collectTransferableData(
PsiFile file, Editor editor, int[] startOffsets, int[] endOffsets) {
if (!Registry.is("editor.richcopy.enable")) {
return null;
}
try {
for (TextWithMarkupBuilder builder : myBuilders) {
builder.reset();
}
SelectionModel selectionModel = editor.getSelectionModel();
if (selectionModel.hasBlockSelection()) {
return null; // unsupported legacy mode
}
RichCopySettings settings = RichCopySettings.getInstance();
List<Caret> carets = editor.getCaretModel().getAllCarets();
Caret firstCaret = carets.get(0);
final int indentSymbolsToStrip;
final int firstLineStartOffset;
if (settings.isStripIndents() && carets.size() == 1) {
Pair<Integer, Integer> p =
calcIndentSymbolsToStrip(
editor.getDocument(), firstCaret.getSelectionStart(), firstCaret.getSelectionEnd());
firstLineStartOffset = p.first;
indentSymbolsToStrip = p.second;
} else {
firstLineStartOffset = firstCaret.getSelectionStart();
indentSymbolsToStrip = 0;
}
logInitial(editor, startOffsets, endOffsets, indentSymbolsToStrip, firstLineStartOffset);
CharSequence text = editor.getDocument().getCharsSequence();
EditorColorsScheme schemeToUse = settings.getColorsScheme(editor.getColorsScheme());
EditorHighlighter highlighter =
HighlighterFactory.createHighlighter(
file.getVirtualFile(), schemeToUse, file.getProject());
highlighter.setText(text);
MarkupModel markupModel =
DocumentMarkupModel.forDocument(editor.getDocument(), file.getProject(), false);
Context context = new Context(text, schemeToUse, indentSymbolsToStrip);
int shift = 0;
int endOffset = 0;
Caret prevCaret = null;
for (Caret caret : carets) {
int caretSelectionStart = caret.getSelectionStart();
int caretSelectionEnd = caret.getSelectionEnd();
int startOffsetToUse;
if (caret == firstCaret) {
startOffsetToUse = firstLineStartOffset;
} else {
startOffsetToUse = caretSelectionStart;
assert prevCaret != null;
String prevCaretSelectedText = prevCaret.getSelectedText();
// Block selection fills short lines by white spaces.
int fillStringLength =
prevCaretSelectedText == null
? 0
: prevCaretSelectedText.length()
- (prevCaret.getSelectionEnd() - prevCaret.getSelectionStart());
int endLineOffset = endOffset + shift + fillStringLength;
context.builder.addText(endLineOffset, endLineOffset + 1);
shift++; // Block selection ends '\n' at line end
shift += fillStringLength;
}
shift += endOffset - caretSelectionStart;
endOffset = caretSelectionEnd;
context.reset(shift);
prevCaret = caret;
if (endOffset <= startOffsetToUse) {
continue;
}
MarkupIterator markupIterator =
new MarkupIterator(
text,
new CompositeRangeIterator(
schemeToUse,
new HighlighterRangeIterator(highlighter, startOffsetToUse, endOffset),
new MarkupModelRangeIterator(
markupModel, schemeToUse, startOffsetToUse, endOffset)),
schemeToUse);
try {
context.iterate(markupIterator, endOffset);
} finally {
markupIterator.dispose();
}
}
SyntaxInfo syntaxInfo = context.finish();
logSyntaxInfo(syntaxInfo);
for (TextWithMarkupBuilder builder : myBuilders) {
builder.build(syntaxInfo);
}
} catch (Exception e) {
// catching the exception so that the rest of copy/paste functionality can still work fine
LOG.error(e);
}
return null;
}
