Home | History | Annotate | Download | only in text
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.text;
     18 
     19 import android.graphics.Bitmap;
     20 import android.graphics.Canvas;
     21 import android.graphics.Paint;
     22 import android.graphics.Paint.FontMetricsInt;
     23 import android.graphics.RectF;
     24 import android.text.Layout.Directions;
     25 import android.text.Layout.TabStops;
     26 import android.text.style.CharacterStyle;
     27 import android.text.style.MetricAffectingSpan;
     28 import android.text.style.ReplacementSpan;
     29 import android.util.Log;
     30 
     31 import com.android.internal.util.ArrayUtils;
     32 
     33 /**
     34  * Represents a line of styled text, for measuring in visual order and
     35  * for rendering.
     36  *
     37  * <p>Get a new instance using obtain(), and when finished with it, return it
     38  * to the pool using recycle().
     39  *
     40  * <p>Call set to prepare the instance for use, then either draw, measure,
     41  * metrics, or caretToLeftRightOf.
     42  *
     43  * @hide
     44  */
     45 class TextLine {
     46     private static final boolean DEBUG = false;
     47 
     48     private TextPaint mPaint;
     49     private CharSequence mText;
     50     private int mStart;
     51     private int mLen;
     52     private int mDir;
     53     private Directions mDirections;
     54     private boolean mHasTabs;
     55     private TabStops mTabs;
     56     private char[] mChars;
     57     private boolean mCharsValid;
     58     private Spanned mSpanned;
     59     private final TextPaint mWorkPaint = new TextPaint();
     60     private final SpanSet<MetricAffectingSpan> mMetricAffectingSpanSpanSet =
     61             new SpanSet<MetricAffectingSpan>(MetricAffectingSpan.class);
     62     private final SpanSet<CharacterStyle> mCharacterStyleSpanSet =
     63             new SpanSet<CharacterStyle>(CharacterStyle.class);
     64     private final SpanSet<ReplacementSpan> mReplacementSpanSpanSet =
     65             new SpanSet<ReplacementSpan>(ReplacementSpan.class);
     66 
     67     private static final TextLine[] sCached = new TextLine[3];
     68 
     69     /**
     70      * Returns a new TextLine from the shared pool.
     71      *
     72      * @return an uninitialized TextLine
     73      */
     74     static TextLine obtain() {
     75         TextLine tl;
     76         synchronized (sCached) {
     77             for (int i = sCached.length; --i >= 0;) {
     78                 if (sCached[i] != null) {
     79                     tl = sCached[i];
     80                     sCached[i] = null;
     81                     return tl;
     82                 }
     83             }
     84         }
     85         tl = new TextLine();
     86         if (DEBUG) {
     87             Log.v("TLINE", "new: " + tl);
     88         }
     89         return tl;
     90     }
     91 
     92     /**
     93      * Puts a TextLine back into the shared pool. Do not use this TextLine once
     94      * it has been returned.
     95      * @param tl the textLine
     96      * @return null, as a convenience from clearing references to the provided
     97      * TextLine
     98      */
     99     static TextLine recycle(TextLine tl) {
    100         tl.mText = null;
    101         tl.mPaint = null;
    102         tl.mDirections = null;
    103 
    104         tl.mMetricAffectingSpanSpanSet.recycle();
    105         tl.mCharacterStyleSpanSet.recycle();
    106         tl.mReplacementSpanSpanSet.recycle();
    107 
    108         synchronized(sCached) {
    109             for (int i = 0; i < sCached.length; ++i) {
    110                 if (sCached[i] == null) {
    111                     sCached[i] = tl;
    112                     break;
    113                 }
    114             }
    115         }
    116         return null;
    117     }
    118 
    119     /**
    120      * Initializes a TextLine and prepares it for use.
    121      *
    122      * @param paint the base paint for the line
    123      * @param text the text, can be Styled
    124      * @param start the start of the line relative to the text
    125      * @param limit the limit of the line relative to the text
    126      * @param dir the paragraph direction of this line
    127      * @param directions the directions information of this line
    128      * @param hasTabs true if the line might contain tabs or emoji
    129      * @param tabStops the tabStops. Can be null.
    130      */
    131     void set(TextPaint paint, CharSequence text, int start, int limit, int dir,
    132             Directions directions, boolean hasTabs, TabStops tabStops) {
    133         mPaint = paint;
    134         mText = text;
    135         mStart = start;
    136         mLen = limit - start;
    137         mDir = dir;
    138         mDirections = directions;
    139         if (mDirections == null) {
    140             throw new IllegalArgumentException("Directions cannot be null");
    141         }
    142         mHasTabs = hasTabs;
    143         mSpanned = null;
    144 
    145         boolean hasReplacement = false;
    146         if (text instanceof Spanned) {
    147             mSpanned = (Spanned) text;
    148             mReplacementSpanSpanSet.init(mSpanned, start, limit);
    149             hasReplacement = mReplacementSpanSpanSet.numberOfSpans > 0;
    150         }
    151 
    152         mCharsValid = hasReplacement || hasTabs || directions != Layout.DIRS_ALL_LEFT_TO_RIGHT;
    153 
    154         if (mCharsValid) {
    155             if (mChars == null || mChars.length < mLen) {
    156                 mChars = new char[ArrayUtils.idealCharArraySize(mLen)];
    157             }
    158             TextUtils.getChars(text, start, limit, mChars, 0);
    159             if (hasReplacement) {
    160                 // Handle these all at once so we don't have to do it as we go.
    161                 // Replace the first character of each replacement run with the
    162                 // object-replacement character and the remainder with zero width
    163                 // non-break space aka BOM.  Cursor movement code skips these
    164                 // zero-width characters.
    165                 char[] chars = mChars;
    166                 for (int i = start, inext; i < limit; i = inext) {
    167                     inext = mReplacementSpanSpanSet.getNextTransition(i, limit);
    168                     if (mReplacementSpanSpanSet.hasSpansIntersecting(i, inext)) {
    169                         // transition into a span
    170                         chars[i - start] = '\ufffc';
    171                         for (int j = i - start + 1, e = inext - start; j < e; ++j) {
    172                             chars[j] = '\ufeff'; // used as ZWNBS, marks positions to skip
    173                         }
    174                     }
    175                 }
    176             }
    177         }
    178         mTabs = tabStops;
    179     }
    180 
    181     /**
    182      * Renders the TextLine.
    183      *
    184      * @param c the canvas to render on
    185      * @param x the leading margin position
    186      * @param top the top of the line
    187      * @param y the baseline
    188      * @param bottom the bottom of the line
    189      */
    190     void draw(Canvas c, float x, int top, int y, int bottom) {
    191         if (!mHasTabs) {
    192             if (mDirections == Layout.DIRS_ALL_LEFT_TO_RIGHT) {
    193                 drawRun(c, 0, mLen, false, x, top, y, bottom, false);
    194                 return;
    195             }
    196             if (mDirections == Layout.DIRS_ALL_RIGHT_TO_LEFT) {
    197                 drawRun(c, 0, mLen, true, x, top, y, bottom, false);
    198                 return;
    199             }
    200         }
    201 
    202         float h = 0;
    203         int[] runs = mDirections.mDirections;
    204         RectF emojiRect = null;
    205 
    206         int lastRunIndex = runs.length - 2;
    207         for (int i = 0; i < runs.length; i += 2) {
    208             int runStart = runs[i];
    209             int runLimit = runStart + (runs[i+1] & Layout.RUN_LENGTH_MASK);
    210             if (runLimit > mLen) {
    211                 runLimit = mLen;
    212             }
    213             boolean runIsRtl = (runs[i+1] & Layout.RUN_RTL_FLAG) != 0;
    214 
    215             int segstart = runStart;
    216             for (int j = mHasTabs ? runStart : runLimit; j <= runLimit; j++) {
    217                 int codept = 0;
    218                 Bitmap bm = null;
    219 
    220                 if (mHasTabs && j < runLimit) {
    221                     codept = mChars[j];
    222                     if (codept >= 0xd800 && codept < 0xdc00 && j + 1 < runLimit) {
    223                         codept = Character.codePointAt(mChars, j);
    224                         if (codept >= Layout.MIN_EMOJI && codept <= Layout.MAX_EMOJI) {
    225                             bm = Layout.EMOJI_FACTORY.getBitmapFromAndroidPua(codept);
    226                         } else if (codept > 0xffff) {
    227                             ++j;
    228                             continue;
    229                         }
    230                     }
    231                 }
    232 
    233                 if (j == runLimit || codept == '\t' || bm != null) {
    234                     h += drawRun(c, segstart, j, runIsRtl, x+h, top, y, bottom,
    235                             i != lastRunIndex || j != mLen);
    236 
    237                     if (codept == '\t') {
    238                         h = mDir * nextTab(h * mDir);
    239                     } else if (bm != null) {
    240                         float bmAscent = ascent(j);
    241                         float bitmapHeight = bm.getHeight();
    242                         float scale = -bmAscent / bitmapHeight;
    243                         float width = bm.getWidth() * scale;
    244 
    245                         if (emojiRect == null) {
    246                             emojiRect = new RectF();
    247                         }
    248                         emojiRect.set(x + h, y + bmAscent,
    249                                 x + h + width, y);
    250                         c.drawBitmap(bm, null, emojiRect, mPaint);
    251                         h += width;
    252                         j++;
    253                     }
    254                     segstart = j + 1;
    255                 }
    256             }
    257         }
    258     }
    259 
    260     /**
    261      * Returns metrics information for the entire line.
    262      *
    263      * @param fmi receives font metrics information, can be null
    264      * @return the signed width of the line
    265      */
    266     float metrics(FontMetricsInt fmi) {
    267         return measure(mLen, false, fmi);
    268     }
    269 
    270     /**
    271      * Returns information about a position on the line.
    272      *
    273      * @param offset the line-relative character offset, between 0 and the
    274      * line length, inclusive
    275      * @param trailing true to measure the trailing edge of the character
    276      * before offset, false to measure the leading edge of the character
    277      * at offset.
    278      * @param fmi receives metrics information about the requested
    279      * character, can be null.
    280      * @return the signed offset from the leading margin to the requested
    281      * character edge.
    282      */
    283     float measure(int offset, boolean trailing, FontMetricsInt fmi) {
    284         int target = trailing ? offset - 1 : offset;
    285         if (target < 0) {
    286             return 0;
    287         }
    288 
    289         float h = 0;
    290 
    291         if (!mHasTabs) {
    292             if (mDirections == Layout.DIRS_ALL_LEFT_TO_RIGHT) {
    293                 return measureRun(0, offset, mLen, false, fmi);
    294             }
    295             if (mDirections == Layout.DIRS_ALL_RIGHT_TO_LEFT) {
    296                 return measureRun(0, offset, mLen, true, fmi);
    297             }
    298         }
    299 
    300         char[] chars = mChars;
    301         int[] runs = mDirections.mDirections;
    302         for (int i = 0; i < runs.length; i += 2) {
    303             int runStart = runs[i];
    304             int runLimit = runStart + (runs[i+1] & Layout.RUN_LENGTH_MASK);
    305             if (runLimit > mLen) {
    306                 runLimit = mLen;
    307             }
    308             boolean runIsRtl = (runs[i+1] & Layout.RUN_RTL_FLAG) != 0;
    309 
    310             int segstart = runStart;
    311             for (int j = mHasTabs ? runStart : runLimit; j <= runLimit; j++) {
    312                 int codept = 0;
    313                 Bitmap bm = null;
    314 
    315                 if (mHasTabs && j < runLimit) {
    316                     codept = chars[j];
    317                     if (codept >= 0xd800 && codept < 0xdc00 && j + 1 < runLimit) {
    318                         codept = Character.codePointAt(chars, j);
    319                         if (codept >= Layout.MIN_EMOJI && codept <= Layout.MAX_EMOJI) {
    320                             bm = Layout.EMOJI_FACTORY.getBitmapFromAndroidPua(codept);
    321                         } else if (codept > 0xffff) {
    322                             ++j;
    323                             continue;
    324                         }
    325                     }
    326                 }
    327 
    328                 if (j == runLimit || codept == '\t' || bm != null) {
    329                     boolean inSegment = target >= segstart && target < j;
    330 
    331                     boolean advance = (mDir == Layout.DIR_RIGHT_TO_LEFT) == runIsRtl;
    332                     if (inSegment && advance) {
    333                         return h += measureRun(segstart, offset, j, runIsRtl, fmi);
    334                     }
    335 
    336                     float w = measureRun(segstart, j, j, runIsRtl, fmi);
    337                     h += advance ? w : -w;
    338 
    339                     if (inSegment) {
    340                         return h += measureRun(segstart, offset, j, runIsRtl, null);
    341                     }
    342 
    343                     if (codept == '\t') {
    344                         if (offset == j) {
    345                             return h;
    346                         }
    347                         h = mDir * nextTab(h * mDir);
    348                         if (target == j) {
    349                             return h;
    350                         }
    351                     }
    352 
    353                     if (bm != null) {
    354                         float bmAscent = ascent(j);
    355                         float wid = bm.getWidth() * -bmAscent / bm.getHeight();
    356                         h += mDir * wid;
    357                         j++;
    358                     }
    359 
    360                     segstart = j + 1;
    361                 }
    362             }
    363         }
    364 
    365         return h;
    366     }
    367 
    368     /**
    369      * Draws a unidirectional (but possibly multi-styled) run of text.
    370      *
    371      *
    372      * @param c the canvas to draw on
    373      * @param start the line-relative start
    374      * @param limit the line-relative limit
    375      * @param runIsRtl true if the run is right-to-left
    376      * @param x the position of the run that is closest to the leading margin
    377      * @param top the top of the line
    378      * @param y the baseline
    379      * @param bottom the bottom of the line
    380      * @param needWidth true if the width value is required.
    381      * @return the signed width of the run, based on the paragraph direction.
    382      * Only valid if needWidth is true.
    383      */
    384     private float drawRun(Canvas c, int start,
    385             int limit, boolean runIsRtl, float x, int top, int y, int bottom,
    386             boolean needWidth) {
    387 
    388         if ((mDir == Layout.DIR_LEFT_TO_RIGHT) == runIsRtl) {
    389             float w = -measureRun(start, limit, limit, runIsRtl, null);
    390             handleRun(start, limit, limit, runIsRtl, c, x + w, top,
    391                     y, bottom, null, false);
    392             return w;
    393         }
    394 
    395         return handleRun(start, limit, limit, runIsRtl, c, x, top,
    396                 y, bottom, null, needWidth);
    397     }
    398 
    399     /**
    400      * Measures a unidirectional (but possibly multi-styled) run of text.
    401      *
    402      *
    403      * @param start the line-relative start of the run
    404      * @param offset the offset to measure to, between start and limit inclusive
    405      * @param limit the line-relative limit of the run
    406      * @param runIsRtl true if the run is right-to-left
    407      * @param fmi receives metrics information about the requested
    408      * run, can be null.
    409      * @return the signed width from the start of the run to the leading edge
    410      * of the character at offset, based on the run (not paragraph) direction
    411      */
    412     private float measureRun(int start, int offset, int limit, boolean runIsRtl,
    413             FontMetricsInt fmi) {
    414         return handleRun(start, offset, limit, runIsRtl, null, 0, 0, 0, 0, fmi, true);
    415     }
    416 
    417     /**
    418      * Walk the cursor through this line, skipping conjuncts and
    419      * zero-width characters.
    420      *
    421      * <p>This function cannot properly walk the cursor off the ends of the line
    422      * since it does not know about any shaping on the previous/following line
    423      * that might affect the cursor position. Callers must either avoid these
    424      * situations or handle the result specially.
    425      *
    426      * @param cursor the starting position of the cursor, between 0 and the
    427      * length of the line, inclusive
    428      * @param toLeft true if the caret is moving to the left.
    429      * @return the new offset.  If it is less than 0 or greater than the length
    430      * of the line, the previous/following line should be examined to get the
    431      * actual offset.
    432      */
    433     int getOffsetToLeftRightOf(int cursor, boolean toLeft) {
    434         // 1) The caret marks the leading edge of a character. The character
    435         // logically before it might be on a different level, and the active caret
    436         // position is on the character at the lower level. If that character
    437         // was the previous character, the caret is on its trailing edge.
    438         // 2) Take this character/edge and move it in the indicated direction.
    439         // This gives you a new character and a new edge.
    440         // 3) This position is between two visually adjacent characters.  One of
    441         // these might be at a lower level.  The active position is on the
    442         // character at the lower level.
    443         // 4) If the active position is on the trailing edge of the character,
    444         // the new caret position is the following logical character, else it
    445         // is the character.
    446 
    447         int lineStart = 0;
    448         int lineEnd = mLen;
    449         boolean paraIsRtl = mDir == -1;
    450         int[] runs = mDirections.mDirections;
    451 
    452         int runIndex, runLevel = 0, runStart = lineStart, runLimit = lineEnd, newCaret = -1;
    453         boolean trailing = false;
    454 
    455         if (cursor == lineStart) {
    456             runIndex = -2;
    457         } else if (cursor == lineEnd) {
    458             runIndex = runs.length;
    459         } else {
    460           // First, get information about the run containing the character with
    461           // the active caret.
    462           for (runIndex = 0; runIndex < runs.length; runIndex += 2) {
    463             runStart = lineStart + runs[runIndex];
    464             if (cursor >= runStart) {
    465               runLimit = runStart + (runs[runIndex+1] & Layout.RUN_LENGTH_MASK);
    466               if (runLimit > lineEnd) {
    467                   runLimit = lineEnd;
    468               }
    469               if (cursor < runLimit) {
    470                 runLevel = (runs[runIndex+1] >>> Layout.RUN_LEVEL_SHIFT) &
    471                     Layout.RUN_LEVEL_MASK;
    472                 if (cursor == runStart) {
    473                   // The caret is on a run boundary, see if we should
    474                   // use the position on the trailing edge of the previous
    475                   // logical character instead.
    476                   int prevRunIndex, prevRunLevel, prevRunStart, prevRunLimit;
    477                   int pos = cursor - 1;
    478                   for (prevRunIndex = 0; prevRunIndex < runs.length; prevRunIndex += 2) {
    479                     prevRunStart = lineStart + runs[prevRunIndex];
    480                     if (pos >= prevRunStart) {
    481                       prevRunLimit = prevRunStart +
    482                           (runs[prevRunIndex+1] & Layout.RUN_LENGTH_MASK);
    483                       if (prevRunLimit > lineEnd) {
    484                           prevRunLimit = lineEnd;
    485                       }
    486                       if (pos < prevRunLimit) {
    487                         prevRunLevel = (runs[prevRunIndex+1] >>> Layout.RUN_LEVEL_SHIFT)
    488                             & Layout.RUN_LEVEL_MASK;
    489                         if (prevRunLevel < runLevel) {
    490                           // Start from logically previous character.
    491                           runIndex = prevRunIndex;
    492                           runLevel = prevRunLevel;
    493                           runStart = prevRunStart;
    494                           runLimit = prevRunLimit;
    495                           trailing = true;
    496                           break;
    497                         }
    498                       }
    499                     }
    500                   }
    501                 }
    502                 break;
    503               }
    504             }
    505           }
    506 
    507           // caret might be == lineEnd.  This is generally a space or paragraph
    508           // separator and has an associated run, but might be the end of
    509           // text, in which case it doesn't.  If that happens, we ran off the
    510           // end of the run list, and runIndex == runs.length.  In this case,
    511           // we are at a run boundary so we skip the below test.
    512           if (runIndex != runs.length) {
    513               boolean runIsRtl = (runLevel & 0x1) != 0;
    514               boolean advance = toLeft == runIsRtl;
    515               if (cursor != (advance ? runLimit : runStart) || advance != trailing) {
    516                   // Moving within or into the run, so we can move logically.
    517                   newCaret = getOffsetBeforeAfter(runIndex, runStart, runLimit,
    518                           runIsRtl, cursor, advance);
    519                   // If the new position is internal to the run, we're at the strong
    520                   // position already so we're finished.
    521                   if (newCaret != (advance ? runLimit : runStart)) {
    522                       return newCaret;
    523                   }
    524               }
    525           }
    526         }
    527 
    528         // If newCaret is -1, we're starting at a run boundary and crossing
    529         // into another run. Otherwise we've arrived at a run boundary, and
    530         // need to figure out which character to attach to.  Note we might
    531         // need to run this twice, if we cross a run boundary and end up at
    532         // another run boundary.
    533         while (true) {
    534           boolean advance = toLeft == paraIsRtl;
    535           int otherRunIndex = runIndex + (advance ? 2 : -2);
    536           if (otherRunIndex >= 0 && otherRunIndex < runs.length) {
    537             int otherRunStart = lineStart + runs[otherRunIndex];
    538             int otherRunLimit = otherRunStart +
    539             (runs[otherRunIndex+1] & Layout.RUN_LENGTH_MASK);
    540             if (otherRunLimit > lineEnd) {
    541                 otherRunLimit = lineEnd;
    542             }
    543             int otherRunLevel = (runs[otherRunIndex+1] >>> Layout.RUN_LEVEL_SHIFT) &
    544                 Layout.RUN_LEVEL_MASK;
    545             boolean otherRunIsRtl = (otherRunLevel & 1) != 0;
    546 
    547             advance = toLeft == otherRunIsRtl;
    548             if (newCaret == -1) {
    549                 newCaret = getOffsetBeforeAfter(otherRunIndex, otherRunStart,
    550                         otherRunLimit, otherRunIsRtl,
    551                         advance ? otherRunStart : otherRunLimit, advance);
    552                 if (newCaret == (advance ? otherRunLimit : otherRunStart)) {
    553                     // Crossed and ended up at a new boundary,
    554                     // repeat a second and final time.
    555                     runIndex = otherRunIndex;
    556                     runLevel = otherRunLevel;
    557                     continue;
    558                 }
    559                 break;
    560             }
    561 
    562             // The new caret is at a boundary.
    563             if (otherRunLevel < runLevel) {
    564               // The strong character is in the other run.
    565               newCaret = advance ? otherRunStart : otherRunLimit;
    566             }
    567             break;
    568           }
    569 
    570           if (newCaret == -1) {
    571               // We're walking off the end of the line.  The paragraph
    572               // level is always equal to or lower than any internal level, so
    573               // the boundaries get the strong caret.
    574               newCaret = advance ? mLen + 1 : -1;
    575               break;
    576           }
    577 
    578           // Else we've arrived at the end of the line.  That's a strong position.
    579           // We might have arrived here by crossing over a run with no internal
    580           // breaks and dropping out of the above loop before advancing one final
    581           // time, so reset the caret.
    582           // Note, we use '<=' below to handle a situation where the only run
    583           // on the line is a counter-directional run.  If we're not advancing,
    584           // we can end up at the 'lineEnd' position but the caret we want is at
    585           // the lineStart.
    586           if (newCaret <= lineEnd) {
    587               newCaret = advance ? lineEnd : lineStart;
    588           }
    589           break;
    590         }
    591 
    592         return newCaret;
    593     }
    594 
    595     /**
    596      * Returns the next valid offset within this directional run, skipping
    597      * conjuncts and zero-width characters.  This should not be called to walk
    598      * off the end of the line, since the returned values might not be valid
    599      * on neighboring lines.  If the returned offset is less than zero or
    600      * greater than the line length, the offset should be recomputed on the
    601      * preceding or following line, respectively.
    602      *
    603      * @param runIndex the run index
    604      * @param runStart the start of the run
    605      * @param runLimit the limit of the run
    606      * @param runIsRtl true if the run is right-to-left
    607      * @param offset the offset
    608      * @param after true if the new offset should logically follow the provided
    609      * offset
    610      * @return the new offset
    611      */
    612     private int getOffsetBeforeAfter(int runIndex, int runStart, int runLimit,
    613             boolean runIsRtl, int offset, boolean after) {
    614 
    615         if (runIndex < 0 || offset == (after ? mLen : 0)) {
    616             // Walking off end of line.  Since we don't know
    617             // what cursor positions are available on other lines, we can't
    618             // return accurate values.  These are a guess.
    619             if (after) {
    620                 return TextUtils.getOffsetAfter(mText, offset + mStart) - mStart;
    621             }
    622             return TextUtils.getOffsetBefore(mText, offset + mStart) - mStart;
    623         }
    624 
    625         TextPaint wp = mWorkPaint;
    626         wp.set(mPaint);
    627 
    628         int spanStart = runStart;
    629         int spanLimit;
    630         if (mSpanned == null) {
    631             spanLimit = runLimit;
    632         } else {
    633             int target = after ? offset + 1 : offset;
    634             int limit = mStart + runLimit;
    635             while (true) {
    636                 spanLimit = mSpanned.nextSpanTransition(mStart + spanStart, limit,
    637                         MetricAffectingSpan.class) - mStart;
    638                 if (spanLimit >= target) {
    639                     break;
    640                 }
    641                 spanStart = spanLimit;
    642             }
    643 
    644             MetricAffectingSpan[] spans = mSpanned.getSpans(mStart + spanStart,
    645                     mStart + spanLimit, MetricAffectingSpan.class);
    646             spans = TextUtils.removeEmptySpans(spans, mSpanned, MetricAffectingSpan.class);
    647 
    648             if (spans.length > 0) {
    649                 ReplacementSpan replacement = null;
    650                 for (int j = 0; j < spans.length; j++) {
    651                     MetricAffectingSpan span = spans[j];
    652                     if (span instanceof ReplacementSpan) {
    653                         replacement = (ReplacementSpan)span;
    654                     } else {
    655                         span.updateMeasureState(wp);
    656                     }
    657                 }
    658 
    659                 if (replacement != null) {
    660                     // If we have a replacement span, we're moving either to
    661                     // the start or end of this span.
    662                     return after ? spanLimit : spanStart;
    663                 }
    664             }
    665         }
    666 
    667         int flags = runIsRtl ? Paint.DIRECTION_RTL : Paint.DIRECTION_LTR;
    668         int cursorOpt = after ? Paint.CURSOR_AFTER : Paint.CURSOR_BEFORE;
    669         if (mCharsValid) {
    670             return wp.getTextRunCursor(mChars, spanStart, spanLimit - spanStart,
    671                     flags, offset, cursorOpt);
    672         } else {
    673             return wp.getTextRunCursor(mText, mStart + spanStart,
    674                     mStart + spanLimit, flags, mStart + offset, cursorOpt) - mStart;
    675         }
    676     }
    677 
    678     /**
    679      * @param wp
    680      */
    681     private static void expandMetricsFromPaint(FontMetricsInt fmi, TextPaint wp) {
    682         final int previousTop     = fmi.top;
    683         final int previousAscent  = fmi.ascent;
    684         final int previousDescent = fmi.descent;
    685         final int previousBottom  = fmi.bottom;
    686         final int previousLeading = fmi.leading;
    687 
    688         wp.getFontMetricsInt(fmi);
    689 
    690         updateMetrics(fmi, previousTop, previousAscent, previousDescent, previousBottom,
    691                 previousLeading);
    692     }
    693 
    694     static void updateMetrics(FontMetricsInt fmi, int previousTop, int previousAscent,
    695             int previousDescent, int previousBottom, int previousLeading) {
    696         fmi.top     = Math.min(fmi.top,     previousTop);
    697         fmi.ascent  = Math.min(fmi.ascent,  previousAscent);
    698         fmi.descent = Math.max(fmi.descent, previousDescent);
    699         fmi.bottom  = Math.max(fmi.bottom,  previousBottom);
    700         fmi.leading = Math.max(fmi.leading, previousLeading);
    701     }
    702 
    703     /**
    704      * Utility function for measuring and rendering text.  The text must
    705      * not include a tab or emoji.
    706      *
    707      * @param wp the working paint
    708      * @param start the start of the text
    709      * @param end the end of the text
    710      * @param runIsRtl true if the run is right-to-left
    711      * @param c the canvas, can be null if rendering is not needed
    712      * @param x the edge of the run closest to the leading margin
    713      * @param top the top of the line
    714      * @param y the baseline
    715      * @param bottom the bottom of the line
    716      * @param fmi receives metrics information, can be null
    717      * @param needWidth true if the width of the run is needed
    718      * @return the signed width of the run based on the run direction; only
    719      * valid if needWidth is true
    720      */
    721     private float handleText(TextPaint wp, int start, int end,
    722             int contextStart, int contextEnd, boolean runIsRtl,
    723             Canvas c, float x, int top, int y, int bottom,
    724             FontMetricsInt fmi, boolean needWidth) {
    725 
    726         // Get metrics first (even for empty strings or "0" width runs)
    727         if (fmi != null) {
    728             expandMetricsFromPaint(fmi, wp);
    729         }
    730 
    731         int runLen = end - start;
    732         // No need to do anything if the run width is "0"
    733         if (runLen == 0) {
    734             return 0f;
    735         }
    736 
    737         float ret = 0;
    738 
    739         int contextLen = contextEnd - contextStart;
    740         if (needWidth || (c != null && (wp.bgColor != 0 || wp.underlineColor != 0 || runIsRtl))) {
    741             int flags = runIsRtl ? Paint.DIRECTION_RTL : Paint.DIRECTION_LTR;
    742             if (mCharsValid) {
    743                 ret = wp.getTextRunAdvances(mChars, start, runLen,
    744                         contextStart, contextLen, flags, null, 0);
    745             } else {
    746                 int delta = mStart;
    747                 ret = wp.getTextRunAdvances(mText, delta + start,
    748                         delta + end, delta + contextStart, delta + contextEnd,
    749                         flags, null, 0);
    750             }
    751         }
    752 
    753         if (c != null) {
    754             if (runIsRtl) {
    755                 x -= ret;
    756             }
    757 
    758             if (wp.bgColor != 0) {
    759                 int previousColor = wp.getColor();
    760                 Paint.Style previousStyle = wp.getStyle();
    761 
    762                 wp.setColor(wp.bgColor);
    763                 wp.setStyle(Paint.Style.FILL);
    764                 c.drawRect(x, top, x + ret, bottom, wp);
    765 
    766                 wp.setStyle(previousStyle);
    767                 wp.setColor(previousColor);
    768             }
    769 
    770             if (wp.underlineColor != 0) {
    771                 // kStdUnderline_Offset = 1/9, defined in SkTextFormatParams.h
    772                 float underlineTop = y + wp.baselineShift + (1.0f / 9.0f) * wp.getTextSize();
    773 
    774                 int previousColor = wp.getColor();
    775                 Paint.Style previousStyle = wp.getStyle();
    776                 boolean previousAntiAlias = wp.isAntiAlias();
    777 
    778                 wp.setStyle(Paint.Style.FILL);
    779                 wp.setAntiAlias(true);
    780 
    781                 wp.setColor(wp.underlineColor);
    782                 c.drawRect(x, underlineTop, x + ret, underlineTop + wp.underlineThickness, wp);
    783 
    784                 wp.setStyle(previousStyle);
    785                 wp.setColor(previousColor);
    786                 wp.setAntiAlias(previousAntiAlias);
    787             }
    788 
    789             drawTextRun(c, wp, start, end, contextStart, contextEnd, runIsRtl,
    790                     x, y + wp.baselineShift);
    791         }
    792 
    793         return runIsRtl ? -ret : ret;
    794     }
    795 
    796     /**
    797      * Utility function for measuring and rendering a replacement.
    798      *
    799      *
    800      * @param replacement the replacement
    801      * @param wp the work paint
    802      * @param start the start of the run
    803      * @param limit the limit of the run
    804      * @param runIsRtl true if the run is right-to-left
    805      * @param c the canvas, can be null if not rendering
    806      * @param x the edge of the replacement closest to the leading margin
    807      * @param top the top of the line
    808      * @param y the baseline
    809      * @param bottom the bottom of the line
    810      * @param fmi receives metrics information, can be null
    811      * @param needWidth true if the width of the replacement is needed
    812      * @return the signed width of the run based on the run direction; only
    813      * valid if needWidth is true
    814      */
    815     private float handleReplacement(ReplacementSpan replacement, TextPaint wp,
    816             int start, int limit, boolean runIsRtl, Canvas c,
    817             float x, int top, int y, int bottom, FontMetricsInt fmi,
    818             boolean needWidth) {
    819 
    820         float ret = 0;
    821 
    822         int textStart = mStart + start;
    823         int textLimit = mStart + limit;
    824 
    825         if (needWidth || (c != null && runIsRtl)) {
    826             int previousTop = 0;
    827             int previousAscent = 0;
    828             int previousDescent = 0;
    829             int previousBottom = 0;
    830             int previousLeading = 0;
    831 
    832             boolean needUpdateMetrics = (fmi != null);
    833 
    834             if (needUpdateMetrics) {
    835                 previousTop     = fmi.top;
    836                 previousAscent  = fmi.ascent;
    837                 previousDescent = fmi.descent;
    838                 previousBottom  = fmi.bottom;
    839                 previousLeading = fmi.leading;
    840             }
    841 
    842             ret = replacement.getSize(wp, mText, textStart, textLimit, fmi);
    843 
    844             if (needUpdateMetrics) {
    845                 updateMetrics(fmi, previousTop, previousAscent, previousDescent, previousBottom,
    846                         previousLeading);
    847             }
    848         }
    849 
    850         if (c != null) {
    851             if (runIsRtl) {
    852                 x -= ret;
    853             }
    854             replacement.draw(c, mText, textStart, textLimit,
    855                     x, top, y, bottom, wp);
    856         }
    857 
    858         return runIsRtl ? -ret : ret;
    859     }
    860 
    861     /**
    862      * Utility function for handling a unidirectional run.  The run must not
    863      * contain tabs or emoji but can contain styles.
    864      *
    865      *
    866      * @param start the line-relative start of the run
    867      * @param measureLimit the offset to measure to, between start and limit inclusive
    868      * @param limit the limit of the run
    869      * @param runIsRtl true if the run is right-to-left
    870      * @param c the canvas, can be null
    871      * @param x the end of the run closest to the leading margin
    872      * @param top the top of the line
    873      * @param y the baseline
    874      * @param bottom the bottom of the line
    875      * @param fmi receives metrics information, can be null
    876      * @param needWidth true if the width is required
    877      * @return the signed width of the run based on the run direction; only
    878      * valid if needWidth is true
    879      */
    880     private float handleRun(int start, int measureLimit,
    881             int limit, boolean runIsRtl, Canvas c, float x, int top, int y,
    882             int bottom, FontMetricsInt fmi, boolean needWidth) {
    883 
    884         // Case of an empty line, make sure we update fmi according to mPaint
    885         if (start == measureLimit) {
    886             TextPaint wp = mWorkPaint;
    887             wp.set(mPaint);
    888             if (fmi != null) {
    889                 expandMetricsFromPaint(fmi, wp);
    890             }
    891             return 0f;
    892         }
    893 
    894         if (mSpanned == null) {
    895             TextPaint wp = mWorkPaint;
    896             wp.set(mPaint);
    897             final int mlimit = measureLimit;
    898             return handleText(wp, start, mlimit, start, limit, runIsRtl, c, x, top,
    899                     y, bottom, fmi, needWidth || mlimit < measureLimit);
    900         }
    901 
    902         mMetricAffectingSpanSpanSet.init(mSpanned, mStart + start, mStart + limit);
    903         mCharacterStyleSpanSet.init(mSpanned, mStart + start, mStart + limit);
    904 
    905         // Shaping needs to take into account context up to metric boundaries,
    906         // but rendering needs to take into account character style boundaries.
    907         // So we iterate through metric runs to get metric bounds,
    908         // then within each metric run iterate through character style runs
    909         // for the run bounds.
    910         final float originalX = x;
    911         for (int i = start, inext; i < measureLimit; i = inext) {
    912             TextPaint wp = mWorkPaint;
    913             wp.set(mPaint);
    914 
    915             inext = mMetricAffectingSpanSpanSet.getNextTransition(mStart + i, mStart + limit) -
    916                     mStart;
    917             int mlimit = Math.min(inext, measureLimit);
    918 
    919             ReplacementSpan replacement = null;
    920 
    921             for (int j = 0; j < mMetricAffectingSpanSpanSet.numberOfSpans; j++) {
    922                 // Both intervals [spanStarts..spanEnds] and [mStart + i..mStart + mlimit] are NOT
    923                 // empty by construction. This special case in getSpans() explains the >= & <= tests
    924                 if ((mMetricAffectingSpanSpanSet.spanStarts[j] >= mStart + mlimit) ||
    925                         (mMetricAffectingSpanSpanSet.spanEnds[j] <= mStart + i)) continue;
    926                 MetricAffectingSpan span = mMetricAffectingSpanSpanSet.spans[j];
    927                 if (span instanceof ReplacementSpan) {
    928                     replacement = (ReplacementSpan)span;
    929                 } else {
    930                     // We might have a replacement that uses the draw
    931                     // state, otherwise measure state would suffice.
    932                     span.updateDrawState(wp);
    933                 }
    934             }
    935 
    936             if (replacement != null) {
    937                 x += handleReplacement(replacement, wp, i, mlimit, runIsRtl, c, x, top, y,
    938                         bottom, fmi, needWidth || mlimit < measureLimit);
    939                 continue;
    940             }
    941 
    942             for (int j = i, jnext; j < mlimit; j = jnext) {
    943                 jnext = mCharacterStyleSpanSet.getNextTransition(mStart + j, mStart + mlimit) -
    944                         mStart;
    945 
    946                 wp.set(mPaint);
    947                 for (int k = 0; k < mCharacterStyleSpanSet.numberOfSpans; k++) {
    948                     // Intentionally using >= and <= as explained above
    949                     if ((mCharacterStyleSpanSet.spanStarts[k] >= mStart + jnext) ||
    950                             (mCharacterStyleSpanSet.spanEnds[k] <= mStart + j)) continue;
    951 
    952                     CharacterStyle span = mCharacterStyleSpanSet.spans[k];
    953                     span.updateDrawState(wp);
    954                 }
    955 
    956                 x += handleText(wp, j, jnext, i, inext, runIsRtl, c, x,
    957                         top, y, bottom, fmi, needWidth || jnext < measureLimit);
    958             }
    959         }
    960 
    961         return x - originalX;
    962     }
    963 
    964     /**
    965      * Render a text run with the set-up paint.
    966      *
    967      * @param c the canvas
    968      * @param wp the paint used to render the text
    969      * @param start the start of the run
    970      * @param end the end of the run
    971      * @param contextStart the start of context for the run
    972      * @param contextEnd the end of the context for the run
    973      * @param runIsRtl true if the run is right-to-left
    974      * @param x the x position of the left edge of the run
    975      * @param y the baseline of the run
    976      */
    977     private void drawTextRun(Canvas c, TextPaint wp, int start, int end,
    978             int contextStart, int contextEnd, boolean runIsRtl, float x, int y) {
    979 
    980         int flags = runIsRtl ? Canvas.DIRECTION_RTL : Canvas.DIRECTION_LTR;
    981         if (mCharsValid) {
    982             int count = end - start;
    983             int contextCount = contextEnd - contextStart;
    984             c.drawTextRun(mChars, start, count, contextStart, contextCount,
    985                     x, y, flags, wp);
    986         } else {
    987             int delta = mStart;
    988             c.drawTextRun(mText, delta + start, delta + end,
    989                     delta + contextStart, delta + contextEnd, x, y, flags, wp);
    990         }
    991     }
    992 
    993     /**
    994      * Returns the ascent of the text at start.  This is used for scaling
    995      * emoji.
    996      *
    997      * @param pos the line-relative position
    998      * @return the ascent of the text at start
    999      */
   1000     float ascent(int pos) {
   1001         if (mSpanned == null) {
   1002             return mPaint.ascent();
   1003         }
   1004 
   1005         pos += mStart;
   1006         MetricAffectingSpan[] spans = mSpanned.getSpans(pos, pos + 1, MetricAffectingSpan.class);
   1007         if (spans.length == 0) {
   1008             return mPaint.ascent();
   1009         }
   1010 
   1011         TextPaint wp = mWorkPaint;
   1012         wp.set(mPaint);
   1013         for (MetricAffectingSpan span : spans) {
   1014             span.updateMeasureState(wp);
   1015         }
   1016         return wp.ascent();
   1017     }
   1018 
   1019     /**
   1020      * Returns the next tab position.
   1021      *
   1022      * @param h the (unsigned) offset from the leading margin
   1023      * @return the (unsigned) tab position after this offset
   1024      */
   1025     float nextTab(float h) {
   1026         if (mTabs != null) {
   1027             return mTabs.nextTab(h);
   1028         }
   1029         return TabStops.nextDefaultStop(h, TAB_INCREMENT);
   1030     }
   1031 
   1032     private static final int TAB_INCREMENT = 20;
   1033 }
   1034