Examples with Spanned android.text.Spanned used on opensource projects

Example 81 with Spanned

use of android.text.Spanned in project android_frameworks_base by crdroidandroid.

the class TextView method paste.

/**
     * Paste clipboard content between min and max positions.
     */
private void paste(int min, int max, boolean withFormatting) {
    ClipboardManager clipboard = (ClipboardManager) getContext().getSystemService(Context.CLIPBOARD_SERVICE);
    ClipData clip = clipboard.getPrimaryClip();
    if (clip != null) {
        boolean didFirst = false;
        for (int i = 0; i < clip.getItemCount(); i++) {
            final CharSequence paste;
            if (withFormatting) {
                paste = clip.getItemAt(i).coerceToStyledText(getContext());
            } else {
                // Get an item as text and remove all spans by toString().
                final CharSequence text = clip.getItemAt(i).coerceToText(getContext());
                paste = (text instanceof Spanned) ? text.toString() : text;
            }
            if (paste != null) {
                if (!didFirst) {
                    Selection.setSelection((Spannable) mText, max);
                    ((Editable) mText).replace(min, max, paste);
                    didFirst = true;
                } else {
                    ((Editable) mText).insert(getSelectionEnd(), "\n");
                    ((Editable) mText).insert(getSelectionEnd(), paste);
                }
            }
        }
        sLastCutCopyOrTextChangedTime = 0;
    }
}

Example 82 with Spanned

use of android.text.Spanned in project android_frameworks_base by crdroidandroid.

the class Editor method extractTextInternal.

private boolean extractTextInternal(@Nullable ExtractedTextRequest request, int partialStartOffset, int partialEndOffset, int delta, @Nullable ExtractedText outText) {
    if (request == null || outText == null) {
        return false;
    }
    final CharSequence content = mTextView.getText();
    if (content == null) {
        return false;
    }
    if (partialStartOffset != EXTRACT_NOTHING) {
        final int N = content.length();
        if (partialStartOffset < 0) {
            outText.partialStartOffset = outText.partialEndOffset = -1;
            partialStartOffset = 0;
            partialEndOffset = N;
        } else {
            // Now use the delta to determine the actual amount of text
            // we need.
            partialEndOffset += delta;
            // Adjust offsets to ensure we contain full spans.
            if (content instanceof Spanned) {
                Spanned spanned = (Spanned) content;
                Object[] spans = spanned.getSpans(partialStartOffset, partialEndOffset, ParcelableSpan.class);
                int i = spans.length;
                while (i > 0) {
                    i--;
                    int j = spanned.getSpanStart(spans[i]);
                    if (j < partialStartOffset)
                        partialStartOffset = j;
                    j = spanned.getSpanEnd(spans[i]);
                    if (j > partialEndOffset)
                        partialEndOffset = j;
                }
            }
            outText.partialStartOffset = partialStartOffset;
            outText.partialEndOffset = partialEndOffset - delta;
            if (partialStartOffset > N) {
                partialStartOffset = N;
            } else if (partialStartOffset < 0) {
                partialStartOffset = 0;
            }
            if (partialEndOffset > N) {
                partialEndOffset = N;
            } else if (partialEndOffset < 0) {
                partialEndOffset = 0;
            }
        }
        if ((request.flags & InputConnection.GET_TEXT_WITH_STYLES) != 0) {
            outText.text = content.subSequence(partialStartOffset, partialEndOffset);
        } else {
            outText.text = TextUtils.substring(content, partialStartOffset, partialEndOffset);
        }
    } else {
        outText.partialStartOffset = 0;
        outText.partialEndOffset = 0;
        outText.text = "";
    }
    outText.flags = 0;
    if (MetaKeyKeyListener.getMetaState(content, MetaKeyKeyListener.META_SELECTING) != 0) {
        outText.flags |= ExtractedText.FLAG_SELECTING;
    }
    if (mTextView.isSingleLine()) {
        outText.flags |= ExtractedText.FLAG_SINGLE_LINE;
    }
    outText.startOffset = 0;
    outText.selectionStart = mTextView.getSelectionStart();
    outText.selectionEnd = mTextView.getSelectionEnd();
    return true;
}

