Examples with HighlightManager com.intellij.codeInsight.highlighting.HighlightManager used on opensource projects

Example 21 with HighlightManager

use of com.intellij.codeInsight.highlighting.HighlightManager in project intellij-community by JetBrains.

the class RefactoringUtil method highlightAllOccurrences.

/**
   * @return List of highlighters
   */
public static List<RangeHighlighter> highlightAllOccurrences(Project project, PsiElement[] occurrences, Editor editor) {
    ArrayList<RangeHighlighter> highlighters = new ArrayList<>();
    HighlightManager highlightManager = HighlightManager.getInstance(project);
    EditorColorsManager colorsManager = EditorColorsManager.getInstance();
    TextAttributes attributes = colorsManager.getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
    if (occurrences.length > 1) {
        for (PsiElement occurrence : occurrences) {
            final RangeMarker rangeMarker = occurrence.getUserData(ElementToWorkOn.TEXT_RANGE);
            if (rangeMarker != null && rangeMarker.isValid()) {
                highlightManager.addRangeHighlight(editor, rangeMarker.getStartOffset(), rangeMarker.getEndOffset(), attributes, true, highlighters);
            } else {
                final TextRange textRange = occurrence.getTextRange();
                highlightManager.addRangeHighlight(editor, textRange.getStartOffset(), textRange.getEndOffset(), attributes, true, highlighters);
            }
        }
    }
    return highlighters;
}

Example 22 with HighlightManager

use of com.intellij.codeInsight.highlighting.HighlightManager in project intellij-community by JetBrains.

the class CopyReferenceAction method actionPerformed.

@Override
public void actionPerformed(AnActionEvent e) {
    DataContext dataContext = e.getDataContext();
    Editor editor = CommonDataKeys.EDITOR.getData(dataContext);
    Project project = CommonDataKeys.PROJECT.getData(dataContext);
    List<PsiElement> elements = getElementsToCopy(editor, dataContext);
    if (!doCopy(elements, project, editor) && editor != null && project != null) {
        Document document = editor.getDocument();
        PsiFile file = PsiDocumentManager.getInstance(project).getCachedPsiFile(document);
        if (file != null) {
            String toCopy = getFileFqn(file) + ":" + (editor.getCaretModel().getLogicalPosition().line + 1);
            CopyPasteManager.getInstance().setContents(new StringSelection(toCopy));
            setStatusBarText(project, toCopy + " has been copied");
        }
        return;
    }
    HighlightManager highlightManager = HighlightManager.getInstance(project);
    EditorColorsManager manager = EditorColorsManager.getInstance();
    TextAttributes attributes = manager.getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
    if (elements.size() == 1 && editor != null && project != null) {
        PsiElement element = elements.get(0);
        PsiElement nameIdentifier = IdentifierUtil.getNameIdentifier(element);
        if (nameIdentifier != null) {
            highlightManager.addOccurrenceHighlights(editor, new PsiElement[] { nameIdentifier }, attributes, true, null);
        } else {
            PsiReference reference = TargetElementUtil.findReference(editor, editor.getCaretModel().getOffset());
            if (reference != null) {
                highlightManager.addOccurrenceHighlights(editor, new PsiReference[] { reference }, attributes, true, null);
            } else if (element != PsiDocumentManager.getInstance(project).getCachedPsiFile(editor.getDocument())) {
                highlightManager.addOccurrenceHighlights(editor, new PsiElement[] { element }, attributes, true, null);
            }
        }
    }
}

Example 23 with HighlightManager

use of com.intellij.codeInsight.highlighting.HighlightManager in project intellij-community by JetBrains.

the class HippieWordCompletionHandler method highlightWord.

private static void highlightWord(final CompletionVariant variant, final Project project) {
    HighlightManager highlightManager = HighlightManager.getInstance(project);
    EditorColorsManager colorManager = EditorColorsManager.getInstance();
    TextAttributes attributes = colorManager.getGlobalScheme().getAttributes(EditorColors.TEXT_SEARCH_RESULT_ATTRIBUTES);
    highlightManager.addOccurrenceHighlight(variant.editor, variant.offset, variant.offset + variant.variant.length(), attributes, HighlightManager.HIDE_BY_ANY_KEY, null, null);
}

Example 24 with HighlightManager

use of com.intellij.codeInsight.highlighting.HighlightManager in project intellij-community by JetBrains.

the class InlineLocalHandler method invoke.

