Java 类org.eclipse.jface.text.IFindReplaceTargetExtension3 实例源码

/**
 * Find the next occurrence of empty line(s)
 * Will match all valid lines except single ^$
 *   
 * @param editor
 * @param forward true if moving forward
 * @return -1 if not found, else offset of match in widget coords
 */
protected int findNext(ITextEditor editor, boolean forward) {

    IFindReplaceTarget frt = getTarget(editor);
    Point selection = frt.getSelection();
    // don't move past eob
    int offset = Math.min(MarkUtils.getCharCount(editor), Math.max(0,MarkUtils.getCaretOffset(editor) + (forward ? 1 : -2)));
    int result = ((IFindReplaceTargetExtension3)frt).findAndSelect(offset, PARAGRAPH_START, forward, false, false, true);       
    if (result != -1) {
        if ((forward && offset > result) || (!forward && offset < result)) {
            // reset if we've wrapped around in the search
            MarkUtils.setWidgetSelection(editor, selection.x, selection.x + selection.y);
            result = -1;
        }
    }
    return result;
}

/**
 * Case-based replacement - after the initial find has already happened
 * 
 * @param replacer - the replacement string (may be regexp)
 * @param index - offset of find
 * @param all - all if true, else initial
 * @return - the replacement region
 * 
 * @throws BadLocationException
 */
private IRegion caseReplace(String replacer, int index, boolean all) throws BadLocationException {
    IRegion result = null;
    IDocumentUndoManager undoer = DocumentUndoManagerRegistry.getDocumentUndoManager(getDocument());
    try {
        if (!isReplaceAll() && undoer != null) {
            undoer.beginCompoundChange();
        }
        IFindReplaceTarget target = getTarget();
        // first replace with (possible regexp) string
        ((IFindReplaceTargetExtension3)target).replaceSelection(replacer, isRegexp());
        // adjust case of actual replacement string
        replacer = target.getSelectionText();
        String caseReplacer = replacer;
        if (all) {
            caseReplacer = caseReplacer.toUpperCase();
        } else {
            caseReplacer = caseReplacer.trim();
            caseReplacer = Character.toUpperCase(caseReplacer.charAt(0)) + 
            caseReplacer.substring(1,caseReplacer.length()).toString();
            // now update the replacement string with the re-cased part
            caseReplacer = replacer.replaceFirst(replacer.trim(), caseReplacer);
        }
        int ind = target.findAndSelect(index, replacer, true, false, false);
        if (ind > -1) {
            target.replaceSelection(caseReplacer);
        }
    }  finally {
        if (!isReplaceAll() && undoer != null) {
            undoer.endCompoundChange();
        }
    }
    return result;
}

/**
 * Find the next occurrence of empty line consisting of ^$
 * Since findNext will find multiple sequential ^$'s, we only need find one
 * 
 * @param editor
 * @param forward
 * @return offset of match in widget coords
 */
protected int findNextEmpty(ITextEditor editor, boolean forward) {
    IFindReplaceTarget frt = getTarget(editor);
    Point selection = frt.getSelection();
    int count = MarkUtils.getCharCount(editor);
    int coffset = MarkUtils.getCaretOffset(editor); 
    // don't move past EOB
    int offset = Math.min(count,coffset + (forward ? 1 : -1)); //(forward ? selection.x + selection.y+1 : selection.x-2);   
    int next = 0;
    int prev = -1;
    do {
        next = ((IFindReplaceTargetExtension3)frt).findAndSelect(offset, REGEX_BOL_HACK, forward, false, false, true);
        if (next == -1 || prev == next){
            // we've run out of buffer
            offset = (forward ? count : 0); 
            MarkUtils.setWidgetSelection(editor, offset, offset);
            return offset;
        } else if (forward && offset > next) {
            // protect against overrun
            MarkUtils.setWidgetSelection(editor, count, count);
            return count;
        } else if (!forward && offset < next) {
            // protect against overrun
            MarkUtils.setWidgetSelection(editor, 0, 0);
            return 0;
        } else {
            selection = frt.getSelection(); 
            // Eclipse internals (frda) return different regions depending on whether the file has a 
            // single or double line delimiter e.g. \r\n or \n.  In the former it returns a 0 length
            // region, and in the latter a length of 1
            if (selection.y == 0 || (!forward && selection.x == 0)) {
                // found it, or reached the top
                return selection.x;
            } if (selection.y == 1) {
                // check for single line delimiter 
                char c = frt.getSelectionText().charAt(0);
                if (c == '\n' || c == '\r'){
                    return selection.x;
                }
            }
            // the widget count could change if a folded region expands automatically
            count = MarkUtils.getCharCount(editor);
            // don't move past EOB              
            offset = Math.min(count,(forward ? selection.x + selection.y+1 : selection.x-1));
            prev = next;
        }
    } while (next != -1);
    return next;
}

