Example usage for android.text Editable append

List of usage examples for android.text Editable append

Introduction

In this page you can find the example usage for android.text Editable append.

Prototype

public Editable append(CharSequence text, int start, int end);

Source Link

Document

Convenience for replace(length(), length(), text, start, end)

Usage

From source file:com.android.ex.chips.RecipientEditTextView.java

/**
 * Handles pasting a {@link ClipData} to this {@link RecipientEditTextView}.
 */// w  ww. j av a  2s. co m
private void handlePasteClip(final ClipData clip) {
    removeTextChangedListener(mTextWatcher);
    if (clip != null && clip.getDescription().hasMimeType(ClipDescription.MIMETYPE_TEXT_PLAIN))
        for (int i = 0; i < clip.getItemCount(); i++) {
            final CharSequence paste = clip.getItemAt(i).getText();
            if (paste != null) {
                final int start = getSelectionStart();
                final int end = getSelectionEnd();
                final Editable editable = getText();
                if (start >= 0 && end >= 0 && start != end)
                    editable.append(paste, start, end);
                else
                    editable.insert(end, paste);
                handlePasteAndReplace();
            }
        }
    mHandler.post(mAddTextWatcher);
}

From source file:org.mozilla.focus.widget.InlineAutocompleteEditText.java

/**
 * Add autocomplete text based on the result URI.
 *
 * @param result Result URI to be turned into autocomplete text
 *///  w w w.  j a v  a2 s  . co m
public final void onAutocomplete(final String result) {
    // If mDiscardAutoCompleteResult is true, we temporarily disabled
    // autocomplete (due to backspacing, etc.) and we should bail early.
    if (mDiscardAutoCompleteResult) {
        return;
    }

    if (!isEnabled() || result == null) {
        mAutoCompleteResult = "";
        return;
    }

    final Editable text = getText();
    final int textLength = text.length();
    final int resultLength = result.length();
    final int autoCompleteStart = text.getSpanStart(AUTOCOMPLETE_SPAN);
    mAutoCompleteResult = result;

    if (autoCompleteStart > -1) {
        // Autocomplete text already exists; we should replace existing autocomplete text.

        // If the result and the current text don't have the same prefixes,
        // the result is stale and we should wait for the another result to come in.
        if (!TextUtils.regionMatches(result, 0, text, 0, autoCompleteStart)) {
            return;
        }

        beginSettingAutocomplete();

        // Replace the existing autocomplete text with new one.
        // replace() preserves the autocomplete spans that we set before.
        text.replace(autoCompleteStart, textLength, result, autoCompleteStart, resultLength);

        // Reshow the cursor if there is no longer any autocomplete text.
        if (autoCompleteStart == resultLength) {
            setCursorVisible(true);
        }

        endSettingAutocomplete();

    } else {
        // No autocomplete text yet; we should add autocomplete text

        // If the result prefix doesn't match the current text,
        // the result is stale and we should wait for the another result to come in.
        if (resultLength <= textLength || !TextUtils.regionMatches(result, 0, text, 0, textLength)) {
            return;
        }

        final Object[] spans = text.getSpans(textLength, textLength, Object.class);
        final int[] spanStarts = new int[spans.length];
        final int[] spanEnds = new int[spans.length];
        final int[] spanFlags = new int[spans.length];

        // Save selection/composing span bounds so we can restore them later.
        for (int i = 0; i < spans.length; i++) {
            final Object span = spans[i];
            final int spanFlag = text.getSpanFlags(span);

            // We don't care about spans that are not selection or composing spans.
            // For those spans, spanFlag[i] will be 0 and we don't restore them.
            if ((spanFlag & Spanned.SPAN_COMPOSING) == 0 && (span != Selection.SELECTION_START)
                    && (span != Selection.SELECTION_END)) {
                continue;
            }

            spanStarts[i] = text.getSpanStart(span);
            spanEnds[i] = text.getSpanEnd(span);
            spanFlags[i] = spanFlag;
        }

        beginSettingAutocomplete();

        // First add trailing text.
        text.append(result, textLength, resultLength);

        // Restore selection/composing spans.
        for (int i = 0; i < spans.length; i++) {
            final int spanFlag = spanFlags[i];
            if (spanFlag == 0) {
                // Skip if the span was ignored before.
                continue;
            }
            text.setSpan(spans[i], spanStarts[i], spanEnds[i], spanFlag);
        }

        // Mark added text as autocomplete text.
        for (final Object span : mAutoCompleteSpans) {
            text.setSpan(span, textLength, resultLength, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        }

        // Hide the cursor.
        setCursorVisible(false);

        // Make sure the autocomplete text is visible. If the autocomplete text is too
        // long, it would appear the cursor will be scrolled out of view. However, this
        // is not the case in practice, because EditText still makes sure the cursor is
        // still in view.
        bringPointIntoView(resultLength);

        endSettingAutocomplete();
    }

    announceForAccessibility(text.toString());
}