/**
   * should be called in AtomicAction
   */
public static void invoke(@NotNull final Project project, final Editor editor, final PsiLocalVariable local, PsiReferenceExpression refExpr) {
    if (!CommonRefactoringUtil.checkReadOnlyStatus(project, local))
        return;
    final HighlightManager highlightManager = HighlightManager.getInstance(project);
    final String localName = local.getName();
    final List<PsiElement> innerClassesWithUsages = Collections.synchronizedList(new ArrayList<PsiElement>());
    final List<PsiElement> innerClassUsages = Collections.synchronizedList(new ArrayList<PsiElement>());
    final PsiClass containingClass = PsiTreeUtil.getParentOfType(local, PsiClass.class);
    final Query<PsiReference> query = ReferencesSearch.search(local);
    if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(() -> {
        if (query.findFirst() == null) {
            LOG.assertTrue(refExpr == null);
            ApplicationManager.getApplication().invokeLater(() -> {
                String message = RefactoringBundle.message("variable.is.never.used", localName);
                CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_VARIABLE);
            }, ModalityState.NON_MODAL);
            return;
        }
        query.forEach(psiReference -> {
            final PsiElement element = psiReference.getElement();
            PsiElement innerClass = PsiTreeUtil.getParentOfType(element, PsiClass.class, PsiLambdaExpression.class);
            while (innerClass != containingClass && innerClass != null) {
                final PsiElement parentPsiClass = PsiTreeUtil.getParentOfType(innerClass.getParent(), PsiClass.class, PsiLambdaExpression.class);
                if (parentPsiClass == containingClass) {
                    if (innerClass instanceof PsiLambdaExpression) {
                        if (PsiTreeUtil.isAncestor(innerClass, local, false)) {
                            innerClassesWithUsages.add(element);
                            innerClass = parentPsiClass;
                            continue;
                        }
                    }
                    innerClassesWithUsages.add(innerClass);
                    innerClassUsages.add(element);
                }
                innerClass = parentPsiClass;
            }
            return true;
        });
    }, "Find Usages", true, project)) {
        return;
    }
    final PsiCodeBlock containerBlock = PsiTreeUtil.getParentOfType(local, PsiCodeBlock.class);
    if (containerBlock == null) {
        final String message = RefactoringBundle.getCannotRefactorMessage("Variable is declared outside a code block");
        CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_VARIABLE);
        return;
    }
    final PsiExpression defToInline = getDefToInline(local, innerClassesWithUsages.isEmpty() ? refExpr : innerClassesWithUsages.get(0), containerBlock);
    if (defToInline == null) {
        final String key = refExpr == null ? "variable.has.no.initializer" : "variable.has.no.dominating.definition";
        String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message(key, localName));
        CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_VARIABLE);
        return;
    }
    List<PsiElement> refsToInlineList = new ArrayList<>();
    Collections.addAll(refsToInlineList, DefUseUtil.getRefs(containerBlock, local, defToInline));
    for (PsiElement innerClassUsage : innerClassUsages) {
        if (!refsToInlineList.contains(innerClassUsage)) {
            refsToInlineList.add(innerClassUsage);
        }
    }
    if (refsToInlineList.size() == 0) {
        String message = RefactoringBundle.message("variable.is.never.used.before.modification", localName);
        CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_VARIABLE);
        return;
    }
    final Ref<Boolean> inlineAll = new Ref<>(true);
    if (editor != null && !ApplicationManager.getApplication().isUnitTestMode()) {
        int occurrencesCount = refsToInlineList.size();
        if (refExpr != null && occurrencesCount > 1 || EditorSettingsExternalizable.getInstance().isShowInlineLocalDialog()) {
            final InlineLocalDialog inlineLocalDialog = new InlineLocalDialog(project, local, refExpr, occurrencesCount);
            if (!inlineLocalDialog.showAndGet()) {
                WindowManager.getInstance().getStatusBar(project).setInfo(RefactoringBundle.message("press.escape.to.remove.the.highlighting"));
                return;
            }
            if (refExpr != null && inlineLocalDialog.isInlineThis()) {
                refsToInlineList = Collections.singletonList(refExpr);
                inlineAll.set(false);
            }
        }
    }
    final PsiElement[] refsToInline = PsiUtilCore.toPsiElementArray(refsToInlineList);
    final EditorColorsManager manager = EditorColorsManager.getInstance();
    final TextAttributes attributes = manager.getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
    final TextAttributes writeAttributes = manager.getGlobalScheme().getAttributes(EditorColors.WRITE_SEARCH_RESULT_ATTRIBUTES);
    if (editor != null && !ApplicationManager.getApplication().isUnitTestMode()) {
        // TODO : check if initializer uses fieldNames that possibly will be hidden by other
        // locals with the same names after inlining
        highlightManager.addOccurrenceHighlights(editor, refsToInline, attributes, true, null);
    }
    if (refExpr != null && PsiUtil.isAccessedForReading(refExpr) && ArrayUtil.find(refsToInline, refExpr) < 0) {
        final PsiElement[] defs = DefUseUtil.getDefs(containerBlock, local, refExpr);
        LOG.assertTrue(defs.length > 0);
        highlightManager.addOccurrenceHighlights(editor, defs, attributes, true, null);
        String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("variable.is.accessed.for.writing", localName));
        CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_VARIABLE);
        WindowManager.getInstance().getStatusBar(project).setInfo(RefactoringBundle.message("press.escape.to.remove.the.highlighting"));
        return;
    }
    PsiTryStatement tryStatement = PsiTreeUtil.getParentOfType(defToInline, PsiTryStatement.class);
    if (tryStatement != null) {
        if (ExceptionUtil.getThrownExceptions(defToInline).isEmpty()) {
            tryStatement = null;
        }
    }
    PsiFile workingFile = local.getContainingFile();
    for (PsiElement ref : refsToInline) {
        final PsiFile otherFile = ref.getContainingFile();
        if (!otherFile.equals(workingFile)) {
            String message = RefactoringBundle.message("variable.is.referenced.in.multiple.files", localName);
            CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_VARIABLE);
            return;
        }
        if (tryStatement != null && !PsiTreeUtil.isAncestor(tryStatement, ref, false)) {
            CommonRefactoringUtil.showErrorHint(project, editor, "Unable to inline outside try/catch statement", REFACTORING_NAME, HelpID.INLINE_VARIABLE);
            return;
        }
    }
    for (final PsiElement ref : refsToInline) {
        final PsiElement[] defs = DefUseUtil.getDefs(containerBlock, local, ref);
        boolean isSameDefinition = true;
        for (PsiElement def : defs) {
            isSameDefinition &= isSameDefinition(def, defToInline);
        }
        if (!isSameDefinition) {
            highlightManager.addOccurrenceHighlights(editor, defs, writeAttributes, true, null);
            highlightManager.addOccurrenceHighlights(editor, new PsiElement[] { ref }, attributes, true, null);
            String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("variable.is.accessed.for.writing.and.used.with.inlined", localName));
            CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_VARIABLE);
            WindowManager.getInstance().getStatusBar(project).setInfo(RefactoringBundle.message("press.escape.to.remove.the.highlighting"));
            return;
        }
    }
    final PsiElement writeAccess = checkRefsInAugmentedAssignmentOrUnaryModified(refsToInline, defToInline);
    if (writeAccess != null) {
        HighlightManager.getInstance(project).addOccurrenceHighlights(editor, new PsiElement[] { writeAccess }, writeAttributes, true, null);
        String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("variable.is.accessed.for.writing", localName));
        CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_VARIABLE);
        WindowManager.getInstance().getStatusBar(project).setInfo(RefactoringBundle.message("press.escape.to.remove.the.highlighting"));
        return;
    }
    final Runnable runnable = () -> {
        final String refactoringId = "refactoring.inline.local.variable";
        try {
            SmartPsiElementPointer<PsiExpression>[] exprs = new SmartPsiElementPointer[refsToInline.length];
            RefactoringEventData beforeData = new RefactoringEventData();
            beforeData.addElements(refsToInline);
            project.getMessageBus().syncPublisher(RefactoringEventListener.REFACTORING_EVENT_TOPIC).refactoringStarted(refactoringId, beforeData);
            WriteAction.run(() -> {
                final SmartPointerManager pointerManager = SmartPointerManager.getInstance(project);
                for (int idx = 0; idx < refsToInline.length; idx++) {
                    PsiJavaCodeReferenceElement refElement = (PsiJavaCodeReferenceElement) refsToInline[idx];
                    exprs[idx] = pointerManager.createSmartPsiElementPointer(InlineUtil.inlineVariable(local, defToInline, refElement));
                }
                if (inlineAll.get()) {
                    if (!isInliningVariableInitializer(defToInline)) {
                        defToInline.getParent().delete();
                    } else {
                        defToInline.delete();
                    }
                }
            });
            if (inlineAll.get() && ReferencesSearch.search(local).findFirst() == null && editor != null) {
                QuickFixFactory.getInstance().createRemoveUnusedVariableFix(local).invoke(project, editor, local.getContainingFile());
            }
            if (editor != null && !ApplicationManager.getApplication().isUnitTestMode()) {
                highlightManager.addOccurrenceHighlights(editor, ContainerUtil.convert(exprs, new PsiExpression[refsToInline.length], pointer -> pointer.getElement()), attributes, true, null);
                WindowManager.getInstance().getStatusBar(project).setInfo(RefactoringBundle.message("press.escape.to.remove.the.highlighting"));
            }
            WriteAction.run(() -> {
                for (SmartPsiElementPointer<PsiExpression> expr : exprs) {
                    InlineUtil.tryToInlineArrayCreationForVarargs(expr.getElement());
                }
            });
        } finally {
            final RefactoringEventData afterData = new RefactoringEventData();
            afterData.addElement(containingClass);
            project.getMessageBus().syncPublisher(RefactoringEventListener.REFACTORING_EVENT_TOPIC).refactoringDone(refactoringId, afterData);
        }
    };
    CommandProcessor.getInstance().executeCommand(project, () -> PostprocessReformattingAspect.getInstance(project).postponeFormattingInside(runnable), RefactoringBundle.message("inline.command", localName), null);
}

