Best Java code snippets using android.text.SpannableStringBuilder.getSpanEnd (Showing top 20 results out of 315)

public static void replaceUnderlineSpans(SpannableStringBuilder builder, Resources resources) {
 UnderlineSpan[] underlineSpans = builder.getSpans(0, builder.length(), UnderlineSpan.class);
 for (UnderlineSpan span : underlineSpans) {
  int start = builder.getSpanStart(span);
  int end = builder.getSpanEnd(span);
  builder.removeSpan(span);
  builder.setSpan(new SquigglySpan(resources), start, end, 0);
 }
}

for (int i = 0; i < obj.length; i++) {
  int start = mSpannableStringBuilder.getSpanStart(obj[i]);
  int end = mSpannableStringBuilder.getSpanEnd(obj[i]);

 final Context context = ... // whereever your context is
CharSequence sequence = Html.fromSource(context.getString(R.string.clickable_string));
SpannableStringBuilder strBuilder = new SpannableStringBuilder(sequence);
UnderlineSpan[] underlines = strBuilder.getSpans(UnderlineSpan.class);
for(UnderlineSpan span : underlines) {
  int start = strBuilder.getSpanStart(span);
  int end = strBuilder.getSpanEnd(span);
  int flags = strBuilder.getSpanFlags(span);
  ClickableSpan myActivityLauncher = new ClickableSpan() {
   public void onClick(View view) {
    context.startActivity(getIntentForActivityToStart());
   }
  };

  strBuilder.setSpan(myActivityLauncher, start, end, flags);
}

TextView textView = ...
textView.setText(strBuilder);
textView.setMovementMethod(LinkMovementMethod.getInstance());

private FixingResult addSpacesAroundSpansUntilFixed(SpannableStringBuilder builder,
                          int widthMeasureSpec, int heightMeasureSpec) {
  Object[] spans = builder.getSpans(0, builder.length(), Object.class);
  List<Object> spansWithSpacesBefore = new ArrayList<>(spans.length);
  List<Object> spansWithSpacesAfter = new ArrayList<>(spans.length);
  for (Object span : spans) {
    int spanStart = builder.getSpanStart(span);
    if (isNotSpace(builder, spanStart - 1)) {
      builder.insert(spanStart, " ");
      spansWithSpacesBefore.add(span);
    }
    int spanEnd = builder.getSpanEnd(span);
    if (isNotSpace(builder, spanEnd)) {
      builder.insert(spanEnd, " ");
      spansWithSpacesAfter.add(span);
    }
    try {
      setTextAndMeasure(builder, widthMeasureSpec, heightMeasureSpec);
      return FixingResult.fixed(spansWithSpacesBefore, spansWithSpacesAfter);
    } catch (IndexOutOfBoundsException ignored) {
    }
  }
  if (HtmlTextView.DEBUG) {
    Log.d(HtmlTextView.TAG, "Could not fix the Spanned by adding spaces around spans");
  }
  return FixingResult.notFixed();
}

@SuppressLint("WrongCall")
private void removeUnneededSpaces(int widthMeasureSpec, int heightMeasureSpec,
                 SpannableStringBuilder builder, FixingResult result) {
  for (Object span : result.spansWithSpacesAfter) {
    int spanEnd = builder.getSpanEnd(span);
    builder.delete(spanEnd, spanEnd + 1);
    try {
      setTextAndMeasure(builder, widthMeasureSpec, heightMeasureSpec);
    } catch (IndexOutOfBoundsException ignored) {
      builder.insert(spanEnd, " ");
    }
  }
  boolean needReset = true;
  for (Object span : result.spansWithSpacesBefore) {
    int spanStart = builder.getSpanStart(span);
    builder.delete(spanStart - 1, spanStart);
    try {
      setTextAndMeasure(builder, widthMeasureSpec, heightMeasureSpec);
      needReset = false;
    } catch (IndexOutOfBoundsException ignored) {
      needReset = true;
      int newSpanStart = spanStart - 1;
      builder.insert(newSpanStart, " ");
    }
  }
  if (needReset) {
    setText(builder);
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  }
}

 TextView decription = (TextView)convertView.findViewById(R.id.library_rss_expan_chaild_des_textView);
String dec=d.get_description()+"<a href='"+d.get_link()+"'><u>more</u></a>";
CharSequence sequence = Html.fromHtml(dec);
SpannableStringBuilder strBuilder = new SpannableStringBuilder(sequence);
UnderlineSpan[] underlines = strBuilder.getSpans(0, 10, UnderlineSpan.class);   
for(UnderlineSpan span : underlines) {
  int start = strBuilder.getSpanStart(span);
  int end = strBuilder.getSpanEnd(span);
  int flags = strBuilder.getSpanFlags(span);
  ClickableSpan myActivityLauncher = new ClickableSpan() {
    public void onClick(View view) {
      Log.e(TAG, "on click");
      Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(d.get_link()));
      mContext.startActivity(intent);         
    }
  };
  strBuilder.setSpan(myActivityLauncher, start, end, flags);
}
decription.setText(strBuilder);
decription.setLinksClickable(true);
decription.setMovementMethod(LinkMovementMethod.getInstance());

