コード例 #1
0
ファイル: TextLine.java プロジェクト: JokeLook/framework
  /**
   * Returns the ascent of the text at start. This is used for scaling emoji.
   *
   * @param pos the line-relative position
   * @return the ascent of the text at start
   */
  float ascent(int pos) {
    if (mSpanned == null) {
      return mPaint.ascent();
    }

    pos += mStart;
    MetricAffectingSpan[] spans = mSpanned.getSpans(pos, pos + 1, MetricAffectingSpan.class);
    if (spans.length == 0) {
      return mPaint.ascent();
    }

    TextPaint wp = mWorkPaint;
    wp.set(mPaint);
    for (MetricAffectingSpan span : spans) {
      span.updateMeasureState(wp);
    }
    return wp.ascent();
  }
コード例 #2
0
 float addStyleRun(TextPaint paint, MetricAffectingSpan[] spans, int len, FontMetricsInt fm) {
   int i;
   float wid;
   TextPaint workPaint = this.mWorkPaint;
   workPaint.set(paint);
   workPaint.baselineShift = 0;
   ReplacementSpan replacement = null;
   for (MetricAffectingSpan span : spans) {
     if (span instanceof ReplacementSpan) {
       replacement = (ReplacementSpan) span;
     } else {
       span.updateMeasureState(workPaint);
     }
   }
   if (replacement == null) {
     wid = addStyleRun(workPaint, len, fm);
   } else {
     wid =
         (float)
             replacement.getSize(
                 workPaint,
                 this.mText,
                 this.mTextStart + this.mPos,
                 (this.mTextStart + this.mPos) + len,
                 fm);
     float[] w = this.mWidths;
     w[this.mPos] = wid;
     int e = this.mPos + len;
     for (i = this.mPos + 1; i < e; i++) {
       w[i] = 0.0f;
     }
     this.mPos += len;
   }
   if (fm != null) {
     if (workPaint.baselineShift < 0) {
       fm.ascent += workPaint.baselineShift;
       fm.top += workPaint.baselineShift;
     } else {
       fm.descent += workPaint.baselineShift;
       fm.bottom += workPaint.baselineShift;
     }
   }
   return wid;
 }
コード例 #3
0
  /**
   * Returns the advance widths for a uniform left-to-right run of text with no style changes in the
   * middle of the run. If any style is replacement text, the first character will isCancelled the
   * width of the replacement and the remaining characters will isCancelled a width of 0.
   *
   * @param paint the paint, will not be modified
   * @param workPaint a paint to modify; on return will reflect the original paint plus the effect
   *     of all spans on the run
   * @param text the text
   * @param start the start of the run
   * @param end the limit of the run
   * @param widths array to receive the advance widths of the characters. Must be at least a large
   *     as (end - start).
   * @param fmi FontMetrics information; can be null
   * @return the actual number of widths returned
   */
  public static int getTextWidths(
      TextPaint paint,
      TextPaint workPaint,
      Spanned text,
      int start,
      int end,
      float[] widths,
      Paint.FontMetricsInt fmi) {
    MetricAffectingSpan[] spans = text.getSpans(start, end, MetricAffectingSpan.class);

    ReplacementSpan replacement = null;
    workPaint.set(paint);

    for (MetricAffectingSpan span : spans) {
      if (span instanceof ReplacementSpan) {
        replacement = (ReplacementSpan) span;
      } else {
        span.updateMeasureState(workPaint);
      }
    }

    if (replacement == null) {
      workPaint.getFontMetricsInt(fmi);
      workPaint.getTextWidths(text, start, end, widths);
    } else {
      int wid = replacement.getSize(workPaint, text, start, end, fmi);

      if (end > start) {
        widths[0] = wid;
        for (int i = start + 1; i < end; i++) {
          widths[i - start] = 0;
        }
      }
    }
    return end - start;
  }
コード例 #4
0
ファイル: TextLine.java プロジェクト: JokeLook/framework
  /**
   * Returns the next valid offset within this directional run, skipping conjuncts and zero-width
   * characters. This should not be called to walk off the end of the line, since the returned
   * values might not be valid on neighboring lines. If the returned offset is less than zero or
   * greater than the line length, the offset should be recomputed on the preceding or following
   * line, respectively.
   *
   * @param runIndex the run index
   * @param runStart the start of the run
   * @param runLimit the limit of the run
   * @param runIsRtl true if the run is right-to-left
   * @param offset the offset
   * @param after true if the new offset should logically follow the provided offset
   * @return the new offset
   */
  private int getOffsetBeforeAfter(
      int runIndex, int runStart, int runLimit, boolean runIsRtl, int offset, boolean after) {

    if (runIndex < 0 || offset == (after ? mLen : 0)) {
      // Walking off end of line.  Since we don't know
      // what cursor positions are available on other lines, we can't
      // return accurate values.  These are a guess.
      if (after) {
        return TextUtils.getOffsetAfter(mText, offset + mStart) - mStart;
      }
      return TextUtils.getOffsetBefore(mText, offset + mStart) - mStart;
    }

    TextPaint wp = mWorkPaint;
    wp.set(mPaint);

    int spanStart = runStart;
    int spanLimit;
    if (mSpanned == null) {
      spanLimit = runLimit;
    } else {
      int target = after ? offset + 1 : offset;
      int limit = mStart + runLimit;
      while (true) {
        spanLimit =
            mSpanned.nextSpanTransition(mStart + spanStart, limit, MetricAffectingSpan.class)
                - mStart;
        if (spanLimit >= target) {
          break;
        }
        spanStart = spanLimit;
      }

      MetricAffectingSpan[] spans =
          mSpanned.getSpans(mStart + spanStart, mStart + spanLimit, MetricAffectingSpan.class);
      spans = TextUtils.removeEmptySpans(spans, mSpanned, MetricAffectingSpan.class);

      if (spans.length > 0) {
        ReplacementSpan replacement = null;
        for (int j = 0; j < spans.length; j++) {
          MetricAffectingSpan span = spans[j];
          if (span instanceof ReplacementSpan) {
            replacement = (ReplacementSpan) span;
          } else {
            span.updateMeasureState(wp);
          }
        }

        if (replacement != null) {
          // If we have a replacement span, we're moving either to
          // the start or end of this span.
          return after ? spanLimit : spanStart;
        }
      }
    }

    int flags = runIsRtl ? Paint.DIRECTION_RTL : Paint.DIRECTION_LTR;
    int cursorOpt = after ? Paint.CURSOR_AFTER : Paint.CURSOR_BEFORE;
    if (mCharsValid) {
      return wp.getTextRunCursor(
          mChars, spanStart, spanLimit - spanStart, flags, offset, cursorOpt);
    } else {
      return wp.getTextRunCursor(
              mText, mStart + spanStart, mStart + spanLimit, flags, mStart + offset, cursorOpt)
          - mStart;
    }
  }