void execute(BrowseMode browseMode) {
myBrowseMode = browseMode;
Document document = myEditor.getDocument();
final PsiFile file = PsiDocumentManager.getInstance(myProject).getPsiFile(document);
if (file == null) return;
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
if (EditorUtil.inVirtualSpace(myEditor, myPosition)) {
return;
}
final int offset = myEditor.logicalPositionToOffset(myPosition);
int selStart = myEditor.getSelectionModel().getSelectionStart();
int selEnd = myEditor.getSelectionModel().getSelectionEnd();
if (offset >= selStart && offset < selEnd) return;
ProgressIndicatorUtils.scheduleWithWriteActionPriority(
myProgress,
new ReadTask() {
@Override
public void computeInReadAction(@NotNull ProgressIndicator indicator) {
doExecute(file, offset);
}
@Override
public void onCanceled(@NotNull ProgressIndicator indicator) {}
});
}
private void createNameAndReturnTypeEditors() {
myNameCodeFragment = new GroovyCodeFragment(myProject, "");
myNameField =
new EditorTextField(
PsiDocumentManager.getInstance(myProject).getDocument(myNameCodeFragment),
myProject,
myNameCodeFragment.getFileType());
final JavaCodeFragmentFactory factory = JavaCodeFragmentFactory.getInstance(myProject);
myReturnTypeCodeFragment =
factory.createTypeCodeFragment("", myMethod, true, JavaCodeFragmentFactory.ALLOW_VOID);
final Document document =
PsiDocumentManager.getInstance(myProject).getDocument(myReturnTypeCodeFragment);
myReturnTypeField =
new EditorTextField(document, myProject, myReturnTypeCodeFragment.getFileType());
myNameField.setText(myMethod.getName());
final GrTypeElement element = myMethod.getReturnTypeElementGroovy();
if (element != null) {
myReturnTypeField.setText(element.getText());
}
myReturnTypeLabel = new JLabel();
myReturnTypeLabel.setLabelFor(myReturnTypeField);
myNameLabel = new JLabel();
myNameLabel.setLabelFor(myNameField);
}
private void altCommitToOriginal(@NotNull DocumentEvent e) {
final PsiFile origPsiFile =
PsiDocumentManager.getInstance(myProject).getPsiFile(myOrigDocument);
String newText = myNewDocument.getText();
// prepare guarded blocks
LinkedHashMap<String, String> replacementMap = new LinkedHashMap<String, String>();
int count = 0;
for (RangeMarker o : ContainerUtil.reverse(((DocumentEx) myNewDocument).getGuardedBlocks())) {
String replacement = o.getUserData(REPLACEMENT_KEY);
String tempText = "REPLACE" + (count++) + Long.toHexString(StringHash.calc(replacement));
newText =
newText.substring(0, o.getStartOffset()) + tempText + newText.substring(o.getEndOffset());
replacementMap.put(tempText, replacement);
}
// run preformat processors
final int hostStartOffset = myAltFullRange.getStartOffset();
myEditor.getCaretModel().moveToOffset(hostStartOffset);
for (CopyPastePreProcessor preProcessor :
Extensions.getExtensions(CopyPastePreProcessor.EP_NAME)) {
newText = preProcessor.preprocessOnPaste(myProject, origPsiFile, myEditor, newText, null);
}
myOrigDocument.replaceString(hostStartOffset, myAltFullRange.getEndOffset(), newText);
// replace temp strings for guarded blocks
for (String tempText : replacementMap.keySet()) {
int idx =
CharArrayUtil.indexOf(
myOrigDocument.getCharsSequence(),
tempText,
hostStartOffset,
myAltFullRange.getEndOffset());
myOrigDocument.replaceString(idx, idx + tempText.length(), replacementMap.get(tempText));
}
// JAVA: fix occasional char literal concatenation
fixDocumentQuotes(myOrigDocument, hostStartOffset - 1);
fixDocumentQuotes(myOrigDocument, myAltFullRange.getEndOffset());
// reformat
PsiDocumentManager.getInstance(myProject).commitDocument(myOrigDocument);
Runnable task =
() -> {
try {
CodeStyleManager.getInstance(myProject)
.reformatRange(origPsiFile, hostStartOffset, myAltFullRange.getEndOffset(), true);
} catch (IncorrectOperationException e1) {
// LOG.error(e);
}
};
DocumentUtil.executeInBulk(myOrigDocument, true, task);
PsiElement newInjected =
InjectedLanguageManager.getInstance(myProject)
.findInjectedElementAt(origPsiFile, hostStartOffset);
DocumentWindow documentWindow =
newInjected == null ? null : InjectedLanguageUtil.getDocumentWindow(newInjected);
if (documentWindow != null) {
myEditor.getCaretModel().moveToOffset(documentWindow.injectedToHost(e.getOffset()));
myEditor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
}
}
public void execute(BrowseMode browseMode) {
myBrowseMode = browseMode;
Document document = myEditor.getDocument();
final PsiFile file = PsiDocumentManager.getInstance(myProject).getPsiFile(document);
if (file == null) return;
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
if (TargetElementUtilBase.inVirtualSpace(myEditor, myPosition)) {
return;
}
final int offset = myEditor.logicalPositionToOffset(myPosition);
int selStart = myEditor.getSelectionModel().getSelectionStart();
int selEnd = myEditor.getSelectionModel().getSelectionEnd();
if (offset >= selStart && offset < selEnd) return;
ApplicationManager.getApplication()
.executeOnPooledThread(
new Runnable() {
public void run() {
final ProgressIndicator progressIndicator = new ProgressIndicatorBase();
final ApplicationAdapter listener =
new ApplicationAdapter() {
@Override
public void beforeWriteActionStart(Object action) {
progressIndicator.cancel();
}
};
final Application application = ApplicationManager.getApplication();
try {
application.addApplicationListener(listener);
ProgressManager.getInstance()
.runProcess(
new Runnable() {
@Override
public void run() {
// This read action can possibe last for a long time, we want it to
// stop immediately on the first write access.
// For this purpose we launch it under empty progress and invoke
// progressIndicator#cancel on write access to avoid possible write
// lock delays.
application.runReadAction(
new Runnable() {
public void run() {
doExecute(file, offset);
}
});
}
},
progressIndicator);
} finally {
application.removeApplicationListener(listener);
}
}
});
}
private void commitToOriginalInner() {
final String text = myNewDocument.getText();
final Map<
PsiLanguageInjectionHost,
Set<Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer>>>
map =
ContainerUtil.classify(
myMarkers.iterator(),
new Convertor<
Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer>,
PsiLanguageInjectionHost>() {
@Override
public PsiLanguageInjectionHost convert(
final Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer> o) {
final PsiElement element = o.third.getElement();
return (PsiLanguageInjectionHost) element;
}
});
PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject);
documentManager.commitDocument(myOrigDocument); // commit here and after each manipulator update
int localInsideFileCursor = 0;
for (PsiLanguageInjectionHost host : map.keySet()) {
if (host == null) continue;
String hostText = host.getText();
ProperTextRange insideHost = null;
StringBuilder sb = new StringBuilder();
for (Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer> entry : map.get(host)) {
RangeMarker origMarker = entry.first; // check for validity?
int hostOffset = host.getTextRange().getStartOffset();
ProperTextRange localInsideHost =
new ProperTextRange(
origMarker.getStartOffset() - hostOffset, origMarker.getEndOffset() - hostOffset);
RangeMarker rangeMarker = entry.second;
ProperTextRange localInsideFile =
new ProperTextRange(
Math.max(localInsideFileCursor, rangeMarker.getStartOffset()),
rangeMarker.getEndOffset());
if (insideHost != null) {
// append unchanged inter-markers fragment
sb.append(
hostText.substring(insideHost.getEndOffset(), localInsideHost.getStartOffset()));
}
sb.append(
localInsideFile.getEndOffset() <= text.length() && !localInsideFile.isEmpty()
? localInsideFile.substring(text)
: "");
localInsideFileCursor = localInsideFile.getEndOffset();
insideHost = insideHost == null ? localInsideHost : insideHost.union(localInsideHost);
}
assert insideHost != null;
ElementManipulators.getManipulator(host).handleContentChange(host, insideHost, sb.toString());
documentManager.commitDocument(myOrigDocument);
}
}
@Override
public void mouseMoved(final EditorMouseEvent e) {
if (e.isConsumed() || !myProject.isInitialized() || myProject.isDisposed()) {
return;
}
MouseEvent mouseEvent = e.getMouseEvent();
if (isMouseOverTooltip(mouseEvent.getLocationOnScreen())
|| ScreenUtil.isMovementTowards(
myPrevMouseLocation, mouseEvent.getLocationOnScreen(), getHintBounds())) {
myPrevMouseLocation = mouseEvent.getLocationOnScreen();
return;
}
myPrevMouseLocation = mouseEvent.getLocationOnScreen();
Editor editor = e.getEditor();
if (editor.getProject() != null && editor.getProject() != myProject) return;
PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject);
PsiFile psiFile = documentManager.getPsiFile(editor.getDocument());
Point point = new Point(mouseEvent.getPoint());
if (documentManager.isCommitted(editor.getDocument())) {
// when document is committed, try to check injected stuff - it's fast
int offset = editor.logicalPositionToOffset(editor.xyToLogicalPosition(point));
editor =
InjectedLanguageUtil.getEditorForInjectedLanguageNoCommit(editor, psiFile, offset);
}
LogicalPosition pos = editor.xyToLogicalPosition(point);
int offset = editor.logicalPositionToOffset(pos);
int selStart = editor.getSelectionModel().getSelectionStart();
int selEnd = editor.getSelectionModel().getSelectionEnd();
myStoredModifiers = mouseEvent.getModifiers();
BrowseMode browseMode = getBrowseMode(myStoredModifiers);
cancelPreviousTooltip();
if (browseMode == BrowseMode.None || offset >= selStart && offset < selEnd) {
disposeHighlighter();
return;
}
myTooltipProvider = new TooltipProvider(editor, pos);
myTooltipProvider.execute(browseMode);
}
final boolean isValidBase() {
if (PsiDocumentManager.getInstance(myProject).getUncommittedDocuments().length > 0) {
return myCachedIsValidBase;
}
final PsiElement element = mySmartPsiElementPointer.getElement();
myCachedIsValidBase = element != null && isApplicableElement(element) && element.isValid();
return myCachedIsValidBase;
}
@Override
protected boolean isValidForFile(
@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) {
if (file instanceof PsiCompiledElement) return false;
PsiDocumentManager.getInstance(project).commitAllDocuments();
PsiClass targetClass = getTargetClass(editor, file);
return targetClass != null && isValidForClass(targetClass);
}
private void getInjectedPsiFiles(
@NotNull final List<PsiElement> elements1,
@NotNull final List<PsiElement> elements2,
@NotNull final ProgressIndicator progress,
@NotNull final Set<PsiFile> outInjected) {
List<DocumentWindow> injected = InjectedLanguageUtil.getCachedInjectedDocuments(myFile);
Collection<PsiElement> hosts =
new THashSet<PsiElement>(elements1.size() + elements2.size() + injected.size());
// rehighlight all injected PSI regardless the range,
// since change in one place can lead to invalidation of injected PSI in (completely) other
// place.
for (DocumentWindow documentRange : injected) {
progress.checkCanceled();
if (!documentRange.isValid()) continue;
PsiFile file = PsiDocumentManager.getInstance(myProject).getPsiFile(documentRange);
if (file == null) continue;
PsiElement context =
InjectedLanguageManager.getInstance(file.getProject()).getInjectionHost(file);
if (context != null
&& context.isValid()
&& !file.getProject().isDisposed()
&& (myUpdateAll
|| new ProperTextRange(myStartOffset, myEndOffset)
.intersects(context.getTextRange()))) {
hosts.add(context);
}
}
hosts.addAll(elements1);
hosts.addAll(elements2);
final PsiLanguageInjectionHost.InjectedPsiVisitor visitor =
new PsiLanguageInjectionHost.InjectedPsiVisitor() {
@Override
public void visit(
@NotNull PsiFile injectedPsi, @NotNull List<PsiLanguageInjectionHost.Shred> places) {
synchronized (outInjected) {
outInjected.add(injectedPsi);
}
}
};
if (!JobUtil.invokeConcurrentlyUnderProgress(
new ArrayList<PsiElement>(hosts),
progress,
false,
new Processor<PsiElement>() {
@Override
public boolean process(PsiElement element) {
progress.checkCanceled();
InjectedLanguageUtil.enumerate(element, myFile, false, visitor);
return true;
}
})) throw new ProcessCanceledException();
}
public void mouseMoved(final EditorMouseEvent e) {
if (e.isConsumed() || !myProject.isInitialized()) {
return;
}
MouseEvent mouseEvent = e.getMouseEvent();
Editor editor = e.getEditor();
if (editor.getProject() != null && editor.getProject() != myProject) return;
PsiFile psiFile =
PsiDocumentManager.getInstance(myProject).getPsiFile(editor.getDocument());
Point point = new Point(mouseEvent.getPoint());
if (!PsiDocumentManager.getInstance(myProject).isUncommited(editor.getDocument())) {
// when document is committed, try to check injected stuff - it's fast
editor =
InjectedLanguageUtil.getEditorForInjectedLanguageNoCommit(
editor,
psiFile,
editor.logicalPositionToOffset(editor.xyToLogicalPosition(point)));
}
LogicalPosition pos = editor.xyToLogicalPosition(point);
int offset = editor.logicalPositionToOffset(pos);
int selStart = editor.getSelectionModel().getSelectionStart();
int selEnd = editor.getSelectionModel().getSelectionEnd();
myStoredModifiers = mouseEvent.getModifiers();
BrowseMode browseMode = getBrowseMode(myStoredModifiers);
if (myTooltipProvider != null) {
myTooltipProvider.dispose();
}
if (browseMode == BrowseMode.None || offset >= selStart && offset < selEnd) {
disposeHighlighter();
myTooltipProvider = null;
return;
}
myTooltipProvider = new TooltipProvider(editor, pos);
myTooltipProvider.execute(browseMode);
}
public static String getNewText(PsiElement elt) {
Project project = elt.getProject();
PsiFile psiFile = getContainingFile(elt);
final Document doc = PsiDocumentManager.getInstance(project).getDocument(psiFile);
if (doc == null) return null;
final ImplementationTextSelectioner implementationTextSelectioner =
LanguageImplementationTextSelectioner.INSTANCE.forLanguage(elt.getLanguage());
int start = implementationTextSelectioner.getTextStartOffset(elt);
final int end = implementationTextSelectioner.getTextEndOffset(elt);
final int lineStart = doc.getLineStartOffset(doc.getLineNumber(start));
final int lineEnd =
end < doc.getTextLength()
? doc.getLineEndOffset(doc.getLineNumber(end))
: doc.getTextLength();
return doc.getCharsSequence().subSequence(lineStart, lineEnd).toString();
}
/**
* Alters either target (by qualifying a name) or source (by explicitly importing the name).
*
* @return true if action succeeded
*/
public boolean execute() {
// check if the tree is sane
PsiDocumentManager.getInstance(myTarget.getProject()).commitAllDocuments();
if (!myTarget.isValid()) return false;
if ((myTarget instanceof PyQualifiedExpression)
&& ((((PyQualifiedExpression) myTarget).isQualified())))
return false; // we cannot be qualified
for (ImportCandidateHolder item : mySources) {
if (!item.getImportable().isValid()) return false;
if (!item.getFile().isValid()) return false;
if (item.getImportElement() != null && !item.getImportElement().isValid()) return false;
}
if (mySources.isEmpty()) {
return false;
}
// act
if (mySources.size() > 1) {
selectSourceAndDo();
} else doWriteAction(mySources.get(0));
return true;
}
@Override
public void finish(boolean success) {
myFinished = true;
final TemplateState templateState = TemplateManagerImpl.getTemplateState(myEditor);
if (templateState != null) {
myEditor.putUserData(ACTIVE_INTRODUCE, null);
}
if (myDocumentAdapter != null) {
myEditor.getDocument().removeDocumentListener(myDocumentAdapter);
}
if (myBalloon == null) {
releaseIfNotRestart();
}
super.finish(success);
if (success) {
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
final V variable = getVariable();
if (variable == null) {
return;
}
restoreState(variable);
}
}
public V getLocalVariable() {
if (myLocalVariable != null && myLocalVariable.isValid()) {
return myLocalVariable;
}
if (myLocalMarker != null) {
V variable = getVariable();
PsiFile containingFile;
if (variable != null) {
containingFile = variable.getContainingFile();
} else {
containingFile =
PsiDocumentManager.getInstance(myProject).getPsiFile(myEditor.getDocument());
}
PsiNameIdentifierOwner identifierOwner =
PsiTreeUtil.getParentOfType(
containingFile.findElementAt(myLocalMarker.getStartOffset()),
PsiNameIdentifierOwner.class,
false);
return identifierOwner != null && identifierOwner.getClass() == myLocalVariable.getClass()
? (V) identifierOwner
: null;
}
return myLocalVariable;
}
private void commitToOriginal(final DocumentEvent e) {
VirtualFile origVirtualFile = PsiUtilCore.getVirtualFile(myNewFile.getContext());
myCommittingToOriginal = true;
try {
if (origVirtualFile == null
|| !ReadonlyStatusHandler.getInstance(myProject)
.ensureFilesWritable(origVirtualFile)
.hasReadonlyFiles()) {
PostprocessReformattingAspect.getInstance(myProject)
.disablePostprocessFormattingInside(
() -> {
if (myAltFullRange != null) {
altCommitToOriginal(e);
return;
}
commitToOriginalInner();
});
PsiDocumentManager.getInstance(myProject)
.doPostponedOperationsAndUnblockDocument(myOrigDocument);
}
} finally {
myCommittingToOriginal = false;
}
}
private static Trinity<PsiElement, TextRange, Value> getSelectedExpression(
final Project project, final Editor editor, final Point point, final ValueHintType type) {
final Ref<PsiElement> selectedExpression = Ref.create(null);
final Ref<TextRange> currentRange = Ref.create(null);
final Ref<Value> preCalculatedValue = Ref.create(null);
PsiDocumentManager.getInstance(project)
.commitAndRunReadAction(
new Runnable() {
public void run() {
// Point -> offset
final int offset = calculateOffset(editor, point);
PsiFile psiFile =
PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
if (psiFile == null || !psiFile.isValid()) return;
int selectionStart = editor.getSelectionModel().getSelectionStart();
int selectionEnd = editor.getSelectionModel().getSelectionEnd();
if ((type == ValueHintType.MOUSE_CLICK_HINT
|| type == ValueHintType.MOUSE_ALT_OVER_HINT)
&& (selectionStart <= offset && offset <= selectionEnd)) {
PsiElement ctx =
(selectionStart > 0)
? psiFile.findElementAt(selectionStart - 1)
: psiFile.findElementAt(selectionStart);
try {
String text = editor.getSelectionModel().getSelectedText();
if (text != null && ctx != null) {
selectedExpression.set(
JVMElementFactories.getFactory(ctx.getLanguage(), project)
.createExpressionFromText(text, ctx));
currentRange.set(
new TextRange(
editor.getSelectionModel().getSelectionStart(),
editor.getSelectionModel().getSelectionEnd()));
}
} catch (IncorrectOperationException ignored) {
}
}
if (currentRange.get() == null) {
PsiElement elementAtCursor = psiFile.findElementAt(offset);
if (elementAtCursor == null) {
return;
}
Pair<PsiElement, TextRange> pair =
findExpression(
elementAtCursor,
type == ValueHintType.MOUSE_CLICK_HINT
|| type == ValueHintType.MOUSE_ALT_OVER_HINT);
if (pair == null) {
if (type == ValueHintType.MOUSE_OVER_HINT) {
final DebuggerSession debuggerSession =
DebuggerManagerEx.getInstanceEx(project)
.getContext()
.getDebuggerSession();
if (debuggerSession != null && debuggerSession.isPaused()) {
final Pair<Method, Value> lastExecuted =
debuggerSession.getProcess().getLastExecutedMethod();
if (lastExecuted != null) {
final Method method = lastExecuted.getFirst();
if (method != null) {
final Pair<PsiElement, TextRange> expressionPair =
findExpression(elementAtCursor, true);
if (expressionPair != null
&& expressionPair.getFirst() instanceof PsiMethodCallExpression) {
final PsiMethodCallExpression methodCallExpression =
(PsiMethodCallExpression) expressionPair.getFirst();
final PsiMethod psiMethod = methodCallExpression.resolveMethod();
if (psiMethod != null) {
final JVMName jvmSignature = JVMNameUtil.getJVMSignature(psiMethod);
try {
if (method.name().equals(psiMethod.getName())
&& method
.signature()
.equals(
jvmSignature.getName(debuggerSession.getProcess()))) {
pair = expressionPair;
preCalculatedValue.set(lastExecuted.getSecond());
}
} catch (EvaluateException ignored) {
}
}
}
}
}
}
}
}
if (pair == null) {
return;
}
selectedExpression.set(pair.getFirst());
currentRange.set(pair.getSecond());
}
}
});
return Trinity.create(selectedExpression.get(), currentRange.get(), preCalculatedValue.get());
}
@Override
@NotNull
public AnnotationPlace chooseAnnotationsPlace(@NotNull final PsiElement element) {
if (!element.isPhysical()) return AnnotationPlace.IN_CODE; // element just created
if (!element.getManager().isInProject(element)) return AnnotationPlace.EXTERNAL;
final Project project = myPsiManager.getProject();
final PsiFile containingFile = element.getContainingFile();
final VirtualFile virtualFile = containingFile.getVirtualFile();
LOG.assertTrue(virtualFile != null);
final List<OrderEntry> entries =
ProjectRootManager.getInstance(project).getFileIndex().getOrderEntriesForFile(virtualFile);
if (!entries.isEmpty()) {
for (OrderEntry entry : entries) {
if (!(entry instanceof ModuleOrderEntry)) {
if (AnnotationOrderRootType.getUrls(entry).length > 0) {
return AnnotationPlace.EXTERNAL;
}
break;
}
}
}
final MyExternalPromptDialog dialog =
ApplicationManager.getApplication().isUnitTestMode()
|| ApplicationManager.getApplication().isHeadlessEnvironment()
? null
: new MyExternalPromptDialog(project);
if (dialog != null && dialog.isToBeShown()) {
final PsiElement highlightElement =
element instanceof PsiNameIdentifierOwner
? ((PsiNameIdentifierOwner) element).getNameIdentifier()
: element.getNavigationElement();
LOG.assertTrue(highlightElement != null);
final Editor editor = FileEditorManager.getInstance(project).getSelectedTextEditor();
final List<RangeHighlighter> highlighters = new ArrayList<RangeHighlighter>();
final boolean highlight =
editor != null
&& editor.getDocument()
== PsiDocumentManager.getInstance(project).getDocument(containingFile);
try {
if (highlight) { // do not highlight for batch inspections
final EditorColorsManager colorsManager = EditorColorsManager.getInstance();
final TextAttributes attributes =
colorsManager.getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
final TextRange textRange = highlightElement.getTextRange();
HighlightManager.getInstance(project)
.addRangeHighlight(
editor,
textRange.getStartOffset(),
textRange.getEndOffset(),
attributes,
true,
highlighters);
final LogicalPosition logicalPosition =
editor.offsetToLogicalPosition(textRange.getStartOffset());
editor.getScrollingModel().scrollTo(logicalPosition, ScrollType.CENTER);
}
dialog.show();
if (dialog.getExitCode() == 2) {
return AnnotationPlace.EXTERNAL;
} else if (dialog.getExitCode() == 1) {
return AnnotationPlace.NOWHERE;
}
} finally {
if (highlight) {
HighlightManager.getInstance(project)
.removeSegmentHighlighter(editor, highlighters.get(0));
}
}
} else if (dialog != null) {
dialog.close(DialogWrapper.OK_EXIT_CODE);
}
return AnnotationPlace.IN_CODE;
}
private void commitChanges(XmlFile xmlFile) {
Document doc = PsiDocumentManager.getInstance(myPsiManager.getProject()).getDocument(xmlFile);
assert doc != null;
FileDocumentManager.getInstance().saveDocument(doc);
}
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;
}
}
