Examples with RangeHighlighter com.intellij.openapi.editor.markup.RangeHighlighter used on opensource projects

Example 11 with RangeHighlighter

use of com.intellij.openapi.editor.markup.RangeHighlighter in project intellij-community by JetBrains.

the class MavenDomTestCase method assertHighlighted.

protected void assertHighlighted(VirtualFile file, HighlightInfo... expected) throws IOException {
    Editor editor = getEditor(file);
    HighlightUsagesHandler.invoke(myProject, editor, getTestPsiFile(file));
    RangeHighlighter[] highlighters = editor.getMarkupModel().getAllHighlighters();
    List<HighlightInfo> actual = new ArrayList<>();
    for (RangeHighlighter each : highlighters) {
        if (!each.isValid())
            continue;
        int offset = each.getStartOffset();
        PsiElement element = getTestPsiFile(file).findElementAt(offset);
        element = PsiTreeUtil.getParentOfType(element, XmlTag.class);
        String text = editor.getDocument().getText().substring(offset, each.getEndOffset());
        actual.add(new HighlightInfo(element, text));
    }
    assertUnorderedElementsAreEqual(actual, expected);
}

Example 12 with RangeHighlighter

use of com.intellij.openapi.editor.markup.RangeHighlighter in project intellij-community by JetBrains.

the class XmlTagInplaceRenamer method addHighlights.

private static void addHighlights(List<TextRange> ranges, Editor editor, ArrayList<RangeHighlighter> highlighters) {
    EditorColorsManager colorsManager = EditorColorsManager.getInstance();
    final TextAttributes attributes = colorsManager.getGlobalScheme().getAttributes(EditorColors.WRITE_SEARCH_RESULT_ATTRIBUTES);
    final HighlightManager highlightManager = HighlightManager.getInstance(editor.getProject());
    for (final TextRange range : ranges) {
        highlightManager.addOccurrenceHighlight(editor, range.getStartOffset(), range.getEndOffset(), attributes, 0, highlighters, null);
    }
    for (RangeHighlighter highlighter : highlighters) {
        highlighter.setGreedyToLeft(true);
        highlighter.setGreedyToRight(true);
    }
}

Example 13 with RangeHighlighter

use of com.intellij.openapi.editor.markup.RangeHighlighter in project ideavim by JetBrains.

the class SearchGroup method searchAndReplace.

