private FixingResult addSpacesAroundSpansUntilFixed(
      SpannableStringBuilder builder, int widthMeasureSpec, int heightMeasureSpec) {

    Object[] spans = builder.getSpans(0, builder.length(), Object.class);
    List<Object> spansWithSpacesBefore = new ArrayList<Object>(spans.length);
    List<Object> spansWithSpacesAfter = new ArrayList<Object>(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 notFixed) {
      }
    }
    if (HtmlTextView.DEBUG) {
      Log.d(HtmlTextView.TAG, "Could not fix the Spanned by adding spaces around spans");
    }
    return FixingResult.notFixed();
  }
  private void notifyCommitComposition() {
    // Gecko already committed its composition, and
    // we should remove the composition on our side as well.
    boolean wasComposing = false;
    final Object[] spans = mText.getSpans(0, mText.length(), Object.class);

    for (Object span : spans) {
      if ((mText.getSpanFlags(span) & Spanned.SPAN_COMPOSING) != 0) {
        mText.removeSpan(span);
        wasComposing = true;
      }
    }

    if (!wasComposing) {
      return;
    }

    // Generate a text change notification if we actually cleared the composition.
    final CharSequence text = TextUtils.stringOrSpannedString(mText);
    geckoPostToIc(
        new Runnable() {
          @Override
          public void run() {
            mListener.onTextChange(text, 0, text.length(), text.length());
          }
        });
  }
 /**
  * get real translate charsequence
  *
  * @param content
  * @return
  */
 public static CharSequence getTranslateTxt(CharSequence content) {
   StringBuilder sBuilder = new StringBuilder();
   if (content instanceof SpannableStringBuilder) {
     SpannableStringBuilder spanSb = (SpannableStringBuilder) content;
     if (spanSb.toString().contains(EMHolderEntity.FINAL_HOLDER)) {
       for (int i = 0; i < spanSb.length(); i++) {
         ReplacementSpan[] spans = spanSb.getSpans(i, i + 1, ReplacementSpan.class);
         if (spans.length > 0) {
           if (spans[0] instanceof EMImageSpan) {
             EMImageSpan imgSpan = (EMImageSpan) spans[0];
             sBuilder.append(imgSpan.mTransferTxt);
           } else if (spans[0] instanceof DefEmojSpan) {
             DefEmojSpan defSpan = (DefEmojSpan) spans[0];
             sBuilder.append(defSpan.mTransferTxt);
           }
         } else {
           sBuilder.append(spanSb.subSequence(i, i + 1));
         }
       }
     } else {
       sBuilder.append(content);
     }
   }
   return sBuilder;
 }
 private void clearCachedMark(SpannableStringBuilder ssb) {
   Cached[] cs = ssb.getSpans(0, ssb.length(), Cached.class);
   if (cs != null && cs.length > 0) {
     for (Cached c : cs) {
       ssb.removeSpan(c);
     }
   }
 }
