TextEditorComponent(
@NotNull final Project project,
@NotNull final VirtualFile file,
@NotNull final TextEditorImpl textEditor) {
super(new BorderLayout(), textEditor);
myProject = project;
myFile = file;
myTextEditor = textEditor;
myDocument = FileDocumentManager.getInstance().getDocument(myFile);
LOG.assertTrue(myDocument != null);
myDocumentListener = new MyDocumentListener();
myDocument.addDocumentListener(myDocumentListener);
myEditorMouseListener = new MyEditorMouseListener();
myEditorPropertyChangeListener = new MyEditorPropertyChangeListener();
myConnection = project.getMessageBus().connect();
myConnection.subscribe(FileTypeManager.TOPIC, new MyFileTypeListener());
myVirtualFileListener = new MyVirtualFileListener();
myFile.getFileSystem().addVirtualFileListener(myVirtualFileListener);
myEditor = createEditor();
add(myEditor.getComponent(), BorderLayout.CENTER);
myModified = isModifiedImpl();
myValid = isEditorValidImpl();
LOG.assertTrue(myValid);
}
public void testDocSynchronizerPrefersLineBoundaryChanges() throws Exception {
String text =
"import java.awt.List;\n"
+ "[import java.util.ArrayList;\n]"
+ "import java.util.HashMap;\n"
+ "import java.util.Map;";
RangeMarker marker = createMarker(text);
synchronizer.startTransaction(getProject(), document, psiFile);
String newText = StringUtil.replaceSubstring(document.getText(), TextRange.create(marker), "");
synchronizer.replaceString(document, 0, document.getTextLength(), newText);
final List<DocumentEvent> events = new ArrayList<DocumentEvent>();
document.addDocumentListener(
new DocumentAdapter() {
@Override
public void documentChanged(DocumentEvent e) {
events.add(e);
}
});
synchronizer.commitTransaction(document);
assertEquals(newText, document.getText());
DocumentEvent event = assertOneElement(events);
assertEquals(
"DocumentEventImpl[myOffset=22, myOldLength=28, myNewLength=0, myOldString='import java.util.ArrayList;\n', myNewString=''].",
event.toString());
}
public void initialize(
@NotNull final String vcsContent, @NotNull RevisionPack baseRevisionNumber) {
myApplication.assertIsDispatchThread();
synchronized (myLock) {
try {
if (myReleased) return;
if (myBaseRevisionNumber != null && myBaseRevisionNumber.contains(baseRevisionNumber))
return;
myBaseRevisionNumber = baseRevisionNumber;
myVcsDocument.setReadOnly(false);
myVcsDocument.setText(vcsContent);
myVcsDocument.setReadOnly(true);
reinstallRanges();
if (myDocumentListener == null) {
myDocumentListener = new MyDocumentListener();
myDocument.addDocumentListener(myDocumentListener);
}
} finally {
myInitialized = true;
}
}
}
@Override
protected void onInit() {
super.onInit();
if (myFileListener != null)
VirtualFileManager.getInstance().addVirtualFileListener(myFileListener);
for (Document document : getDocuments()) {
document.addDocumentListener(myDocumentListener);
}
}
private ReferenceEditorComboWithBrowseButton createPackageChooser() {
final ReferenceEditorComboWithBrowseButton packageChooser =
new PackageNameReferenceEditorCombo(
"", myProject, RECENTS_KEY, RefactoringBundle.message("choose.destination.package"));
final Document document = packageChooser.getChildComponent().getDocument();
document.addDocumentListener(
new DocumentAdapter() {
public void documentChanged(DocumentEvent e) {
validateButtons();
}
});
return packageChooser;
}
public static void trackStatistics(InsertionContext context, final StatisticsUpdate update) {
if (ourPendingUpdate != update) {
return;
}
final Document document = context.getDocument();
int startOffset = context.getStartOffset();
int tailOffset = context.getEditor().getCaretModel().getOffset();
if (startOffset < 0 || tailOffset <= startOffset) {
return;
}
final RangeMarker marker = document.createRangeMarker(startOffset, tailOffset);
final DocumentAdapter listener =
new DocumentAdapter() {
@Override
public void beforeDocumentChange(DocumentEvent e) {
if (!marker.isValid()
|| e.getOffset() > marker.getStartOffset()
&& e.getOffset() < marker.getEndOffset()) {
cancelLastCompletionStatisticsUpdate();
}
}
};
ourStatsAlarm.addRequest(
new Runnable() {
@Override
public void run() {
if (ourPendingUpdate == update) {
applyLastCompletionStatisticsUpdate();
}
}
},
20 * 1000);
document.addDocumentListener(listener);
Disposer.register(
update,
new Disposable() {
@Override
public void dispose() {
document.removeDocumentListener(listener);
marker.dispose();
ourStatsAlarm.cancelAllRequests();
}
});
}
private static VirtualFile getCopyWithAnswers(
@NotNull final VirtualFile taskDir,
@NotNull final VirtualFile file,
@NotNull final TaskFile source,
@NotNull final TaskFile target) {
VirtualFile copy = null;
try {
copy =
file.copy(
taskDir,
taskDir,
file.getNameWithoutExtension()
+ EduNames.ANSWERS_POSTFIX
+ "."
+ file.getExtension());
final FileDocumentManager documentManager = FileDocumentManager.getInstance();
final Document document = documentManager.getDocument(copy);
if (document != null) {
TaskFile.copy(source, target);
EduDocumentListener listener = new EduDocumentListener(target);
document.addDocumentListener(listener);
for (AnswerPlaceholder answerPlaceholder : target.getAnswerPlaceholders()) {
final int start = answerPlaceholder.getOffset();
final int end = start + answerPlaceholder.getRealLength();
final String text = answerPlaceholder.getPossibleAnswer();
document.replaceString(start, end, text);
}
ApplicationManager.getApplication()
.runWriteAction(() -> documentManager.saveDocument(document));
}
} catch (IOException e) {
LOG.error(e);
}
return copy;
}
QuickEditHandler(
Project project,
@NotNull PsiFile injectedFile,
final PsiFile origFile,
Editor editor,
QuickEditAction action) {
myProject = project;
myEditor = editor;
myAction = action;
myOrigDocument = editor.getDocument();
Place shreds = InjectedLanguageUtil.getShreds(injectedFile);
FileType fileType = injectedFile.getFileType();
Language language = injectedFile.getLanguage();
PsiLanguageInjectionHost.Shred firstShred = ContainerUtil.getFirstItem(shreds);
PsiFileFactory factory = PsiFileFactory.getInstance(project);
String text = InjectedLanguageManager.getInstance(project).getUnescapedText(injectedFile);
String newFileName =
StringUtil.notNullize(language.getDisplayName(), "Injected")
+ " Fragment "
+ "("
+ origFile.getName()
+ ":"
+ firstShred.getHost().getTextRange().getStartOffset()
+ ")"
+ "."
+ fileType.getDefaultExtension();
// preserve \r\n as it is done in MultiHostRegistrarImpl
myNewFile = factory.createFileFromText(newFileName, language, text, true, false);
myNewVirtualFile = ObjectUtils.assertNotNull((LightVirtualFile) myNewFile.getVirtualFile());
myNewVirtualFile.setOriginalFile(origFile.getVirtualFile());
assert myNewFile != null : "PSI file is null";
assert myNewFile.getTextLength() == myNewVirtualFile.getContent().length()
: "PSI / Virtual file text mismatch";
myNewVirtualFile.setOriginalFile(origFile.getVirtualFile());
// suppress possible errors as in injected mode
myNewFile.putUserData(
InjectedLanguageUtil.FRANKENSTEIN_INJECTION,
injectedFile.getUserData(InjectedLanguageUtil.FRANKENSTEIN_INJECTION));
myNewFile.putUserData(FileContextUtil.INJECTED_IN_ELEMENT, shreds.getHostPointer());
myNewDocument = PsiDocumentManager.getInstance(project).getDocument(myNewFile);
assert myNewDocument != null;
EditorActionManager.getInstance()
.setReadonlyFragmentModificationHandler(myNewDocument, new MyQuietHandler());
myOrigCreationStamp =
myOrigDocument.getModificationStamp(); // store creation stamp for UNDO tracking
myOrigDocument.addDocumentListener(this, this);
myNewDocument.addDocumentListener(this, this);
EditorFactory editorFactory = ObjectUtils.assertNotNull(EditorFactory.getInstance());
// not FileEditorManager listener because of RegExp checker and alike
editorFactory.addEditorFactoryListener(
new EditorFactoryAdapter() {
int useCount;
@Override
public void editorCreated(@NotNull EditorFactoryEvent event) {
if (event.getEditor().getDocument() != myNewDocument) return;
useCount++;
}
@Override
public void editorReleased(@NotNull EditorFactoryEvent event) {
if (event.getEditor().getDocument() != myNewDocument) return;
if (--useCount > 0) return;
if (Boolean.TRUE.equals(
myNewVirtualFile.getUserData(FileEditorManagerImpl.CLOSING_TO_REOPEN))) return;
Disposer.dispose(QuickEditHandler.this);
}
},
this);
if ("JAVA".equals(firstShred.getHost().getLanguage().getID())) {
PsiLanguageInjectionHost.Shred lastShred = ContainerUtil.getLastItem(shreds);
myAltFullRange =
myOrigDocument.createRangeMarker(
firstShred.getHostRangeMarker().getStartOffset(),
lastShred.getHostRangeMarker().getEndOffset());
myAltFullRange.setGreedyToLeft(true);
myAltFullRange.setGreedyToRight(true);
initGuardedBlocks(shreds);
myInjectedFile = null;
} else {
initMarkers(shreds);
myAltFullRange = null;
myInjectedFile = injectedFile;
}
}
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());
}
public void showCoverageInformation(final CoverageSuitesBundle suite) {
// Store the values of myFile and myEditor in local variables to avoid an NPE after dispose()
// has been called in the EDT.
final PsiFile psiFile = myFile;
final Editor editor = myEditor;
final Document document = myDocument;
if (editor == null || psiFile == null || document == null) return;
final MarkupModel markupModel = DocumentMarkupModel.forDocument(document, myProject, true);
final List<RangeHighlighter> highlighters = new ArrayList<RangeHighlighter>();
final ProjectData data = suite.getCoverageData();
if (data == null) {
coverageDataNotFound(suite);
return;
}
final CoverageEngine engine = suite.getCoverageEngine();
final Set<String> qualifiedNames = engine.getQualifiedNames(psiFile);
// let's find old content in local history and build mapping from old lines to new one
// local history doesn't index libraries, so let's distinguish libraries content with other one
final ProjectFileIndex projectFileIndex =
ProjectRootManager.getInstance(myProject).getFileIndex();
final VirtualFile file = psiFile.getVirtualFile();
LOG.assertTrue(file != null);
final long fileTimeStamp = file.getTimeStamp();
final long coverageTimeStamp = suite.getLastCoverageTimeStamp();
final TIntIntHashMap oldToNewLineMapping;
// do not show coverage info over cls
if (engine.isInLibraryClasses(myProject, file)) {
return;
}
// if in libraries content
if (projectFileIndex.isInLibrarySource(file)) {
// compare file and coverage timestamps
if (fileTimeStamp > coverageTimeStamp) {
showEditorWarningMessage(CodeInsightBundle.message("coverage.data.outdated"));
return;
}
oldToNewLineMapping = null;
} else {
// check local history
oldToNewLineMapping = getOldToNewLineMapping(coverageTimeStamp);
if (oldToNewLineMapping == null) {
// if history for file isn't available let's check timestamps
if (fileTimeStamp > coverageTimeStamp
&& classesArePresentInCoverageData(data, qualifiedNames)) {
showEditorWarningMessage(CodeInsightBundle.message("coverage.data.outdated"));
return;
}
}
}
if (editor.getUserData(COVERAGE_HIGHLIGHTERS) != null) {
// highlighters already collected - no need to do it twice
return;
}
final Module module =
ApplicationManager.getApplication()
.runReadAction(
new Computable<Module>() {
@Nullable
@Override
public Module compute() {
return ModuleUtilCore.findModuleForPsiElement(psiFile);
}
});
if (module != null) {
if (engine.recompileProjectAndRerunAction(
module,
suite,
() -> CoverageDataManager.getInstance(myProject).chooseSuitesBundle(suite))) {
return;
}
}
// now if oldToNewLineMapping is null we should use f(x)=id(x) mapping
// E.g. all *.class files for java source file with several classes
final Set<File> outputFiles = engine.getCorrespondingOutputFiles(psiFile, module, suite);
final boolean subCoverageActive =
CoverageDataManager.getInstance(myProject).isSubCoverageActive();
final boolean coverageByTestApplicable =
suite.isCoverageByTestApplicable()
&& !(subCoverageActive && suite.isCoverageByTestEnabled());
final TreeMap<Integer, LineData> executableLines = new TreeMap<Integer, LineData>();
final TreeMap<Integer, Object[]> classLines = new TreeMap<Integer, Object[]>();
final TreeMap<Integer, String> classNames = new TreeMap<Integer, String>();
class HighlightersCollector {
private void collect(File outputFile, final String qualifiedName) {
final ClassData fileData = data.getClassData(qualifiedName);
if (fileData != null) {
final Object[] lines = fileData.getLines();
if (lines != null) {
final Object[] postProcessedLines =
suite.getCoverageEngine().postProcessExecutableLines(lines, editor);
for (Object lineData : postProcessedLines) {
if (lineData instanceof LineData) {
final int line = ((LineData) lineData).getLineNumber() - 1;
final int lineNumberInCurrent;
if (oldToNewLineMapping != null) {
// use mapping based on local history
if (!oldToNewLineMapping.contains(line)) {
continue;
}
lineNumberInCurrent = oldToNewLineMapping.get(line);
} else {
// use id mapping
lineNumberInCurrent = line;
}
LOG.assertTrue(lineNumberInCurrent < document.getLineCount());
executableLines.put(line, (LineData) lineData);
classLines.put(line, postProcessedLines);
classNames.put(line, qualifiedName);
ApplicationManager.getApplication()
.invokeLater(
() -> {
if (lineNumberInCurrent >= document.getLineCount()) return;
final RangeHighlighter highlighter =
createRangeHighlighter(
suite.getLastCoverageTimeStamp(),
markupModel,
coverageByTestApplicable,
executableLines,
qualifiedName,
line,
lineNumberInCurrent,
suite,
postProcessedLines);
highlighters.add(highlighter);
});
}
}
}
} else if (outputFile != null
&& !subCoverageActive
&& engine.includeUntouchedFileInCoverage(qualifiedName, outputFile, psiFile, suite)) {
collectNonCoveredFileInfo(
outputFile, highlighters, markupModel, executableLines, coverageByTestApplicable);
}
}
}
final HighlightersCollector collector = new HighlightersCollector();
if (!outputFiles.isEmpty()) {
for (File outputFile : outputFiles) {
final String qualifiedName = engine.getQualifiedName(outputFile, psiFile);
if (qualifiedName != null) {
collector.collect(outputFile, qualifiedName);
}
}
} else { // check non-compilable classes which present in ProjectData
for (String qName : qualifiedNames) {
collector.collect(null, qName);
}
}
ApplicationManager.getApplication()
.invokeLater(
() -> {
if (myEditor != null && highlighters.size() > 0) {
editor.putUserData(COVERAGE_HIGHLIGHTERS, highlighters);
}
});
final DocumentListener documentListener =
new DocumentAdapter() {
@Override
public void documentChanged(final DocumentEvent e) {
myNewToOldLines = null;
myOldToNewLines = null;
List<RangeHighlighter> rangeHighlighters = editor.getUserData(COVERAGE_HIGHLIGHTERS);
if (rangeHighlighters == null) rangeHighlighters = new ArrayList<RangeHighlighter>();
int offset = e.getOffset();
final int lineNumber = document.getLineNumber(offset);
final int lastLineNumber = document.getLineNumber(offset + e.getNewLength());
final TextRange changeRange =
new TextRange(
document.getLineStartOffset(lineNumber),
document.getLineEndOffset(lastLineNumber));
for (Iterator<RangeHighlighter> it = rangeHighlighters.iterator(); it.hasNext(); ) {
final RangeHighlighter highlighter = it.next();
if (!highlighter.isValid() || TextRange.create(highlighter).intersects(changeRange)) {
highlighter.dispose();
it.remove();
}
}
final List<RangeHighlighter> highlighters = rangeHighlighters;
myUpdateAlarm.cancelAllRequests();
if (!myUpdateAlarm.isDisposed()) {
myUpdateAlarm.addRequest(
() -> {
final TIntIntHashMap newToOldLineMapping =
getNewToOldLineMapping(suite.getLastCoverageTimeStamp());
if (newToOldLineMapping != null) {
ApplicationManager.getApplication()
.invokeLater(
() -> {
if (editor.isDisposed()) return;
for (int line = lineNumber; line <= lastLineNumber; line++) {
final int oldLineNumber = newToOldLineMapping.get(line);
final LineData lineData = executableLines.get(oldLineNumber);
if (lineData != null) {
RangeHighlighter rangeHighlighter =
createRangeHighlighter(
suite.getLastCoverageTimeStamp(),
markupModel,
coverageByTestApplicable,
executableLines,
classNames.get(oldLineNumber),
oldLineNumber,
line,
suite,
classLines.get(oldLineNumber));
highlighters.add(rangeHighlighter);
}
}
editor.putUserData(
COVERAGE_HIGHLIGHTERS,
highlighters.size() > 0 ? highlighters : null);
});
}
},
100);
}
}
};
document.addDocumentListener(documentListener);
editor.putUserData(COVERAGE_DOCUMENT_LISTENER, documentListener);
}
