public void printToHistory(String text, final TextAttributes attributes) {
ApplicationManager.getApplication().assertIsDispatchThread();
text = StringUtil.convertLineSeparators(text);
final boolean scrollToEnd = shouldScrollHistoryToEnd();
final Document history = myHistoryViewer.getDocument();
final MarkupModel markupModel = DocumentMarkupModel.forDocument(history, myProject, true);
final int offset = history.getTextLength();
appendToHistoryDocument(history, text);
markupModel.addRangeHighlighter(
offset,
history.getTextLength(),
HighlighterLayer.SYNTAX,
attributes,
HighlighterTargetArea.EXACT_RANGE);
if (scrollToEnd) {
scrollHistoryToEnd();
}
queueUiUpdate(scrollToEnd);
}
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 reparsePsiFile() {
myVirtualFile.setContent(myEditorDocument, myEditorDocument.getText(), false);
FileContentUtil.reparseFiles(
myProject, Collections.<VirtualFile>singletonList(myVirtualFile), false);
myFile = ObjectUtils.assertNotNull(PsiManager.getInstance(myProject).findFile(myVirtualFile));
}
protected void appendToHistoryDocument(@NotNull Document history, @NotNull String text) {
history.insertString(history.getTextLength(), text);
}
protected String addTextRangeToHistory(
TextRange textRange, final EditorEx consoleEditor, boolean preserveMarkup) {
final Document history = myHistoryViewer.getDocument();
final MarkupModel markupModel = DocumentMarkupModel.forDocument(history, myProject, true);
if (myPrompt != null) {
appendToHistoryDocument(history, myPrompt);
}
markupModel.addRangeHighlighter(
history.getTextLength() - StringUtil.length(myPrompt),
history.getTextLength(),
HighlighterLayer.SYNTAX,
ConsoleViewContentType.USER_INPUT.getAttributes(),
HighlighterTargetArea.EXACT_RANGE);
final int localStartOffset = textRange.getStartOffset();
String text;
EditorHighlighter highlighter;
if (consoleEditor instanceof EditorWindow) {
EditorWindow editorWindow = (EditorWindow) consoleEditor;
EditorColorsScheme scheme = EditorColorsManager.getInstance().getGlobalScheme();
PsiFile file = editorWindow.getInjectedFile();
final VirtualFile virtualFile = file.getVirtualFile();
assert virtualFile != null;
highlighter = HighlighterFactory.createHighlighter(virtualFile, scheme, getProject());
String fullText = InjectedLanguageUtil.getUnescapedText(file, null, null);
highlighter.setText(fullText);
text = textRange.substring(fullText);
} else {
text = consoleEditor.getDocument().getText(textRange);
highlighter = consoleEditor.getHighlighter();
}
// offset can be changed after text trimming after insert due to buffer constraints
appendToHistoryDocument(history, text);
int offset = history.getTextLength() - text.length();
final HighlighterIterator iterator = highlighter.createIterator(localStartOffset);
final int localEndOffset = textRange.getEndOffset();
while (!iterator.atEnd()) {
final int itStart = iterator.getStart();
if (itStart > localEndOffset) break;
final int itEnd = iterator.getEnd();
if (itEnd >= localStartOffset) {
final int start = Math.max(itStart, localStartOffset) - localStartOffset + offset;
final int end = Math.min(itEnd, localEndOffset) - localStartOffset + offset;
markupModel.addRangeHighlighter(
start,
end,
HighlighterLayer.SYNTAX,
iterator.getTextAttributes(),
HighlighterTargetArea.EXACT_RANGE);
}
iterator.advance();
}
if (preserveMarkup) {
duplicateHighlighters(
markupModel,
DocumentMarkupModel.forDocument(consoleEditor.getDocument(), myProject, true),
offset,
textRange);
duplicateHighlighters(markupModel, consoleEditor.getMarkupModel(), offset, textRange);
}
if (!text.endsWith("\n")) {
appendToHistoryDocument(history, "\n");
}
return text;
}
private void setupComponents() {
setupEditorDefault(myConsoleEditor);
setupEditorDefault(myHistoryViewer);
myConsoleEditor.addEditorMouseListener(
EditorActionUtil.createEditorPopupHandler(IdeActions.GROUP_CONSOLE_EDITOR_POPUP));
//noinspection PointlessBooleanExpression,ConstantConditions
if (SEPARATOR_THICKNESS > 0 && myShowSeparatorLine) {
myHistoryViewer
.getComponent()
.setBorder(new SideBorder(JBColor.LIGHT_GRAY, SideBorder.BOTTOM));
}
myHistoryViewer.getComponent().setMinimumSize(new Dimension(0, 0));
myHistoryViewer.getComponent().setPreferredSize(new Dimension(0, 0));
myConsoleEditor.getSettings().setAdditionalLinesCount(2);
myConsoleEditor.setHighlighter(
EditorHighlighterFactory.getInstance().createEditorHighlighter(myProject, myVirtualFile));
myHistoryViewer.setCaretEnabled(false);
myConsoleEditor.setHorizontalScrollbarVisible(true);
final VisibleAreaListener areaListener =
new VisibleAreaListener() {
public void visibleAreaChanged(VisibleAreaEvent e) {
final int offset = myConsoleEditor.getScrollingModel().getHorizontalScrollOffset();
final ScrollingModel model = myHistoryViewer.getScrollingModel();
final int historyOffset = model.getHorizontalScrollOffset();
if (historyOffset != offset) {
try {
model.disableAnimation();
model.scrollHorizontally(offset);
} finally {
model.enableAnimation();
}
}
}
};
myConsoleEditor.getScrollingModel().addVisibleAreaListener(areaListener);
final DocumentAdapter docListener =
new DocumentAdapter() {
@Override
public void documentChanged(final DocumentEvent e) {
queueUiUpdate(false);
}
};
myEditorDocument.addDocumentListener(docListener, this);
myHistoryViewer.getDocument().addDocumentListener(docListener, this);
myHistoryViewer
.getContentComponent()
.addKeyListener(
new KeyAdapter() {
public void keyTyped(KeyEvent event) {
if (isConsoleEditorEnabled() && UIUtil.isReallyTypedEvent(event)) {
myConsoleEditor.getContentComponent().requestFocus();
myConsoleEditor.processKeyTyped(event);
}
}
});
for (AnAction action : createActions()) {
action.registerCustomShortcutSet(action.getShortcutSet(), myConsoleEditor.getComponent());
}
EmptyAction.registerActionShortcuts(
myHistoryViewer.getComponent(), myConsoleEditor.getComponent());
}
