@Nullable
private Location buildLocation() {
if (mySelectedTaskProvider == null) {
return null;
}
ExternalTaskExecutionInfo task = mySelectedTaskProvider.produce();
if (task == null) {
return null;
}
String projectPath = task.getSettings().getExternalProjectPath();
String name =
myExternalSystemId.getReadableName()
+ projectPath
+ StringUtil.join(task.getSettings().getTaskNames(), " ");
// We create a dummy text file instead of re-using external system file in order to avoid
// clashing with other configuration producers.
// For example gradle files are enhanced groovy scripts but we don't want to run them via
// regular IJ groovy script runners.
// Gradle tooling api should be used for running gradle tasks instead. IJ execution sub-system
// operates on Location objects
// which encapsulate PsiElement and groovy runners are automatically applied if that PsiElement
// IS-A GroovyFile.
PsiFile file =
PsiFileFactory.getInstance(myProject)
.createFileFromText(name, PlainTextFileType.INSTANCE, "nichts");
return new ExternalSystemTaskLocation(myProject, file, task);
}
@Nullable
@Override
public Object getData(@NonNls String dataId) {
if (ExternalSystemDataKeys.RECENT_TASKS_LIST.is(dataId)) {
return myRecentTasksList;
} else if (ExternalSystemDataKeys.ALL_TASKS_MODEL.is(dataId)) {
return myAllTasksModel;
} else if (ExternalSystemDataKeys.EXTERNAL_SYSTEM_ID.is(dataId)) {
return myExternalSystemId;
} else if (ExternalSystemDataKeys.NOTIFICATION_GROUP.is(dataId)) {
return myNotificationGroup;
} else if (ExternalSystemDataKeys.SELECTED_TASK.is(dataId)) {
return mySelectedTaskProvider == null ? null : mySelectedTaskProvider.produce();
} else if (ExternalSystemDataKeys.SELECTED_PROJECT.is(dataId)) {
if (mySelectedTaskProvider != myAllTasksTree) {
return null;
} else {
Object component = myAllTasksTree.getLastSelectedPathComponent();
if (component instanceof ExternalSystemNode) {
Object element = ((ExternalSystemNode) component).getDescriptor().getElement();
return element instanceof ExternalProjectPojo ? element : null;
}
}
} else if (Location.DATA_KEY.is(dataId)) {
Location location = buildLocation();
return location == null ? super.getData(dataId) : location;
}
return null;
}
@Nullable
private static String getStringContent(@Nullable 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) return null;
RawText raw = RawText.fromTransferable(content);
if (raw != null) return raw.rawText;
try {
return (String) content.getTransferData(DataFlavor.stringFlavor);
} catch (UnsupportedFlavorException ignore) {
} catch (IOException ignore) {
}
return null;
}
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));
}
}
}