public boolean searchAndReplace(@NotNull Editor editor, @NotNull LineRange range, @NotNull String excmd, String exarg) {
    // Explicitly exit visual mode here, so that visual mode marks don't change when we move the cursor to a match.
    if (CommandState.getInstance(editor).getMode() == CommandState.Mode.VISUAL) {
        VimPlugin.getMotion().exitVisual(editor);
    }
    CharPointer cmd = new CharPointer(new StringBuffer(exarg));
    //sub_nsubs = 0;
    //sub_nlines = 0;
    int which_pat;
    if (excmd.equals("~")) {
        which_pat = RE_LAST;
    /* use last used regexp */
    } else {
        which_pat = RE_SUBST;
    /* use last substitute regexp */
    }
    CharPointer pat;
    CharPointer sub;
    char delimiter;
    /* new pattern and substitution */
    if (excmd.charAt(0) == 's' && !cmd.isNul() && !Character.isWhitespace(cmd.charAt()) && "0123456789cegriIp|\"".indexOf(cmd.charAt()) == -1) {
        /* don't accept alphanumeric for separator */
        if (CharacterClasses.isAlpha(cmd.charAt())) {
            VimPlugin.showMessage(MessageHelper.message(Msg.E146));
            return false;
        }
        /*
      * undocumented vi feature:
      *  "\/sub/" and "\?sub?" use last used search pattern (almost like
      *  //sub/r).  "\&sub&" use last substitute pattern (like //sub/).
      */
        if (cmd.charAt() == '\\') {
            cmd.inc();
            if ("/?&".indexOf(cmd.charAt()) == -1) {
                VimPlugin.showMessage(MessageHelper.message(Msg.e_backslash));
                return false;
            }
            if (cmd.charAt() != '&') {
                which_pat = RE_SEARCH;
            /* use last '/' pattern */
            }
            pat = new CharPointer("");
            /* empty search pattern */
            delimiter = cmd.charAt();
            /* remember delimiter character */
            cmd.inc();
        } else /* find the end of the regexp */
        {
            which_pat = RE_LAST;
            /* use last used regexp */
            delimiter = cmd.charAt();
            /* remember delimiter character */
            cmd.inc();
            pat = cmd.ref(0);
            /* remember start of search pat */
            cmd = RegExp.skip_regexp(cmd, delimiter, true);
            if (cmd.charAt() == delimiter) /* end delimiter found */
            {
                cmd.set('').inc();
            /* replace it with a NUL */
            }
        }
        /*
      * Small incompatibility: vi sees '\n' as end of the command, but in
      * Vim we want to use '\n' to find/substitute a NUL.
      */
        sub = cmd.ref(0);
        while (!cmd.isNul()) {
            if (cmd.charAt() == delimiter) /* end delimiter found */
            {
                cmd.set('').inc();
                /* replace it with a NUL */
                break;
            }
            if (cmd.charAt(0) == '\\' && cmd.charAt(1) != 0) /* skip escaped characters */
            {
                cmd.inc();
            }
            cmd.inc();
        }
    } else /* use previous pattern and substitution */
    {
        if (lastReplace == null) /* there is no previous command */
        {
            VimPlugin.showMessage(MessageHelper.message(Msg.e_nopresub));
            return false;
        }
        pat = null;
        /* search_regcomp() will use previous pattern */
        sub = new CharPointer(lastReplace);
    }
    /*
    * Find trailing options.  When '&' is used, keep old options.
    */
    if (cmd.charAt() == '&') {
        cmd.inc();
    } else {
        do_all = Options.getInstance().isSet("gdefault");
        do_ask = false;
        do_error = true;
        //do_print = false;
        do_ic = 0;
    }
    while (!cmd.isNul()) {
        /*
      * Note that 'g' and 'c' are always inverted, also when p_ed is off.
      * 'r' is never inverted.
      */
        if (cmd.charAt() == 'g') {
            do_all = !do_all;
        } else if (cmd.charAt() == 'c') {
            do_ask = !do_ask;
        } else if (cmd.charAt() == 'e') {
            do_error = !do_error;
        } else if (cmd.charAt() == 'r') /* use last used regexp */
        {
            which_pat = RE_LAST;
        } else if (cmd.charAt() == 'i') /* ignore case */
        {
            do_ic = 'i';
        } else if (cmd.charAt() == 'I') /* don't ignore case */
        {
            do_ic = 'I';
        } else if (cmd.charAt() != 'p') {
            break;
        }
        cmd.inc();
    }
    int line1 = range.getStartLine();
    int line2 = range.getEndLine();
    if (line1 < 0 || line2 < 0) {
        return false;
    }
    /*
    * check for a trailing count
    */
    cmd = CharHelper.skipwhite(cmd);
    if (CharacterClasses.isDigit(cmd.charAt())) {
        int i = CharHelper.getdigits(cmd);
        if (i <= 0 && do_error) {
            VimPlugin.showMessage(MessageHelper.message(Msg.e_zerocount));
            return false;
        }
        line1 = line2;
        line2 = EditorHelper.normalizeLine(editor, line1 + i - 1);
    }
    /*
    * check for trailing command or garbage
    */
    cmd = CharHelper.skipwhite(cmd);
    if (!cmd.isNul() && cmd.charAt() != '"') /* if not end-of-line or comment */
    {
        VimPlugin.showMessage(MessageHelper.message(Msg.e_trailing));
        return false;
    }
    String pattern = "";
    if (pat == null || pat.isNul()) {
        switch(which_pat) {
            case RE_LAST:
                pattern = lastPattern;
                break;
            case RE_SEARCH:
                pattern = lastSearch;
                break;
            case RE_SUBST:
                pattern = lastSubstitute;
                break;
        }
    } else {
        pattern = pat.toString();
    }
    lastSubstitute = pattern;
    lastSearch = pattern;
    if (pattern != null) {
        setLastPattern(editor, pattern);
    }
    //int start = editor.logicalPositionToOffset(new LogicalPosition(line1, 0));
    //int end = editor.logicalPositionToOffset(new LogicalPosition(line2, EditorHelper.getLineLength(editor, line2)));
    int start = editor.getDocument().getLineStartOffset(line1);
    int end = editor.getDocument().getLineEndOffset(line2);
    RegExp sp;
    RegExp.regmmatch_T regmatch = new RegExp.regmmatch_T();
    sp = new RegExp();
    regmatch.regprog = sp.vim_regcomp(pattern, 1);
    if (regmatch.regprog == null) {
        if (do_error) {
            VimPlugin.showMessage(MessageHelper.message(Msg.e_invcmd));
        }
        return false;
    }
    /* the 'i' or 'I' flag overrules 'ignorecase' and 'smartcase' */
    if (do_ic == 'i') {
        regmatch.rmm_ic = true;
    } else if (do_ic == 'I') {
        regmatch.rmm_ic = false;
    }
    /*
    * ~ in the substitute pattern is replaced with the old pattern.
    * We do it here once to avoid it to be replaced over and over again.
    * But don't do it when it starts with "\=", then it's an expression.
    */
    if (!(sub.charAt(0) == '\\' && sub.charAt(1) == '=') && lastReplace != null) {
        StringBuffer tmp = new StringBuffer(sub.toString());
        int pos = 0;
        while ((pos = tmp.indexOf("~", pos)) != -1) {
            if (pos == 0 || tmp.charAt(pos - 1) != '\\') {
                tmp.replace(pos, pos + 1, lastReplace);
                pos += lastReplace.length();
            }
            pos++;
        }
        sub = new CharPointer(tmp);
    }
    lastReplace = sub.toString();
    searchHighlight(false);
    if (logger.isDebugEnabled()) {
        logger.debug("search range=[" + start + "," + end + "]");
        logger.debug("pattern=" + pattern + ", replace=" + sub);
    }
    int lastMatch = -1;
    int lastLine = -1;
    int searchcol = 0;
    boolean firstMatch = true;
    boolean got_quit = false;
    int lcount = EditorHelper.getLineCount(editor);
    for (int lnum = line1; lnum <= line2 && !got_quit; ) {
        CharacterPosition newpos = null;
        int nmatch = sp.vim_regexec_multi(regmatch, editor, lcount, lnum, searchcol);
        if (nmatch > 0) {
            if (firstMatch) {
                VimPlugin.getMark().saveJumpLocation(editor);
                firstMatch = false;
            }
            String match = sp.vim_regsub_multi(regmatch, lnum, sub, 1, false);
            if (match == null) {
                return false;
            }
            //logger.debug("found match[" + spos + "," + epos + "] - replace " + match);
            int line = lnum + regmatch.startpos[0].lnum;
            CharacterPosition startpos = new CharacterPosition(lnum + regmatch.startpos[0].lnum, regmatch.startpos[0].col);
            CharacterPosition endpos = new CharacterPosition(lnum + regmatch.endpos[0].lnum, regmatch.endpos[0].col);
            int startoff = EditorHelper.characterPositionToOffset(editor, startpos);
            int endoff = EditorHelper.characterPositionToOffset(editor, endpos);
            int newend = startoff + match.length();
            if (do_all || line != lastLine) {
                boolean doReplace = true;
                if (do_ask) {
                    RangeHighlighter hl = highlightConfirm(editor, startoff, endoff);
                    MotionGroup.scrollPositionIntoView(editor, editor.offsetToVisualPosition(startoff), true);
                    MotionGroup.moveCaret(editor, startoff);
                    final ReplaceConfirmationChoice choice = confirmChoice(editor, match);
                    editor.getMarkupModel().removeHighlighter(hl);
                    switch(choice) {
                        case SUBSTITUTE_THIS:
                            doReplace = true;
                            break;
                        case SKIP:
                            doReplace = false;
                            break;
                        case SUBSTITUTE_ALL:
                            do_ask = false;
                            break;
                        case QUIT:
                            doReplace = false;
                            got_quit = true;
                            break;
                        case SUBSTITUTE_LAST:
                            do_all = false;
                            line2 = lnum;
                            doReplace = true;
                            break;
                    }
                }
                if (doReplace) {
                    editor.getDocument().replaceString(startoff, endoff, match);
                    lastMatch = startoff;
                    newpos = EditorHelper.offsetToCharacterPosition(editor, newend);
                    lnum += newpos.line - endpos.line;
                    line2 += newpos.line - endpos.line;
                }
            }
            lastLine = line;
            lnum += nmatch - 1;
            if (do_all && startoff != endoff) {
                if (newpos != null) {
                    lnum = newpos.line;
                    searchcol = newpos.column;
                } else {
                    searchcol = endpos.column;
                }
            } else {
                searchcol = 0;
                lnum++;
            }
        } else {
            lnum++;
            searchcol = 0;
        }
    }
    if (lastMatch != -1) {
        MotionGroup.moveCaret(editor, VimPlugin.getMotion().moveCaretToLineStartSkipLeading(editor, editor.offsetToLogicalPosition(lastMatch).line));
    } else {
        VimPlugin.showMessage(MessageHelper.message(Msg.e_patnotf2, pattern));
    }
    return true;
}