Example 83 with Spanned

use of android.text.Spanned in project pictureapp by EyeSeeTea.

the class LayoutUtils method setActionBarAppAndUser.

public static void setActionBarAppAndUser(ActionBar actionBar) {
    Context context = PreferencesState.getInstance().getContext();
    actionBar.setLogo(R.drawable.pictureapp_logo);
    actionBar.setDisplayShowCustomEnabled(true);
    actionBar.setDisplayUseLogoEnabled(true);
    actionBar.setDisplayShowHomeEnabled(true);
    int color = ContextCompat.getColor(context, R.color.text_first_color);
    String colorString = String.format("%X", color).substring(2);
    Spanned spannedTitle = Html.fromHtml(String.format("<font color=\"#%s\" size=\"10\"><b>%s</b></font>", colorString, context.getString(R.string.malaria_case_based_reporting)));
    color = ContextCompat.getColor(context, R.color.text_second_color);
    colorString = String.format("%X", color).substring(2);
    User user = User.getLoggedUser();
    String userName;
    userName = (user == null) ? "" : user.getName();
    String volunteer = context.getString(R.string.volunteer_label);
    Spanned spannedSubTitle = Html.fromHtml(String.format("<font color=\"#%s\"><b>%s</b></font>", colorString, volunteer + " " + userName + ""));
    actionBar.setCustomView(R.layout.custom_action_bar);
    TextView title = (TextView) actionBar.getCustomView().findViewById(R.id.action_bar_multititle_title);
    title.setText(spannedTitle);
    Typeface tf = Typeface.createFromAsset(context.getAssets(), "fonts/" + context.getString(R.string.light_font));
    title.setTypeface(tf);
    TextView subtitle = (TextView) actionBar.getCustomView().findViewById(R.id.action_bar_multititle_subtitle);
    subtitle.setText(spannedSubTitle);
    tf = Typeface.createFromAsset(context.getAssets(), "fonts/" + context.getString(R.string.light_font));
    subtitle.setTypeface(tf);
}

Example 84 with Spanned

use of android.text.Spanned in project BBS-Android by bdpqchen.

the class JellyBeanSpanFixTextView method fixOnMeasure.

/**
     * If possible, fixes the Spanned text by adding spaces around spans when needed.
     */
private void fixOnMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    CharSequence text = getText();
    if (text instanceof Spanned) {
        SpannableStringBuilder builder = new SpannableStringBuilder(text);
        fixSpannedWithSpaces(builder, widthMeasureSpec, heightMeasureSpec);
    } else {
        if (HtmlTextView.DEBUG) {
            Log.d(HtmlTextView.TAG, "The text isn't a Spanned");
        }
        fallbackToString(widthMeasureSpec, heightMeasureSpec);
    }
}

Example 85 with Spanned

use of android.text.Spanned in project android_frameworks_base by crdroidandroid.

the class TextView method setText.

