Example usage for com.intellij.openapi.editor EditorModificationUtil deleteSelectedText

List of usage examples for com.intellij.openapi.editor EditorModificationUtil deleteSelectedText

  1. HOME
  2. Java
  3. com.intellij.openapi
  4. com.intellij.openapi.editor.*
  5. EditorModificationUtil
  6. deleteSelectedText

Introduction

In this page you can find the example usage for com.intellij.openapi.editor EditorModificationUtil deleteSelectedText.

Prototype

public static void deleteSelectedText(Editor editor)

Source Link

Usage

From source file:com.intellij.codeInsight.editorActions.BackspaceHandler.java

License:Apache License

public static void deleteToTargetPosition(@NotNull Editor editor, @NotNull LogicalPosition pos) {
    final int offset = editor.getCaretModel().getOffset();
    final int targetOffset = editor.logicalPositionToOffset(pos);
    editor.getSelectionModel().setSelection(targetOffset, offset);
    EditorModificationUtil.deleteSelectedText(editor);
    editor.getCaretModel().moveToLogicalPosition(pos);
}

From source file:com.intellij.codeInsight.editorActions.CompletionAutoPopupHandler.java

License:Apache License

@Override
public Result checkAutoPopup(char charTyped, final Project project, final Editor editor, final PsiFile file) {
    CompletionPhase oldPhase = CompletionServiceImpl.getCompletionPhase();

    if (oldPhase instanceof CompletionPhase.CommittingDocuments
            && ((CompletionPhase.CommittingDocuments) oldPhase).isRestartingCompletion()) {
        oldPhase.indicator.scheduleRestart();
        return Result.STOP;
    }/*from   ww w . j  av  a2  s  .c o  m*/

    LookupImpl lookup = (LookupImpl) LookupManager.getActiveLookup(editor);
    if (lookup != null) {
        if (editor.getSelectionModel().hasSelection()) {
            lookup.performGuardedChange(new Runnable() {
                @Override
                public void run() {
                    EditorModificationUtil.deleteSelectedText(editor);
                }
            });
        }
        return Result.STOP;
    }

    if (Character.isLetter(charTyped) || charTyped == '_') {
        AutoPopupController.getInstance(project).scheduleAutoPopup(editor);
        return Result.STOP;
    }

    if (CompletionServiceImpl.isPhase(CompletionPhase.CommittingDocuments.class)) {
        CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
    }
    return Result.CONTINUE;
}

From source file:com.intellij.codeInsight.editorActions.CutHandler.java

License:Apache License

@Override
public void executeWriteAction(final Editor editor, Caret caret, DataContext dataContext) {
    assert caret == null : "Invocation of 'cut' operation for specific caret is not supported";
    Project project = CommonDataKeys.PROJECT
            .getData(DataManager.getInstance().getDataContext(editor.getContentComponent()));
    if (project == null) {
        if (myOriginalHandler != null) {
            myOriginalHandler.execute(editor, null, dataContext);
        }/*from w w  w.ja  va 2  s . c  o  m*/
        return;
    }

    final PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());

    if (file == null) {
        if (myOriginalHandler != null) {
            myOriginalHandler.execute(editor, null, dataContext);
        }
        return;
    }

    final SelectionModel selectionModel = editor.getSelectionModel();
    if (!selectionModel.hasSelection(true) && !selectionModel.hasBlockSelection()) {
        if (Registry.is(CopyAction.SKIP_COPY_AND_CUT_FOR_EMPTY_SELECTION_KEY)) {
            return;
        }
        editor.getCaretModel().runForEachCaret(new CaretAction() {
            @Override
            public void perform(Caret caret) {
                selectionModel.selectLineAtCaret();
            }
        });
        if (!selectionModel.hasSelection(true))
            return;
    }

    int start = selectionModel.getSelectionStart();
    int end = selectionModel.getSelectionEnd();
    final List<TextRange> selections = new ArrayList<TextRange>();
    if (editor.getCaretModel().supportsMultipleCarets()) {
        editor.getCaretModel().runForEachCaret(new CaretAction() {
            @Override
            public void perform(Caret caret) {
                selections.add(
                        new TextRange(selectionModel.getSelectionStart(), selectionModel.getSelectionEnd()));
            }
        });
    }

    EditorActionManager.getInstance().getActionHandler(IdeActions.ACTION_EDITOR_COPY).execute(editor, null,
            dataContext);

    if (editor.getCaretModel().supportsMultipleCarets()) {

        Collections.reverse(selections);
        final Iterator<TextRange> it = selections.iterator();
        editor.getCaretModel().runForEachCaret(new CaretAction() {
            @Override
            public void perform(Caret caret) {
                TextRange range = it.next();
                editor.getCaretModel().moveToOffset(range.getStartOffset());
                selectionModel.removeSelection();
                editor.getDocument().deleteString(range.getStartOffset(), range.getEndOffset());
            }
        });
        editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
    } else {
        if (start != end) {
            // There is a possible case that 'sticky selection' is active. It's automatically removed on copying then, so, we explicitly
            // remove the text.
            editor.getDocument().deleteString(start, end);
        } else {
            EditorModificationUtil.deleteSelectedText(editor);
        }
    }
}