Beispiel #5
0
  private void showNote(boolean xml) {

    if (xml) {
      content.setText(note.getXmlContent());
      title.setText((CharSequence) note.getTitle());
      this.setTitle(this.getTitle() + " - XML");
      return;
    }

    LinkInternalSpan[] links =
        noteContent.getSpans(0, noteContent.length(), LinkInternalSpan.class);
    MatchFilter noteLinkMatchFilter = LinkInternalSpan.getNoteLinkMatchFilter(noteContent, links);

    // show the note (spannable makes the TextView able to output styled text)
    content.setText(noteContent, TextView.BufferType.SPANNABLE);

    // add links to stuff that is understood by Android except phone numbers because it's too
    // aggressive
    // TODO this is SLOWWWW!!!!

    int linkFlags = 0;

    if (Preferences.getBoolean(Preferences.Key.LINK_EMAILS)) linkFlags |= Linkify.EMAIL_ADDRESSES;
    if (Preferences.getBoolean(Preferences.Key.LINK_URLS)) linkFlags |= Linkify.WEB_URLS;
    if (Preferences.getBoolean(Preferences.Key.LINK_ADDRESSES)) linkFlags |= Linkify.MAP_ADDRESSES;

    Linkify.addLinks(content, linkFlags);

    // Custom phone number linkifier (fixes lp:512204)
    if (Preferences.getBoolean(Preferences.Key.LINK_PHONES))
      Linkify.addLinks(
          content,
          LinkifyPhone.PHONE_PATTERN,
          "tel:",
          LinkifyPhone.sPhoneNumberMatchFilter,
          Linkify.sPhoneNumberTransformFilter);

    // This will create a link every time a note title is found in the text.
    // The pattern contains a very dumb (title1)|(title2) escaped correctly
    // Then we transform the url from the note name to the note id to avoid characters that mess up
    // with the URI (ex: ?)
    if (Preferences.getBoolean(Preferences.Key.LINK_TITLES)) {
      Pattern pattern = NoteManager.buildNoteLinkifyPattern(this, note.getTitle());

      if (pattern != null) {
        Linkify.addLinks(
            content,
            pattern,
            Tomdroid.CONTENT_URI + "/",
            noteLinkMatchFilter,
            noteTitleTransformFilter);

        // content.setMovementMethod(LinkMovementMethod.getInstance());
      }
    }
    title.setText((CharSequence) note.getTitle());
  }
  /**
   * Returns the current FontFamilySpan in use on the given subsection of the builder.
   *
   * <p>If no FontFamily has been set yet, spanner.getDefaultFont() is returned.
   *
   * @param builder the text to check
   * @param start start of the section
   * @param end end of the section
   * @return a FontFamily object
   */
  private FontFamilySpan getFontFamilySpan(SpannableStringBuilder builder, int start, int end) {

    FontFamilySpan[] spans = builder.getSpans(start, end, FontFamilySpan.class);

    if (spans != null && spans.length > 0) {
      return spans[spans.length - 1];
    }

    return null;
  }
 private void notifyCancelComposition() {
   // Composition should have been cancelled on our side
   // through text update notifications; verify that here.
   if (DEBUG) {
     final Object[] spans = mText.getSpans(0, mText.length(), Object.class);
     for (Object span : spans) {
       if ((mText.getSpanFlags(span) & Spanned.SPAN_COMPOSING) != 0) {
         throw new IllegalStateException("composition not cancelled");
       }
     }
   }
 }
  /**
   * Set the necessary spans for each spoiler.
   *
   * <p>The algorithm works in the same way as <code>setCodeFont</code>.
   *
   * @param sequence
   * @return
   */
  private CharSequence setSpoilerStyle(SpannableStringBuilder sequence) {
    int start = 0;
    int end = 0;
    for (int i = 0; i < sequence.length(); i++) {
      if (sequence.charAt(i) == '[' && i < sequence.length() - 3) {
        if (sequence.charAt(i + 1) == '['
            && sequence.charAt(i + 2) == 's'
            && sequence.charAt(i + 3) == '[') {
          start = i;
        }
      } else if (sequence.charAt(i) == ']' && i < sequence.length() - 3) {
        if (sequence.charAt(i + 1) == 's'
            && sequence.charAt(i + 2) == ']'
            && sequence.charAt(i + 3) == ']') {
          end = i;
        }
      }

      if (end > start) {
        sequence.delete(end, end + 4);
        sequence.delete(start, start + 4);
        BackgroundColorSpan backgroundColorSpan = new BackgroundColorSpan(Color.BLACK);
        ForegroundColorSpan foregroundColorSpan = new ForegroundColorSpan(Color.BLACK);

        URLSpan urlSpan = sequence.getSpans(start, start, URLSpan.class)[0];
        sequence.setSpan(
            urlSpan, sequence.getSpanStart(urlSpan), start - 1, Spanned.SPAN_INCLUSIVE_INCLUSIVE);

        // spoiler text has a space at the front
        sequence.setSpan(
            backgroundColorSpan, start + 1, end - 4, Spannable.SPAN_INCLUSIVE_INCLUSIVE);
        sequence.setSpan(foregroundColorSpan, start, end - 4, Spannable.SPAN_INCLUSIVE_INCLUSIVE);

        storedSpoilerSpans.add(foregroundColorSpan);
        storedSpoilerSpans.add(backgroundColorSpan);
        // Shift 1 to account for remove of beginning "<"
        storedSpoilerStarts.add(start - 1);
        storedSpoilerStarts.add(start - 1);
        storedSpoilerEnds.add(end - 5);
        storedSpoilerEnds.add(end - 5);

        sequence.delete(start - 2, start - 1); // remove the trailing <
        start = 0;
        end = 0;
        i = i - 5; // move back to compensate for removal of [[s[
      }
    }

    return sequence;
  }
 /**
  * @desc
  *     <pre>表情解析,转成unicode字符</pre>
  *
  * @author Weiliang Hu
  * @date 2013-12-17
  * @param cs
  * @param mContext
  * @return
  */
 public static String convertToMsg(CharSequence cs, Context mContext) {
   SpannableStringBuilder ssb = new SpannableStringBuilder(cs);
   ImageSpan[] spans = ssb.getSpans(0, cs.length(), ImageSpan.class);
   for (int i = 0; i < spans.length; i++) {
     ImageSpan span = spans[i];
     String c = span.getSource();
     int a = ssb.getSpanStart(span);
     int b = ssb.getSpanEnd(span);
     if (c.contains("[")) {
       ssb.replace(a, b, convertUnicode(c));
     }
   }
   ssb.clearSpans();
   return ssb.toString();
 }
 private void handleClick(SpannableStringBuilder ssb, RichTextConfig config, boolean cached) {
   if (cached) {
     LongClickableURLSpan[] lcus = ssb.getSpans(0, ssb.length(), LongClickableURLSpan.class);
     if (lcus != null && lcus.length > 0) {
       for (LongClickableURLSpan lcu : lcus) {
         resetLinkSpan(ssb, config, lcu);
       }
     }
   } else {
     if (config.clickable >= 0) {
       // 处理超链接点击事件
       URLSpan[] urlSpans = ssb.getSpans(0, ssb.length(), URLSpan.class);
       for (int i = 0, size = urlSpans == null ? 0 : urlSpans.length; i < size; i++) {
         resetLinkSpan(ssb, config, urlSpans[i]);
       }
     } else {
       // 移除URLSpan
       URLSpan[] urlSpans = ssb.getSpans(0, ssb.length(), URLSpan.class);
       for (int i = 0, size = urlSpans == null ? 0 : urlSpans.length; i < size; i++) {
         ssb.removeSpan(urlSpans[i]);
       }
     }
   }
 }
  public static void setTextWithIcon(Context context, TextView textView, String text) {
    Spanned html = Html.fromHtml(text);
    SpannableStringBuilder builder = new SpannableStringBuilder(html);

    ImageSpan[] images = builder.getSpans(0, builder.length(), ImageSpan.class);
    if (images != null && images.length > 0) {
      ImageSpan imagePlaceholder = images[0];
      int start = builder.getSpanStart(imagePlaceholder);
      int end = builder.getSpanEnd(imagePlaceholder);
      int flags = builder.getSpanFlags(imagePlaceholder);

      ImageSpan imageSpan = new ImageSpan(context, R.drawable.lock_icon, ImageSpan.ALIGN_BASELINE);
      builder.setSpan(imageSpan, start, end, flags);
      builder.removeSpan(imagePlaceholder);
    }

    textView.setText(builder);
  }
  private void icUpdateGecko(boolean force) {

    // Skip if receiving a repeated request, or
    // if suppressing compositions during text selection.
    if ((!force && mIcUpdateSeqno == mLastIcUpdateSeqno) || mSuppressCompositions) {
      if (DEBUG) {
        Log.d(LOGTAG, "icUpdateGecko() skipped");
      }
      return;
    }
    mLastIcUpdateSeqno = mIcUpdateSeqno;
    mActionQueue.syncWithGecko();

    if (DEBUG) {
      Log.d(LOGTAG, "icUpdateGecko()");
    }

    final int selStart = mText.getSpanStart(Selection.SELECTION_START);
    final int selEnd = mText.getSpanEnd(Selection.SELECTION_END);
    int composingStart = mText.length();
    int composingEnd = 0;
    Object[] spans = mText.getSpans(0, composingStart, Object.class);

    for (Object span : spans) {
      if ((mText.getSpanFlags(span) & Spanned.SPAN_COMPOSING) != 0) {
        composingStart = Math.min(composingStart, mText.getSpanStart(span));
        composingEnd = Math.max(composingEnd, mText.getSpanEnd(span));
      }
    }
    if (DEBUG) {
      Log.d(LOGTAG, " range = " + composingStart + "-" + composingEnd);
      Log.d(LOGTAG, " selection = " + selStart + "-" + selEnd);
    }
    if (composingStart >= composingEnd) {
      if (selStart >= 0 && selEnd >= 0) {
        onImeSetSelection(selStart, selEnd);
      } else {
        onImeRemoveComposition();
      }
      return;
    }

    if (selEnd >= composingStart && selEnd <= composingEnd) {
      onImeAddCompositionRange(
          selEnd - composingStart,
          selEnd - composingStart,
          IME_RANGE_CARETPOSITION,
          0,
          0,
          false,
          0,
          0,
          0);
    }
    int rangeStart = composingStart;
    TextPaint tp = new TextPaint();
    TextPaint emptyTp = new TextPaint();
    // set initial foreground color to 0, because we check for tp.getColor() == 0
    // below to decide whether to pass a foreground color to Gecko
    emptyTp.setColor(0);
    do {
      int rangeType, rangeStyles = 0, rangeLineStyle = IME_RANGE_LINE_NONE;
      boolean rangeBoldLine = false;
      int rangeForeColor = 0, rangeBackColor = 0, rangeLineColor = 0;
      int rangeEnd = mText.nextSpanTransition(rangeStart, composingEnd, Object.class);

      if (selStart > rangeStart && selStart < rangeEnd) {
        rangeEnd = selStart;
      } else if (selEnd > rangeStart && selEnd < rangeEnd) {
        rangeEnd = selEnd;
      }
      CharacterStyle[] styleSpans = mText.getSpans(rangeStart, rangeEnd, CharacterStyle.class);

      if (DEBUG) {
        Log.d(LOGTAG, " found " + styleSpans.length + " spans @ " + rangeStart + "-" + rangeEnd);
      }

      if (styleSpans.length == 0) {
        rangeType =
            (selStart == rangeStart && selEnd == rangeEnd)
                ? IME_RANGE_SELECTEDRAWTEXT
                : IME_RANGE_RAWINPUT;
      } else {
        rangeType =
            (selStart == rangeStart && selEnd == rangeEnd)
                ? IME_RANGE_SELECTEDCONVERTEDTEXT
                : IME_RANGE_CONVERTEDTEXT;
        tp.set(emptyTp);
        for (CharacterStyle span : styleSpans) {
          span.updateDrawState(tp);
        }
        int tpUnderlineColor = 0;
        float tpUnderlineThickness = 0.0f;

        // These TextPaint fields only exist on Android ICS+ and are not in the SDK.
        if (Versions.feature14Plus) {
          tpUnderlineColor = (Integer) getField(tp, "underlineColor", 0);
          tpUnderlineThickness = (Float) getField(tp, "underlineThickness", 0.0f);
        }
        if (tpUnderlineColor != 0) {
          rangeStyles |= IME_RANGE_UNDERLINE | IME_RANGE_LINECOLOR;
          rangeLineColor = tpUnderlineColor;
          // Approximately translate underline thickness to what Gecko understands
          if (tpUnderlineThickness <= 0.5f) {
            rangeLineStyle = IME_RANGE_LINE_DOTTED;
          } else {
            rangeLineStyle = IME_RANGE_LINE_SOLID;
            if (tpUnderlineThickness >= 2.0f) {
              rangeBoldLine = true;
            }
          }
        } else if (tp.isUnderlineText()) {
          rangeStyles |= IME_RANGE_UNDERLINE;
          rangeLineStyle = IME_RANGE_LINE_SOLID;
        }
        if (tp.getColor() != 0) {
          rangeStyles |= IME_RANGE_FORECOLOR;
          rangeForeColor = tp.getColor();
        }
        if (tp.bgColor != 0) {
          rangeStyles |= IME_RANGE_BACKCOLOR;
          rangeBackColor = tp.bgColor;
        }
      }
      onImeAddCompositionRange(
          rangeStart - composingStart,
          rangeEnd - composingStart,
          rangeType,
          rangeStyles,
          rangeLineStyle,
          rangeBoldLine,
          rangeForeColor,
          rangeBackColor,
          rangeLineColor);
      rangeStart = rangeEnd;

      if (DEBUG) {
        Log.d(
            LOGTAG,
            " added "
                + rangeType
                + " : "
                + Integer.toHexString(rangeStyles)
                + " : "
                + Integer.toHexString(rangeForeColor)
                + " : "
                + Integer.toHexString(rangeBackColor));
      }
    } while (rangeStart < composingEnd);

    onImeUpdateComposition(composingStart, composingEnd);
  }
  private int handleImage(
      SpannableStringBuilder ssb,
      ImageGetterWrapper imageGetterWrapper,
      RichTextConfig config,
      boolean cached) {
    if (cached) {
      ClickableImageSpan[] cis = ssb.getSpans(0, ssb.length(), ClickableImageSpan.class);
      if (cis != null && cis.length > 0) {
        for (ClickableImageSpan ci : cis) {
          int start = ssb.getSpanStart(ci);
          int end = ssb.getSpanEnd(ci);
          ssb.removeSpan(ci);
          OnImageClickListener onImageClickListener = null;
          OnImageLongClickListener onImageLongClickListener = null;
          if (config.clickable > 0) {
            onImageClickListener = config.onImageClickListener;
            onImageLongClickListener = config.onImageLongClickListener;
          }
          Drawable drawable = imageGetterWrapper.getDrawable(ci.getSource());
          if (drawable == null) {
            drawable = new ColorDrawable(Color.TRANSPARENT);
          }
          ClickableImageSpan nci =
              new ClickableImageSpan(drawable, ci, onImageClickListener, onImageLongClickListener);
          ssb.setSpan(nci, start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        }
        return cis.length;
      }
    } else if (!config.noImage) {
      ImageSpan[] iss = ssb.getSpans(0, ssb.length(), ImageSpan.class);
      if (iss != null && iss.length > 0) {
        ArrayList<String> imageUrls = new ArrayList<>(iss.length);
        for (int i = 0; i < iss.length; i++) {
          ImageSpan imageSpan = iss[i];
          String imageUrl = imageSpan.getSource();
          imageUrls.add(imageUrl);

          int start = ssb.getSpanStart(imageSpan);
          int end = ssb.getSpanEnd(imageSpan);
          ClickableSpan[] clickableSpans = ssb.getSpans(start, end, ClickableSpan.class);
          if (clickableSpans != null && clickableSpans.length != 0) {
            for (ClickableSpan cs : clickableSpans) {
              ssb.removeSpan(cs);
            }
          }
          OnImageClickListener onImageClickListener = null;
          OnImageLongClickListener onImageLongClickListener = null;
          if (config.clickable > 0) {
            onImageClickListener = config.onImageClickListener;
            onImageLongClickListener = config.onImageLongClickListener;
          }
          Drawable drawable = imageGetterWrapper.getDrawable(imageUrl);
          if (drawable == null) {
            drawable = new ColorDrawable(Color.TRANSPARENT);
          }
          ClickableImageSpan cacheImageSpan =
              new ClickableImageSpan(
                  drawable, imageUrls, i, onImageClickListener, onImageLongClickListener);
          ssb.removeSpan(imageSpan);
          ssb.setSpan(cacheImageSpan, start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        }
        return iss.length;
      }
    }
    return 0;
  }
 private boolean isCached(SpannableStringBuilder ssb) {
   Cached[] cs = ssb.getSpans(0, ssb.length(), Cached.class);
   return cs != null && cs.length > 0;
 }