private void setText(CharSequence text, BufferType type, boolean notifyBefore, int oldlen) {
    if (text == null) {
        text = "";
    }
    // If suggestions are not enabled, remove the suggestion spans from the text
    if (!isSuggestionsEnabled()) {
        text = removeSuggestionSpans(text);
    }
    if (!mUserSetTextScaleX)
        mTextPaint.setTextScaleX(1.0f);
    if (text instanceof Spanned && ((Spanned) text).getSpanStart(TextUtils.TruncateAt.MARQUEE) >= 0) {
        if (ViewConfiguration.get(mContext).isFadingMarqueeEnabled()) {
            setHorizontalFadingEdgeEnabled(true);
            mMarqueeFadeMode = MARQUEE_FADE_NORMAL;
        } else {
            setHorizontalFadingEdgeEnabled(false);
            mMarqueeFadeMode = MARQUEE_FADE_SWITCH_SHOW_ELLIPSIS;
        }
        setEllipsize(TextUtils.TruncateAt.MARQUEE);
    }
    int n = mFilters.length;
    for (int i = 0; i < n; i++) {
        CharSequence out = mFilters[i].filter(text, 0, text.length(), EMPTY_SPANNED, 0, 0);
        if (out != null) {
            text = out;
        }
    }
    if (notifyBefore) {
        if (mText != null) {
            oldlen = mText.length();
            sendBeforeTextChanged(mText, 0, oldlen, text.length());
        } else {
            sendBeforeTextChanged("", 0, 0, text.length());
        }
    }
    boolean needEditableForNotification = false;
    if (mListeners != null && mListeners.length != 0) {
        needEditableForNotification = true;
    }
    if (type == BufferType.EDITABLE || getKeyListener() != null || needEditableForNotification) {
        createEditorIfNeeded();
        mEditor.forgetUndoRedo();
        Editable t = mEditableFactory.newEditable(text);
        text = t;
        setFilters(t, mFilters);
        InputMethodManager imm = InputMethodManager.peekInstance();
        if (imm != null)
            imm.restartInput(this);
    } else if (type == BufferType.SPANNABLE || mMovement != null) {
        text = mSpannableFactory.newSpannable(text);
    } else if (!(text instanceof CharWrapper)) {
        text = TextUtils.stringOrSpannedString(text);
    }
    if (mAutoLinkMask != 0) {
        Spannable s2;
        if (type == BufferType.EDITABLE || text instanceof Spannable) {
            s2 = (Spannable) text;
        } else {
            s2 = mSpannableFactory.newSpannable(text);
        }
        if (Linkify.addLinks(s2, mAutoLinkMask)) {
            text = s2;
            type = (type == BufferType.EDITABLE) ? BufferType.EDITABLE : BufferType.SPANNABLE;
            /*
                 * We must go ahead and set the text before changing the
                 * movement method, because setMovementMethod() may call
                 * setText() again to try to upgrade the buffer type.
                 */
            mText = text;
            // would prevent an arbitrary cursor displacement.
            if (mLinksClickable && !textCanBeSelected()) {
                setMovementMethod(LinkMovementMethod.getInstance());
            }
        }
    }
    mBufferType = type;
    mText = text;
    if (mTransformation == null) {
        mTransformed = text;
    } else {
        mTransformed = mTransformation.getTransformation(text, this);
    }
    final int textLength = text.length();
    if (text instanceof Spannable && !mAllowTransformationLengthChange) {
        Spannable sp = (Spannable) text;
        // Remove any ChangeWatchers that might have come from other TextViews.
        final ChangeWatcher[] watchers = sp.getSpans(0, sp.length(), ChangeWatcher.class);
        final int count = watchers.length;
        for (int i = 0; i < count; i++) {
            sp.removeSpan(watchers[i]);
        }
        if (mChangeWatcher == null)
            mChangeWatcher = new ChangeWatcher();
        sp.setSpan(mChangeWatcher, 0, textLength, Spanned.SPAN_INCLUSIVE_INCLUSIVE | (CHANGE_WATCHER_PRIORITY << Spanned.SPAN_PRIORITY_SHIFT));
        if (mEditor != null)
            mEditor.addSpanWatchers(sp);
        if (mTransformation != null) {
            sp.setSpan(mTransformation, 0, textLength, Spanned.SPAN_INCLUSIVE_INCLUSIVE);
        }
        if (mMovement != null) {
            mMovement.initialize(this, (Spannable) text);
            /*
                 * Initializing the movement method will have set the
                 * selection, so reset mSelectionMoved to keep that from
                 * interfering with the normal on-focus selection-setting.
                 */
            if (mEditor != null)
                mEditor.mSelectionMoved = false;
        }
    }
    if (mLayout != null) {
        checkForRelayout();
    }
    sendOnTextChanged(text, 0, oldlen, textLength);
    onTextChanged(text, 0, oldlen, textLength);
    notifyViewAccessibilityStateChangedIfNeeded(AccessibilityEvent.CONTENT_CHANGE_TYPE_TEXT);
    if (needEditableForNotification) {
        sendAfterTextChanged((Editable) text);
    }
    // SelectionModifierCursorController depends on textCanBeSelected, which depends on text
    if (mEditor != null)
        mEditor.prepareCursorControllers();
}