From source file:com.intellij.codeInsight.editorActions.EnterHandler.java

License:Apache License

private void executeWriteActionInner(Editor editor, Caret caret, DataContext dataContext, Project project) {
    CodeInsightSettings settings = CodeInsightSettings.getInstance();
    if (project == null) {
        myOriginalHandler.execute(editor, caret, dataContext);
        return;// w w  w  . ja va  2 s.c om
    }
    final Document document = editor.getDocument();
    final PsiFile file = PsiUtilBase.getPsiFileInEditor(editor, project);

    if (file == null) {
        myOriginalHandler.execute(editor, caret, dataContext);
        return;
    }

    CommandProcessor.getInstance().setCurrentCommandName(CodeInsightBundle.message("command.name.typing"));

    EditorModificationUtil.deleteSelectedText(editor);

    int caretOffset = editor.getCaretModel().getOffset();
    CharSequence text = document.getCharsSequence();
    int length = document.getTextLength();
    if (caretOffset < length && text.charAt(caretOffset) != '\n') {
        int offset1 = CharArrayUtil.shiftBackward(text, caretOffset, " \t");
        if (offset1 < 0 || text.charAt(offset1) == '\n') {
            int offset2 = CharArrayUtil.shiftForward(text, offset1 + 1, " \t");
            boolean isEmptyLine = offset2 >= length || text.charAt(offset2) == '\n';
            if (!isEmptyLine) { // we are in leading spaces of a non-empty line
                myOriginalHandler.execute(editor, caret, dataContext);
                return;
            }
        }
    }

    final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project);
    documentManager.commitDocument(document);

    boolean forceIndent = false;
    boolean forceSkipIndent = false;
    Ref<Integer> caretOffsetRef = new Ref<Integer>(caretOffset);
    Ref<Integer> caretAdvanceRef = new Ref<Integer>(0);

    final EnterHandlerDelegate[] delegates = Extensions.getExtensions(EnterHandlerDelegate.EP_NAME);
    for (EnterHandlerDelegate delegate : delegates) {
        EnterHandlerDelegate.Result result = delegate.preprocessEnter(file, editor, caretOffsetRef,
                caretAdvanceRef, dataContext, myOriginalHandler);
        if (caretOffsetRef.get() > document.getTextLength()) {
            throw new AssertionError("Wrong caret offset change by " + delegate);
        }

        if (result == EnterHandlerDelegate.Result.Stop) {
            return;
        }
        if (result != EnterHandlerDelegate.Result.Continue) {
            if (result == EnterHandlerDelegate.Result.DefaultForceIndent) {
                forceIndent = true;
            } else if (result == EnterHandlerDelegate.Result.DefaultSkipIndent) {
                forceSkipIndent = true;
            }
            break;
        }
    }

    text = document.getCharsSequence(); // update after changes done in preprocessEnter()
    caretOffset = caretOffsetRef.get().intValue();
    boolean isFirstColumn = caretOffset == 0 || text.charAt(caretOffset - 1) == '\n';
    final boolean insertSpace = !isFirstColumn && !(caretOffset >= text.length()
            || text.charAt(caretOffset) == ' ' || text.charAt(caretOffset) == '\t');
    editor.getCaretModel().moveToOffset(caretOffset);
    myOriginalHandler.execute(editor, caret, dataContext);
    if (!editor.isInsertMode() || forceSkipIndent) {
        return;
    }

    if (settings.SMART_INDENT_ON_ENTER || forceIndent) {
        caretOffset += 1;
        caretOffset = CharArrayUtil.shiftForward(editor.getDocument().getCharsSequence(), caretOffset, " \t");
    } else {
        caretOffset = editor.getCaretModel().getOffset();
    }

    documentManager.commitAllDocuments();
    final DoEnterAction action = new DoEnterAction(file, editor, document, dataContext, caretOffset,
            !insertSpace, caretAdvanceRef.get(), project);
    action.setForceIndent(forceIndent);
    action.run();
    documentManager.commitDocument(document);
    for (EnterHandlerDelegate delegate : delegates) {
        if (delegate.postProcessEnter(file, editor, dataContext) == EnterHandlerDelegate.Result.Stop) {
            break;
        }
    }
    documentManager.commitDocument(document);
}