Example 14 with RangeHighlighter

use of com.intellij.openapi.editor.markup.RangeHighlighter in project ideavim by JetBrains.

the class SearchGroup method highlightSearchLines.

private static void highlightSearchLines(@NotNull Editor editor, @NotNull String pattern, int startLine, int endLine, boolean ignoreCase) {
    final TextAttributes color = editor.getColorsScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
    Collection<RangeHighlighter> highlighters = EditorData.getLastHighlights(editor);
    if (highlighters == null) {
        highlighters = new ArrayList<RangeHighlighter>();
        EditorData.setLastHighlights(editor, highlighters);
    }
    for (TextRange range : findAll(editor, pattern, startLine, endLine, ignoreCase)) {
        final RangeHighlighter highlighter = highlightMatch(editor, range.getStartOffset(), range.getEndOffset());
        highlighter.setErrorStripeMarkColor(color.getBackgroundColor());
        highlighter.setErrorStripeTooltip(pattern);
        highlighters.add(highlighter);
    }
}

Example 15 with RangeHighlighter

use of com.intellij.openapi.editor.markup.RangeHighlighter in project intellij-community by JetBrains.

the class EditorMarkupModelImpl method getNearestRangeHighlighter.

@Nullable
private RangeHighlighter getNearestRangeHighlighter(@NotNull final MouseEvent e) {
    List<RangeHighlighter> highlighters = new ArrayList<>();
    getNearestHighlighters(this, e.getY(), highlighters);
    getNearestHighlighters(myEditor.getFilteredDocumentMarkupModel(), e.getY(), highlighters);
    RangeHighlighter nearestMarker = null;
    int yPos = 0;
    for (RangeHighlighter highlighter : highlighters) {
        final int newYPos = offsetsToYPositions(highlighter.getStartOffset(), highlighter.getEndOffset()).getStartOffset();
        if (nearestMarker == null || Math.abs(yPos - e.getY()) > Math.abs(newYPos - e.getY())) {
            nearestMarker = highlighter;
            yPos = newYPos;
        }
    }
    return nearestMarker;
}