Example 25 with HighlightManager

use of com.intellij.codeInsight.highlighting.HighlightManager in project intellij-community by JetBrains.

the class BaseExpressionToFieldHandler method convertExpressionToField.

private boolean convertExpressionToField(PsiExpression selectedExpr, @Nullable Editor editor, PsiFile file, final Project project, PsiType tempType) {
    if (myParentClass == null) {
        if (FileTypeUtils.isInServerPageFile(file)) {
            CommonRefactoringUtil.showErrorHint(project, editor, RefactoringBundle.message("error.not.supported.for.jsp", getRefactoringName()), getRefactoringName(), getHelpID());
            return true;
        } else if ("package-info.java".equals(file.getName())) {
            CommonRefactoringUtil.showErrorHint(project, editor, RefactoringBundle.message("error.not.supported.for.package.info", getRefactoringName()), getRefactoringName(), getHelpID());
            return true;
        } else {
            LOG.error(file);
            return true;
        }
    }
    if (!validClass(myParentClass, editor)) {
        return true;
    }
    if (!CommonRefactoringUtil.checkReadOnlyStatus(project, file))
        return true;
    final OccurrenceManager occurrenceManager = createOccurrenceManager(selectedExpr, myParentClass);
    final PsiExpression[] occurrences = occurrenceManager.getOccurrences();
    final PsiElement anchorStatementIfAll = occurrenceManager.getAnchorStatementForAll();
    List<RangeHighlighter> highlighters = null;
    if (editor != null) {
        highlighters = RefactoringUtil.highlightAllOccurrences(project, occurrences, editor);
    }
    PsiElement tempAnchorElement = RefactoringUtil.getParentExpressionAnchorElement(selectedExpr);
    if (!Comparing.strEqual(IntroduceConstantHandler.REFACTORING_NAME, getRefactoringName()) && IntroduceVariableBase.checkAnchorBeforeThisOrSuper(project, editor, tempAnchorElement, getRefactoringName(), getHelpID()))
        return true;
    final Settings settings = showRefactoringDialog(project, editor, myParentClass, selectedExpr, tempType, occurrences, tempAnchorElement, anchorStatementIfAll);
    if (settings == null)
        return true;
    if (settings.getForcedType() != null) {
        tempType = settings.getForcedType();
    }
    final PsiType type = tempType;
    if (editor != null) {
        HighlightManager highlightManager = HighlightManager.getInstance(project);
        for (RangeHighlighter highlighter : highlighters) {
            highlightManager.removeSegmentHighlighter(editor, highlighter);
        }
    }
    final Runnable runnable = new ConvertToFieldRunnable(settings.getSelectedExpr(), settings, type, settings.getOccurrences(), occurrenceManager, anchorStatementIfAll, tempAnchorElement, editor, myParentClass);
    new WriteCommandAction(project, getRefactoringName()) {

        @Override
        protected void run(@NotNull Result result) throws Throwable {
            runnable.run();
        }
    }.execute();
    return false;
}