From source file:com.intellij.codeInsight.lookup.impl.LookupImpl.java

License:Apache License

private void insertLookupString(LookupElement item, final int prefix) {
    final Document document = myEditor.getDocument();

    final String lookupString = getCaseCorrectedLookupString(item);

    if (myEditor.getSelectionModel().hasBlockSelection()) {
        LogicalPosition blockStart = myEditor.getSelectionModel().getBlockStart();
        LogicalPosition blockEnd = myEditor.getSelectionModel().getBlockEnd();
        assert blockStart != null && blockEnd != null;

        int minLine = Math.min(blockStart.line, blockEnd.line);
        int maxLine = Math.max(blockStart.line, blockEnd.line);
        int minColumn = Math.min(blockStart.column, blockEnd.column);
        int maxColumn = Math.max(blockStart.column, blockEnd.column);

        int caretLine = document.getLineNumber(myEditor.getCaretModel().getOffset());

        for (int line = minLine; line <= maxLine; line++) {
            int bs = myEditor.logicalPositionToOffset(new LogicalPosition(line, minColumn));
            int start = bs - prefix;
            int end = myEditor.logicalPositionToOffset(new LogicalPosition(line, maxColumn));
            if (start > end) {
                LOG.error("bs=" + bs + "; start=" + start + "; end=" + end + "; blockStart=" + blockStart
                        + "; blockEnd=" + blockEnd + "; line=" + line + "; len="
                        + (document.getLineEndOffset(line) - document.getLineStartOffset(line)));
            }//from   w  w  w.j  a v a2s . co m
            document.replaceString(start, end, lookupString);
        }
        LogicalPosition start = new LogicalPosition(minLine, minColumn - prefix);
        LogicalPosition end = new LogicalPosition(maxLine, start.column + lookupString.length());
        myEditor.getSelectionModel().setBlockSelection(start, end);
        myEditor.getCaretModel().moveToLogicalPosition(new LogicalPosition(caretLine, end.column));
    } else {
        final Editor hostEditor = InjectedLanguageUtil.getTopLevelEditor(myEditor);
        hostEditor.getCaretModel().runForEachCaret(new CaretAction() {
            @Override
            public void perform(Caret caret) {
                EditorModificationUtil.deleteSelectedText(hostEditor);
                final int caretOffset = hostEditor.getCaretModel().getOffset();
                int lookupStart = Math.max(caretOffset - prefix, 0);

                int len = hostEditor.getDocument().getTextLength();
                LOG.assertTrue(lookupStart >= 0 && lookupStart <= len,
                        "ls: " + lookupStart + " caret: " + caretOffset + " prefix:" + prefix + " doc: " + len);
                LOG.assertTrue(caretOffset >= 0 && caretOffset <= len, "co: " + caretOffset + " doc: " + len);

                hostEditor.getDocument().replaceString(lookupStart, caretOffset, lookupString);

                int offset = lookupStart + lookupString.length();
                hostEditor.getCaretModel().moveToOffset(offset);
                hostEditor.getSelectionModel().removeSelection();
            }
        });
    }

    myEditor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
}

