protected IpnbPyFragment clone() {
final IpnbPyFragment clone =
(IpnbPyFragment) cloneImpl((FileElement) calcTreeElement().clone());
clone.myPhysical = false;
clone.myOriginalFile = this;
FileManager fileManager = ((PsiManagerEx) getManager()).getFileManager();
SingleRootFileViewProvider cloneViewProvider =
(SingleRootFileViewProvider)
fileManager.createFileViewProvider(
new LightVirtualFile(getName(), getLanguage(), getText()), false);
cloneViewProvider.forceCachedPsi(clone);
clone.myViewProvider = cloneViewProvider;
return clone;
}
@Override
public void beforeDocumentChange(DocumentEvent event) {
final Document document = event.getDocument();
final FileViewProvider viewProvider = getCachedViewProvider(document);
if (viewProvider == null) return;
if (!isRelevant(viewProvider)) return;
VirtualFile virtualFile = viewProvider.getVirtualFile();
if (virtualFile.getFileType().isBinary()) return;
final List<PsiFile> files = viewProvider.getAllFiles();
PsiFile psiCause = null;
for (PsiFile file : files) {
mySmartPointerManager.fastenBelts(file, event.getOffset(), null);
if (TextBlock.get(file).isLocked()) {
psiCause = file;
}
}
if (psiCause == null) {
beforeDocumentChangeOnUnlockedDocument(viewProvider);
}
((SingleRootFileViewProvider) viewProvider).beforeDocumentChanged(psiCause);
}
@Override
public void markInvalidated() {
for (PsiFileImpl file : myRoots.values()) {
file.markInvalidated();
}
super.markInvalidated();
}
@NotNull
private static DiffLog makeFullParse(
@NotNull PsiFileImpl fileImpl,
@NotNull CharSequence newFileText,
@NotNull ProgressIndicator indicator,
@NotNull CharSequence lastCommittedText) {
if (fileImpl instanceof PsiCodeFragment) {
FileElement parent = fileImpl.getTreeElement();
final FileElement holderElement =
new DummyHolder(fileImpl.getManager(), null).getTreeElement();
holderElement.rawAddChildren(
fileImpl.createContentLeafElement(
holderElement.getCharTable().intern(newFileText, 0, newFileText.length())));
DiffLog diffLog = new DiffLog();
diffLog.appendReplaceFileElement(parent, (FileElement) holderElement.getFirstChildNode());
return diffLog;
} else {
FileViewProvider viewProvider = fileImpl.getViewProvider();
viewProvider.getLanguages();
FileType fileType = viewProvider.getVirtualFile().getFileType();
String fileName = fileImpl.getName();
final LightVirtualFile lightFile =
new LightVirtualFile(
fileName,
fileType,
newFileText,
viewProvider.getVirtualFile().getCharset(),
fileImpl.getViewProvider().getModificationStamp());
lightFile.setOriginalFile(viewProvider.getVirtualFile());
FileViewProvider copy = viewProvider.createCopy(lightFile);
if (copy.isEventSystemEnabled()) {
throw new AssertionError(
"Copied view provider must be non-physical for reparse to deliver correct events: "
+ viewProvider);
}
copy.getLanguages();
SingleRootFileViewProvider.doNotCheckFileSizeLimit(
lightFile); // optimization: do not convert file contents to bytes to determine if we
// should codeinsight it
PsiFileImpl newFile = getFileCopy(fileImpl, copy);
newFile.setOriginalFile(fileImpl);
final FileElement newFileElement = (FileElement) newFile.getNode();
final FileElement oldFileElement = (FileElement) fileImpl.getNode();
if (!lastCommittedText.toString().equals(oldFileElement.getText())) {
throw new IncorrectOperationException();
}
DiffLog diffLog =
mergeTrees(fileImpl, oldFileElement, newFileElement, indicator, lastCommittedText);
((PsiManagerEx) fileImpl.getManager()).getFileManager().setViewProvider(lightFile, null);
return diffLog;
}
}
@Override
@Nullable
public Document getDocument(@NotNull final VirtualFile file) {
DocumentEx document = (DocumentEx) getCachedDocument(file);
if (document == null) {
if (file.isDirectory()
|| isBinaryWithoutDecompiler(file)
|| SingleRootFileViewProvider.isTooLargeForContentLoading(file)) {
return null;
}
final CharSequence text = LoadTextUtil.loadText(file);
synchronized (lock) {
document = (DocumentEx) getCachedDocument(file);
if (document != null) return document; // Double checking
document = (DocumentEx) createDocument(text);
document.setModificationStamp(file.getModificationStamp());
final FileType fileType = file.getFileType();
document.setReadOnly(!file.isWritable() || fileType.isBinary());
file.putUserData(DOCUMENT_KEY, new WeakReference<Document>(document));
document.putUserData(FILE_KEY, file);
if (!(file instanceof LightVirtualFile
|| file.getFileSystem() instanceof DummyFileSystem)) {
document.addDocumentListener(
new DocumentAdapter() {
@Override
public void documentChanged(DocumentEvent e) {
final Document document = e.getDocument();
myUnsavedDocuments.add(document);
final Runnable currentCommand =
CommandProcessor.getInstance().getCurrentCommand();
Project project =
currentCommand == null
? null
: CommandProcessor.getInstance().getCurrentCommandProject();
String lineSeparator = CodeStyleFacade.getInstance(project).getLineSeparator();
document.putUserData(LINE_SEPARATOR_KEY, lineSeparator);
// avoid documents piling up during batch processing
if (areTooManyDocumentsInTheQueue(myUnsavedDocuments)) {
saveAllDocumentsLater();
}
}
});
}
}
myMultiCaster.fileContentLoaded(file, document);
}
return document;
}
@Override
public void contentsSynchronized() {
super.contentsSynchronized();
Set<Language> languages = getLanguages();
for (Iterator<Map.Entry<Language, PsiFile>> iterator = myRoots.entrySet().iterator();
iterator.hasNext(); ) {
Map.Entry<Language, PsiFile> entry = iterator.next();
if (!languages.contains(entry.getKey())) {
iterator.remove();
}
}
}
@Override
public void beforeDocumentChange(@NotNull DocumentEvent event) {
if (myStopTrackingDocuments) return;
final Document document = event.getDocument();
if (!(document instanceof DocumentWindow) && !myLastCommittedTexts.containsKey(document)) {
myLastCommittedTexts.put(
document,
Pair.create(document.getImmutableCharSequence(), document.getModificationStamp()));
}
VirtualFile virtualFile = FileDocumentManager.getInstance().getFile(document);
boolean isRelevant = virtualFile != null && isRelevant(virtualFile);
final FileViewProvider viewProvider = getCachedViewProvider(document);
boolean inMyProject = viewProvider != null && viewProvider.getManager() == myPsiManager;
if (!isRelevant || !inMyProject) {
return;
}
final List<PsiFile> files = viewProvider.getAllFiles();
PsiFile psiCause = null;
for (PsiFile file : files) {
if (file == null) {
throw new AssertionError(
"View provider "
+ viewProvider
+ " ("
+ viewProvider.getClass()
+ ") returned null in its files array: "
+ files
+ " for file "
+ viewProvider.getVirtualFile());
}
if (mySynchronizer.isInsideAtomicChange(file)) {
psiCause = file;
}
}
if (psiCause == null) {
beforeDocumentChangeOnUnlockedDocument(viewProvider);
}
((SingleRootFileViewProvider) viewProvider).beforeDocumentChanged(psiCause);
}
@Override
public boolean shouldInspect(@NotNull PsiElement psiRoot) {
if (ApplicationManager.getApplication().isUnitTestMode()) return true;
final FileHighlightingSetting settingForRoot = getHighlightingSettingForRoot(psiRoot);
if (settingForRoot == FileHighlightingSetting.SKIP_HIGHLIGHTING
|| settingForRoot == FileHighlightingSetting.SKIP_INSPECTION) {
return false;
}
final Project project = psiRoot.getProject();
final VirtualFile virtualFile = psiRoot.getContainingFile().getVirtualFile();
if (virtualFile == null || !virtualFile.isValid()) return false;
if (ProjectCoreUtil.isProjectOrWorkspaceFile(virtualFile)) return false;
final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
if (ProjectScope.getLibrariesScope(project).contains(virtualFile)
&& !fileIndex.isInContent(virtualFile)) return false;
return !SingleRootFileViewProvider.isTooLargeForIntelligence(virtualFile);
}
private static void doPaste(
final Editor editor,
final Project project,
final PsiFile file,
final Document document,
final Producer<Transferable> producer) {
Transferable content = null;
if (producer != null) {
content = producer.produce();
} else {
CopyPasteManager manager = CopyPasteManager.getInstance();
if (manager.areDataFlavorsAvailable(DataFlavor.stringFlavor)) {
content = manager.getContents();
if (content != null) {
manager.stopKillRings();
}
}
}
if (content != null) {
String text = null;
try {
text = (String) content.getTransferData(DataFlavor.stringFlavor);
} catch (Exception e) {
editor.getComponent().getToolkit().beep();
}
if (text == null) return;
final CodeInsightSettings settings = CodeInsightSettings.getInstance();
final Map<CopyPastePostProcessor, TextBlockTransferableData> extraData =
new HashMap<CopyPastePostProcessor, TextBlockTransferableData>();
for (CopyPastePostProcessor processor :
Extensions.getExtensions(CopyPastePostProcessor.EP_NAME)) {
TextBlockTransferableData data = processor.extractTransferableData(content);
if (data != null) {
extraData.put(processor, data);
}
}
text = TextBlockTransferable.convertLineSeparators(text, "\n", extraData.values());
final CaretModel caretModel = editor.getCaretModel();
final SelectionModel selectionModel = editor.getSelectionModel();
final int col = caretModel.getLogicalPosition().column;
// There is a possible case that we want to perform paste while there is an active selection
// at the editor and caret is located
// inside it (e.g. Ctrl+A is pressed while caret is not at the zero column). We want to insert
// the text at selection start column
// then, hence, inserted block of text should be indented according to the selection start as
// well.
final int blockIndentAnchorColumn;
final int caretOffset = caretModel.getOffset();
if (selectionModel.hasSelection() && caretOffset >= selectionModel.getSelectionStart()) {
blockIndentAnchorColumn =
editor.offsetToLogicalPosition(selectionModel.getSelectionStart()).column;
} else {
blockIndentAnchorColumn = col;
}
// We assume that EditorModificationUtil.insertStringAtCaret() is smart enough to remove
// currently selected text (if any).
RawText rawText = RawText.fromTransferable(content);
String newText = text;
for (CopyPastePreProcessor preProcessor :
Extensions.getExtensions(CopyPastePreProcessor.EP_NAME)) {
newText = preProcessor.preprocessOnPaste(project, file, editor, newText, rawText);
}
int indentOptions =
text.equals(newText) ? settings.REFORMAT_ON_PASTE : CodeInsightSettings.REFORMAT_BLOCK;
text = newText;
if (LanguageFormatting.INSTANCE.forContext(file) == null
&& indentOptions != CodeInsightSettings.NO_REFORMAT) {
indentOptions = CodeInsightSettings.INDENT_BLOCK;
}
final String _text = text;
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
EditorModificationUtil.insertStringAtCaret(editor, _text, false, true);
}
});
int length = text.length();
int offset = caretModel.getOffset() - length;
if (offset < 0) {
length += offset;
offset = 0;
}
final RangeMarker bounds = document.createRangeMarker(offset, offset + length);
caretModel.moveToOffset(bounds.getEndOffset());
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
selectionModel.removeSelection();
final Ref<Boolean> indented = new Ref<Boolean>(Boolean.FALSE);
for (Map.Entry<CopyPastePostProcessor, TextBlockTransferableData> e : extraData.entrySet()) {
//noinspection unchecked
e.getKey()
.processTransferableData(project, editor, bounds, caretOffset, indented, e.getValue());
}
boolean pastedTextContainsWhiteSpacesOnly =
CharArrayUtil.shiftForward(document.getCharsSequence(), bounds.getStartOffset(), " \n\t")
>= bounds.getEndOffset();
VirtualFile virtualFile = file.getVirtualFile();
if (!pastedTextContainsWhiteSpacesOnly
&& (virtualFile == null
|| !SingleRootFileViewProvider.isTooLargeForIntelligence(virtualFile))) {
final int indentOptions1 = indentOptions;
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
switch (indentOptions1) {
case CodeInsightSettings.INDENT_BLOCK:
if (!indented.get()) {
indentBlock(
project,
editor,
bounds.getStartOffset(),
bounds.getEndOffset(),
blockIndentAnchorColumn);
}
break;
case CodeInsightSettings.INDENT_EACH_LINE:
if (!indented.get()) {
indentEachLine(
project, editor, bounds.getStartOffset(), bounds.getEndOffset());
}
break;
case CodeInsightSettings.REFORMAT_BLOCK:
indentEachLine(
project,
editor,
bounds.getStartOffset(),
bounds
.getEndOffset()); // this is needed for example when inserting a
// comment before method
reformatBlock(
project, editor, bounds.getStartOffset(), bounds.getEndOffset());
break;
}
}
});
}
if (bounds.isValid()) {
caretModel.moveToOffset(bounds.getEndOffset());
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
selectionModel.removeSelection();
editor.putUserData(EditorEx.LAST_PASTED_REGION, TextRange.create(bounds));
}
}
}