/**
 * Perform one replacement
 * 
 * @return the replacement index
 */
private boolean replaceIt() {
    boolean result = false;
    boolean forward = true;
    if (!checkPaused()) { 
        findCount++;
        try {
            result = true;
            int index = getSearchOffset();
            IFindReplaceTarget target = getTarget();
            int fpos = findTarget(target,getSearchStr(), index, forward);
            if (fpos > -1) {
                boolean initial = false;
                boolean all = false;
                String replacer = replaceStr;
                if (!isCaseSensitive() && replacer.length() > 0) {
                    // Preserve case using the emacs definition
                    // - Preserving case means that if the string matched is all caps, or capitalized,
                    //   then its replacement is upper cased or capitalized.)
                    String replacee = target.getSelectionText().trim();
                    if (replacee != null && replacee.length() > 0) {
                        initial = Character.isUpperCase(replacee.charAt(0));
                        all = initial;
                        if (initial) {
                            for (int i = 1; i < replacee.length(); i++) {
                                if (!Character.isUpperCase(replacee.charAt(i))) {
                                    all = false;
                                    break;
                                }
                            }
                        }
                    }
                }
                int adjust = 0;
                if (all || initial) {
                    caseReplace(replacer,index,all);
                } else {
                    if (isRegexLD()) {
                        adjust = replacer.length(); // prevents repetitious find of same EOL
                        // now we need the offset in model coords
                        ITextSelection sel = (ITextSelection)getEditor().getSelectionProvider().getSelection();
                        // use document 'insert' instead of broken target replace
                        getDocument().replace(sel.getOffset(),0,replacer);
                        // search uses cursor position - s/r is always forward
                        MarkUtils.setCursorOffset(getEditor(), sel.getOffset()+adjust);
                    } else {
                        ((IFindReplaceTargetExtension3)target).replaceSelection(replacer, isRegexp());
                    }
                }
                Point p = target.getSelection();
                int rIndex = p.x + p.y + adjust;
                setSearchOffset(rIndex);                    
            }
        } catch (Exception e) {
            setResultString(e.getLocalizedMessage(), true);
            finish();
            beep();
        }
    }
    return result;
}

/**
 * Replaces the selection with <code>replaceString</code>. If <code>regExReplace</code> is <code>true</code>,
 * <code>replaceString</code> is a regex replace pattern which will get expanded if the underlying target supports
 * it. Returns the region of the inserted text; note that the returned selection covers the expanded pattern in case
 * of regex replace.
 * 
 * @param replaceString
 *            the replace string (or a regex pattern)
 * @param regExReplace
 *            <code>true</code> if <code>replaceString</code> is a pattern
 * @return the selection after replacing, i.e. the inserted text
 * @since 3.0
 */
/* default */Point replaceSelection(String replaceString, boolean regExReplace)
{
    if (fTarget instanceof IFindReplaceTargetExtension3)
        ((IFindReplaceTargetExtension3) fTarget).replaceSelection(replaceString, regExReplace);
    else
        fTarget.replaceSelection(replaceString);

    return fTarget.getSelection();
}

/**
 * Searches for a string starting at the given offset and using the specified search directives. If a string has
 * been found it is selected and its start offset is returned.
 * 
 * @param offset
 *            the offset at which searching starts
 * @param findString
 *            the string which should be found
 * @param forwardSearch
 *            the direction of the search
 * @param caseSensitive
 *            <code>true</code> performs a case sensitive search, <code>false</code> an insensitive search
 * @param wholeWord
 *            if <code>true</code> only occurrences are reported in which the findString stands as a word by itself
 * @param regExSearch
 *            if <code>true</code> findString represents a regular expression
 * @return the position of the specified string, or -1 if the string has not been found
 * @since 3.0
 */
/* default */int findAndSelect(int offset, String findString, boolean forwardSearch, boolean caseSensitive,
        boolean wholeWord, boolean regExSearch)
{
    if (fTarget instanceof IFindReplaceTargetExtension3)
        return ((IFindReplaceTargetExtension3) fTarget).findAndSelect(offset, findString, forwardSearch,
                caseSensitive, wholeWord, regExSearch);
    return fTarget.findAndSelect(offset, findString, forwardSearch, caseSensitive, wholeWord);
}