From source file:com.intellij.codeInsight.lookup.impl.LookupImpl.java

License:Apache License

public void replacePrefix(final String presentPrefix, final String newPrefix) {
    if (!performGuardedChange(new Runnable() {
        @Override/*from  ww w . java 2  s  . com*/
        public void run() {
            EditorModificationUtil.deleteSelectedText(myEditor);
            int offset = myEditor.getCaretModel().getOffset();
            final int start = offset - presentPrefix.length();
            myEditor.getDocument().replaceString(start, offset, newPrefix);

            Map<LookupElement, PrefixMatcher> newMatchers = new HashMap<LookupElement, PrefixMatcher>();
            for (LookupElement item : getItems()) {
                if (item.isValid()) {
                    PrefixMatcher matcher = itemMatcher(item).cloneWithPrefix(newPrefix);
                    if (matcher.prefixMatches(item)) {
                        newMatchers.put(item, matcher);
                    }
                }
            }
            myMatchers.clear();
            myMatchers.putAll(newMatchers);

            myOffsets.clearAdditionalPrefix();

            myEditor.getCaretModel().moveToOffset(start + newPrefix.length());
        }
    })) {
        return;
    }
    synchronized (myList) {
        myPresentableArranger.prefixChanged(this);
    }
    refreshUi(true, true);
}

From source file:com.intellij.codeInsight.lookup.impl.LookupTypedHandler.java

License:Apache License

@SuppressWarnings("AssignmentToStaticFieldFromInstanceMethod")
@Override// w  ww. j  a va 2 s  . c o m
public Result beforeCharTyped(final char charTyped, Project project, final Editor editor, PsiFile file,
        FileType fileType) {
    final LookupImpl lookup = (LookupImpl) LookupManager.getActiveLookup(editor);
    if (lookup == null) {
        return Result.CONTINUE;
    }

    if (charTyped == ' ' && ChooseItemAction.hasTemplatePrefix(lookup, TemplateSettings.SPACE_CHAR)) {
        return Result.CONTINUE;
    }

    final CharFilter.Result result = getLookupAction(charTyped, lookup);
    if (lookup.isLookupDisposed()) {
        return Result.CONTINUE;
    }

    if (!lookup.performGuardedChange(new Runnable() {
        @Override
        public void run() {
            EditorModificationUtil.deleteSelectedText(editor);
        }
    })) {
        return Result.STOP;
    }
    if (result == CharFilter.Result.ADD_TO_PREFIX) {
        Document document = editor.getDocument();
        long modificationStamp = document.getModificationStamp();

        if (!lookup.performGuardedChange(new Runnable() {
            @Override
            public void run() {
                EditorModificationUtil.typeInStringAtCaretHonorMultipleCarets(editor, String.valueOf(charTyped),
                        true);
            }
        })) {
            return Result.STOP;
        }
        lookup.appendPrefix(charTyped);
        if (lookup.isStartCompletionWhenNothingMatches() && lookup.getItems().isEmpty()) {
            final CompletionProgressIndicator completion = CompletionServiceImpl.getCompletionService()
                    .getCurrentCompletion();
            if (completion != null) {
                completion.scheduleRestart();
            } else {
                AutoPopupController.getInstance(editor.getProject()).scheduleAutoPopup(editor);
            }
        }

        AutoHardWrapHandler.getInstance().wrapLineIfNecessary(editor,
                DataManager.getInstance().getDataContext(editor.getContentComponent()), modificationStamp);

        final CompletionProgressIndicator completion = CompletionServiceImpl.getCompletionService()
                .getCurrentCompletion();
        if (completion != null) {
            completion.prefixUpdated();
        }
        return Result.STOP;
    }

    if (result == CharFilter.Result.SELECT_ITEM_AND_FINISH_LOOKUP && lookup.isFocused()) {
        LookupElement item = lookup.getCurrentItem();
        if (item != null) {
            if (completeTillTypedCharOccurrence(charTyped, lookup, item)) {
                return Result.STOP;
            }

            FeatureUsageTracker.getInstance()
                    .triggerFeatureUsed(CodeCompletionFeatures.EDITING_COMPLETION_FINISH_BY_DOT_ETC);
            lookup.finishLookup(charTyped);
            return Result.STOP;
        }
    }

    lookup.hide();
    TypedHandler.autoPopupCompletion(editor, charTyped, project, file);
    return Result.CONTINUE;
}