@Override
public int getSpanEnd(Object span) {
  return mSpannableString.getSpanEnd(span);
}

/**
 * Return the correct end for the DynamicLayout$ChangeWatcher span.
 */
@Override
public int getSpanEnd(Object tag) {
 if (isWatcher(tag)) {
  final WatcherWrapper watcher = getWatcherFor(tag);
  if (watcher != null) {
   tag = watcher;
  }
 }
 return super.getSpanEnd(tag);
}

private void makeLinkClickable(SpannableStringBuilder strBuilder, final URLSpan span, Runnable runnable) {
  int start = strBuilder.getSpanStart(span);
  int end = strBuilder.getSpanEnd(span);
  int flags = strBuilder.getSpanFlags(span);
  ClickableSpan clickable = new ClickableSpan() {
    public void onClick(View view) {
      runnable.run();
    }
  };
  strBuilder.setSpan(clickable, start, end, flags);
  strBuilder.removeSpan(span);
}

  void swapIn(SpannableStringBuilder builder) {
    int start = builder.getSpanStart(this);
    int end = builder.getSpanEnd(this);
    builder.removeSpan(this);
    if (start >= 0 && end > start && end <= builder.length()) {
      builder.setSpan(mSpan, start, end, Spanned.SPAN_EXCLUSIVE_INCLUSIVE);
    }
  }
}

 SpannableStringBuilder builder = ...
URLSpan[] spans = builder .getSpans(0, builder .length(), URLSpan.class);
for (URLSpan span : spans) {
  int start = builder .getSpanStart(span);
  int end = builder .getSpanEnd(span);
  s.removeSpan(span);
  span = new CustomURLSpan(span.getURL().replace("http://", "scheme://"));
  s.setSpan(span, start, end, 0);
}
textView.setText(builder);

private SpannableStringBuilder removeImageChar(SpannableStringBuilder text) {
  SpannableStringBuilder buf = new SpannableStringBuilder(text);
  DynamicDrawableSpan[] styles =
      buf.getSpans(0, buf.length(), DynamicDrawableSpan.class);
  for (DynamicDrawableSpan style : styles) {
    if (style instanceof HorizontalLineSpan
        || style instanceof RescalableImageSpan) {
      int start = buf.getSpanStart(style);
      int end = buf.getSpanEnd(style);
      buf.replace(start, end, "");
    }
  }
  return buf;
}

final TextView textView = (TextView) findViewById(R.id.text);
 final CharSequence text = textView.getText();
 final SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder(text);
 final URLSpan[] spans = spannableStringBuilder.getSpans(0, text.length(), URLSpan.class);
 final URLSpan span = spans[0];
 final int start = spannableStringBuilder.getSpanStart(span);
 final int end = spannableStringBuilder.getSpanEnd(span);
 final int flags = spannableStringBuilder.getSpanFlags(span);
 final ClickableSpan clickableSpan = new ClickableSpan() {
   public void onClick(View view) {
     Log.d(TAG, "Clicked: " + span.getURL());
   }
 };
 spannableStringBuilder.setSpan(clickableSpan, start, end, flags);
 spannableStringBuilder.removeSpan(span);
 textView.setText(spannableStringBuilder);
 textView.setLinksClickable(true);
 textView.setMovementMethod(LinkMovementMethod.getInstance());

 public static Spanned removeImageSpanObjects(String inStr) {
  SpannableStringBuilder spannedStr = (SpannableStringBuilder) Html
      .fromHtml(inStr.trim());
  Object[] spannedObjects = spannedStr.getSpans(0, spannedStr.length(),
      Object.class);
  for (int i = 0; i < spannedObjects.length; i++) {
    if (spannedObjects[i] instanceof ImageSpan) {
      ImageSpan imageSpan = (ImageSpan) spannedObjects[i];
      spannedStr.replace(spannedStr.getSpanStart(imageSpan),
          spannedStr.getSpanEnd(imageSpan), "");
    }
  }
  return spannedStr;
}

 protected void makeLinkClickable(SpannableStringBuilder strBuilder, final URLSpan span)
{
  int start = strBuilder.getSpanStart(span);
  int end = strBuilder.getSpanEnd(span);
  int flags = strBuilder.getSpanFlags(span);
  ClickableSpan clickable = new ClickableSpan() {
    public void onClick(View view) {
      Log.d("LipAdapter", span.getURL());
    }
  };
  strBuilder.setSpan(clickable, start, end, flags);
  strBuilder.removeSpan(span);
}