From source file:com.intellij.codeInsight.template.impl.TemplateManagerImpl.java

License:Apache License

private void startTemplate(final Editor editor, final String selectionString, final Template template,
        boolean inSeparateCommand, TemplateEditingListener listener,
        final PairProcessor<String, String> processor, final Map<String, String> predefinedVarValues) {
    final TemplateState templateState = initTemplateState(editor);

    //noinspection unchecked
    templateState.getProperties().put(ExpressionContext.SELECTION, selectionString);

    if (listener != null) {
        templateState.addTemplateStateListener(listener);
    }/*w  w  w.j  ava2 s. c  o  m*/
    Runnable r = new Runnable() {
        @Override
        public void run() {
            if (selectionString != null) {
                ApplicationManager.getApplication().runWriteAction(new Runnable() {
                    @Override
                    public void run() {
                        EditorModificationUtil.deleteSelectedText(editor);
                    }
                });
            } else {
                editor.getSelectionModel().removeSelection();
            }
            templateState.start((TemplateImpl) template, processor, predefinedVarValues);
        }
    };
    if (inSeparateCommand) {
        CommandProcessor.getInstance().executeCommand(myProject, r,
                CodeInsightBundle.message("insert.code.template.command"), null);
    } else {
        r.run();
    }

    if (shouldSkipInTests()) {
        if (!templateState.isFinished())
            templateState.gotoEnd();
    }
}

From source file:com.intellij.ide.actions.PasteReferenceProvider.java

License:Apache License

private static void insert(final String fqn, final PsiElement element, final Editor editor,
        final QualifiedNameProvider provider) {
    final Project project = editor.getProject();
    if (project == null)
        return;//from   w ww  .j a va2s . c  o m

    final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project);
    documentManager.commitDocument(editor.getDocument());

    final PsiFile file = documentManager.getPsiFile(editor.getDocument());
    if (!FileModificationService.getInstance().prepareFileForWrite(file))
        return;

    CommandProcessor.getInstance().executeCommand(project, new Runnable() {
        @Override
        public void run() {
            ApplicationManager.getApplication().runWriteAction(new Runnable() {
                @Override
                public void run() {
                    Document document = editor.getDocument();
                    documentManager.doPostponedOperationsAndUnblockDocument(document);
                    documentManager.commitDocument(document);
                    EditorModificationUtil.deleteSelectedText(editor);
                    provider.insertQualifiedName(fqn, element, editor, project);
                }
            });
        }
    }, IdeBundle.message("command.pasting.reference"), null);
}

From source file:com.vladsch.MissingInActions.actions.character.BackspaceToWordStartNotEolActionHandler.java

License:Apache License

@Override
public void executeWriteAction(Editor editor, Caret caret, DataContext dataContext) {
    CommandProcessor.getInstance().setCurrentCommandGroupId(EditorActionUtil.DELETE_COMMAND_GROUP);
    CopyPasteManager.getInstance().stopKillRings();
    if (editor.getSelectionModel().hasSelection()) {
        EditorModificationUtil.deleteSelectedText(editor);
        return;/*from w  w  w . j av a 2  s .com*/
    }
    backspaceToWordStart(editor);
}