private static String getTextWithPasswords(CharSequence seq) {
  SpannableStringBuilder lstr = new SpannableStringBuilder(seq);
  for (PasswordSpan span : lstr.getSpans(0, lstr.length(), PasswordSpan.class)) {
    lstr.replace(lstr.getSpanStart(span), lstr.getSpanEnd(span), span.mPassword);
    lstr.removeSpan(span);
  }
  return lstr.toString();
}

 protected void makeLinkClickable(SpannableStringBuilder strBuilder, final URLSpan span)
{
  int start = strBuilder.getSpanStart(span);
  int end = strBuilder.getSpanEnd(span);
  int flags = strBuilder.getSpanFlags(span);


  ClickableSpan clickable = new ClickableSpan() {
    @Override
    public void onClick(View widget) {
      Log.d("LipAdapter", span.getURL());
    }

    @Override
    public void updateDrawState(TextPaint ds) {
      super.updateDrawState(ds);
    }
  };

  strBuilder.setSpan(clickable, start, end, flags);
  strBuilder.removeSpan(span);
}

// textView.setText("Lucy is very nice. Here is her link. https://www.google.com");
   final String source = "Lucy is very nice. Here is her link. <a href=\"scheme://some.link\">Click</a>";
   final Spanned html = Html.fromHtml(source);
   final SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder(html);
   final URLSpan[] spans = spannableStringBuilder.getSpans(0, html.length(), URLSpan.class);
   final URLSpan span = spans[0];
   final int start = spannableStringBuilder.getSpanStart(span);
   final int end = spannableStringBuilder.getSpanEnd(span);
   final int flags = spannableStringBuilder.getSpanFlags(span);
   final ClickableSpan clickableSpan = new ClickableSpan() {
     public void onClick(View view) {
       Log.d(TAG, "Clicked: " + span.getURL());
     }
   };
   spannableStringBuilder.setSpan(clickableSpan, start, end, flags);
   spannableStringBuilder.removeSpan(span);
   textView.setText(spannableStringBuilder);
   textView.setLinksClickable(true);
   textView.setMovementMethod(LinkMovementMethod.getInstance());

private void handleFont(int start, HtmlNode.HtmlAttr attr) {
  if (attr == null) return;
  StyleSpan span;
  Object[] spans = spannedBuilder.getSpans(start, position, StyleSpan.class);
  if (spans != null && spans.length > 0) {
    int pos1 = spannedBuilder.getSpanStart(spans[0]);
    int pos2 = spannedBuilder.getSpanEnd(spans[0]);
    if (pos1 == start && pos2 == position) {//一摸一样位置的同样font
      span = (StyleSpan) spans[0];
      span.updateStyle(attr);
      return;
    }
  }
  setSpan(start, new StyleSpan(attr));
}

@Override
public void write(Parcel dest, int flags) {
  dest.writeString(mSpannableString.toString());
  RichTextSpan[] spans =  getSpans();
  int[] spanStarts = new int[spans.length];
  int[] spanEnds = new int[spans.length];
  int[] spanFlags = new int[spans.length];
  for(int index = 0; index < spans.length; index ++){
    RichTextSpan currentSpan = spans[index];
    spanStarts[index] = mSpannableString.getSpanStart(currentSpan);
    spanEnds[index] = mSpannableString.getSpanEnd(currentSpan);
    spanFlags[index] = mSpannableString.getSpanFlags(currentSpan);
  }
  dest.writeIntArray(spanStarts);
  dest.writeIntArray(spanEnds);
  dest.writeIntArray(spanFlags);
  dest.writeTypedArray(spans, flags);
}