core/java/android/text/Layout.java

   1 /*
   2  * Copyright (C) 2006 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.emoji.EmojiFactory;
  20 import android.graphics.Canvas;
  21 import android.graphics.Paint;
  22 import android.graphics.Path;
  23 import android.graphics.Rect;
  24 import android.text.method.TextKeyListener;
  25 import android.text.style.AlignmentSpan;
  26 import android.text.style.LeadingMarginSpan;
  27 import android.text.style.LeadingMarginSpan.LeadingMarginSpan2;
  28 import android.text.style.LineBackgroundSpan;
  29 import android.text.style.ParagraphStyle;
  30 import android.text.style.ReplacementSpan;
  31 import android.text.style.TabStopSpan;
  32
  33 import com.android.internal.util.ArrayUtils;
  34 import com.android.internal.util.GrowingArrayUtils;
  35
  36 import java.util.Arrays;
  37
  38 /**
  39  * A base class that manages text layout in visual elements on
  40  * the screen.
  41  * <p>For text that will be edited, use a {@link DynamicLayout},
  42  * which will be updated as the text changes.
  43  * For text that will not change, use a {@link StaticLayout}.
  44  */
  45 public abstract class Layout {
  46     private static final ParagraphStyle[] NO_PARA_SPANS =
  47         ArrayUtils.emptyArray(ParagraphStyle.class);
  48
  49     /* package */ static final EmojiFactory EMOJI_FACTORY = EmojiFactory.newAvailableInstance();
  50     /* package */ static final int MIN_EMOJI, MAX_EMOJI;
  51
  52     static {
  53         if (EMOJI_FACTORY != null) {
  54             MIN_EMOJI = EMOJI_FACTORY.getMinimumAndroidPua();
  55             MAX_EMOJI = EMOJI_FACTORY.getMaximumAndroidPua();
  56         } else {
  57             MIN_EMOJI = -1;
  58             MAX_EMOJI = -1;
  59         }
  60     }
  61
  62     /**
  63      * Return how wide a layout must be in order to display the
  64      * specified text with one line per paragraph.
  65      */
  66     public static float getDesiredWidth(CharSequence source,
  67                                         TextPaint paint) {
  68         return getDesiredWidth(source, 0, source.length(), paint);
  69     }
  70
  71     /**
  72      * Return how wide a layout must be in order to display the
  73      * specified text slice with one line per paragraph.
  74      */
  75     public static float getDesiredWidth(CharSequence source,
  76                                         int start, int end,
  77                                         TextPaint paint) {
  78         float need = 0;
  79
  80         int next;
  81         for (int i = start; i <= end; i = next) {
  82             next = TextUtils.indexOf(source, '\n', i, end);
  83
  84             if (next < 0)
  85                 next = end;
  86
  87             // note, omits trailing paragraph char
  88             float w = measurePara(paint, source, i, next);
  89
  90             if (w > need)
  91                 need = w;
  92
  93             next++;
  94         }
  95
  96         return need;
  97     }
  98
  99     /**
 100      * Subclasses of Layout use this constructor to set the display text,
 101      * width, and other standard properties.
 102      * @param text the text to render
 103      * @param paint the default paint for the layout.  Styles can override
 104      * various attributes of the paint.
 105      * @param width the wrapping width for the text.
 106      * @param align whether to left, right, or center the text.  Styles can
 107      * override the alignment.
 108      * @param spacingMult factor by which to scale the font size to get the
 109      * default line spacing
 110      * @param spacingAdd amount to add to the default line spacing
 111      */
 112     protected Layout(CharSequence text, TextPaint paint,
 113                      int width, Alignment align,
 114                      float spacingMult, float spacingAdd) {
 115         this(text, paint, width, align, TextDirectionHeuristics.FIRSTSTRONG_LTR,
 116                 spacingMult, spacingAdd);
 117     }
 118
 119     /**
 120      * Subclasses of Layout use this constructor to set the display text,
 121      * width, and other standard properties.
 122      * @param text the text to render
 123      * @param paint the default paint for the layout.  Styles can override
 124      * various attributes of the paint.
 125      * @param width the wrapping width for the text.
 126      * @param align whether to left, right, or center the text.  Styles can
 127      * override the alignment.
 128      * @param spacingMult factor by which to scale the font size to get the
 129      * default line spacing
 130      * @param spacingAdd amount to add to the default line spacing
 131      *
 132      * @hide
 133      */
 134     protected Layout(CharSequence text, TextPaint paint,
 135                      int width, Alignment align, TextDirectionHeuristic textDir,
 136                      float spacingMult, float spacingAdd) {
 137
 138         if (width < 0)
 139             throw new IllegalArgumentException("Layout: " + width + " < 0");
 140
 141         // Ensure paint doesn't have baselineShift set.
 142         // While normally we don't modify the paint the user passed in,
 143         // we were already doing this in Styled.drawUniformRun with both
 144         // baselineShift and bgColor.  We probably should reevaluate bgColor.
 145         if (paint != null) {
 146             paint.bgColor = 0;
 147             paint.baselineShift = 0;
 148         }
 149
 150         mText = text;
 151         mPaint = paint;
 152         mWorkPaint = new TextPaint();
 153         mWidth = width;
 154         mAlignment = align;
 155         mSpacingMult = spacingMult;
 156         mSpacingAdd = spacingAdd;
 157         mSpannedText = text instanceof Spanned;
 158         mTextDir = textDir;
 159     }
 160
 161     /**
 162      * Replace constructor properties of this Layout with new ones.  Be careful.
 163      */
 164     /* package */ void replaceWith(CharSequence text, TextPaint paint,
 165                               int width, Alignment align,
 166                               float spacingmult, float spacingadd) {
 167         if (width < 0) {
 168             throw new IllegalArgumentException("Layout: " + width + " < 0");
 169         }
 170
 171         mText = text;
 172         mPaint = paint;
 173         mWidth = width;
 174         mAlignment = align;
 175         mSpacingMult = spacingmult;
 176         mSpacingAdd = spacingadd;
 177         mSpannedText = text instanceof Spanned;
 178     }
 179
 180     /**
 181      * Draw this Layout on the specified Canvas.
 182      */
 183     public void draw(Canvas c) {
 184         draw(c, null, null, 0);
 185     }
 186
 187     /**
 188      * Draw this Layout on the specified canvas, with the highlight path drawn
 189      * between the background and the text.
 190      *
 191      * @param canvas the canvas
 192      * @param highlight the path of the highlight or cursor; can be null
 193      * @param highlightPaint the paint for the highlight
 194      * @param cursorOffsetVertical the amount to temporarily translate the
 195      *        canvas while rendering the highlight
 196      */
 197     public void draw(Canvas canvas, Path highlight, Paint highlightPaint,
 198             int cursorOffsetVertical) {
 199         final long lineRange = getLineRangeForDraw(canvas);
 200         int firstLine = TextUtils.unpackRangeStartFromLong(lineRange);
 201         int lastLine = TextUtils.unpackRangeEndFromLong(lineRange);
 202         if (lastLine < 0) return;
 203
 204         drawBackground(canvas, highlight, highlightPaint, cursorOffsetVertical,
 205                 firstLine, lastLine);
 206         drawText(canvas, firstLine, lastLine);
 207     }
 208
 209     /**
 210      * @hide
 211      */
 212     public void drawText(Canvas canvas, int firstLine, int lastLine) {
 213         int previousLineBottom = getLineTop(firstLine);
 214         int previousLineEnd = getLineStart(firstLine);
 215         ParagraphStyle[] spans = NO_PARA_SPANS;
 216         int spanEnd = 0;
 217         TextPaint paint = mPaint;
 218         CharSequence buf = mText;
 219
 220         Alignment paraAlign = mAlignment;
 221         TabStops tabStops = null;
 222         boolean tabStopsIsInitialized = false;
 223
 224         TextLine tl = TextLine.obtain();
 225
 226         // Draw the lines, one at a time.
 227         // The baseline is the top of the following line minus the current line's descent.
 228         for (int i = firstLine; i <= lastLine; i++) {
 229             int start = previousLineEnd;
 230             previousLineEnd = getLineStart(i + 1);
 231             int end = getLineVisibleEnd(i, start, previousLineEnd);
 232
 233             int ltop = previousLineBottom;
 234             int lbottom = getLineTop(i+1);
 235             previousLineBottom = lbottom;
 236             int lbaseline = lbottom - getLineDescent(i);
 237
 238             int dir = getParagraphDirection(i);
 239             int left = 0;
 240             int right = mWidth;
 241
 242             if (mSpannedText) {
 243                 Spanned sp = (Spanned) buf;
 244                 int textLength = buf.length();
 245                 boolean isFirstParaLine = (start == 0 || buf.charAt(start - 1) == '\n');
 246
 247                 // New batch of paragraph styles, collect into spans array.
 248                 // Compute the alignment, last alignment style wins.
 249                 // Reset tabStops, we'll rebuild if we encounter a line with
 250                 // tabs.
 251                 // We expect paragraph spans to be relatively infrequent, use
 252                 // spanEnd so that we can check less frequently.  Since
 253                 // paragraph styles ought to apply to entire paragraphs, we can
 254                 // just collect the ones present at the start of the paragraph.
 255                 // If spanEnd is before the end of the paragraph, that's not
 256                 // our problem.
 257                 if (start >= spanEnd && (i == firstLine || isFirstParaLine)) {
 258                     spanEnd = sp.nextSpanTransition(start, textLength,
 259                                                     ParagraphStyle.class);
 260                     spans = getParagraphSpans(sp, start, spanEnd, ParagraphStyle.class);
 261
 262                     paraAlign = mAlignment;
 263                     for (int n = spans.length - 1; n >= 0; n--) {
 264                         if (spans[n] instanceof AlignmentSpan) {
 265                             paraAlign = ((AlignmentSpan) spans[n]).getAlignment();
 266                             break;
 267                         }
 268                     }
 269
 270                     tabStopsIsInitialized = false;
 271                 }
 272
 273                 // Draw all leading margin spans.  Adjust left or right according
 274                 // to the paragraph direction of the line.
 275                 final int length = spans.length;
 276                 boolean useFirstLineMargin = isFirstParaLine;
 277                 for (int n = 0; n < length; n++) {
 278                     if (spans[n] instanceof LeadingMarginSpan2) {
 279                         int count = ((LeadingMarginSpan2) spans[n]).getLeadingMarginLineCount();
 280                         int startLine = getLineForOffset(sp.getSpanStart(spans[n]));
 281                         // if there is more than one LeadingMarginSpan2, use
 282                         // the count that is greatest
 283                         if (i < startLine + count) {
 284                             useFirstLineMargin = true;
 285                             break;
 286                         }
 287                     }
 288                 }
 289                 for (int n = 0; n < length; n++) {
 290                     if (spans[n] instanceof LeadingMarginSpan) {
 291                         LeadingMarginSpan margin = (LeadingMarginSpan) spans[n];
 292                         if (dir == DIR_RIGHT_TO_LEFT) {
 293                             margin.drawLeadingMargin(canvas, paint, right, dir, ltop,
 294                                                      lbaseline, lbottom, buf,
 295                                                      start, end, isFirstParaLine, this);
 296                             right -= margin.getLeadingMargin(useFirstLineMargin);
 297                         } else {
 298                             margin.drawLeadingMargin(canvas, paint, left, dir, ltop,
 299                                                      lbaseline, lbottom, buf,
 300                                                      start, end, isFirstParaLine, this);
 301                             left += margin.getLeadingMargin(useFirstLineMargin);
 302                         }
 303                     }
 304                 }
 305             }
 306
 307             boolean hasTabOrEmoji = getLineContainsTab(i);
 308             // Can't tell if we have tabs for sure, currently
 309             if (hasTabOrEmoji && !tabStopsIsInitialized) {
 310                 if (tabStops == null) {
 311                     tabStops = new TabStops(TAB_INCREMENT, spans);
 312                 } else {
 313                     tabStops.reset(TAB_INCREMENT, spans);
 314                 }
 315                 tabStopsIsInitialized = true;
 316             }
 317
 318             // Determine whether the line aligns to normal, opposite, or center.
 319             Alignment align = paraAlign;
 320             if (align == Alignment.ALIGN_LEFT) {
 321                 align = (dir == DIR_LEFT_TO_RIGHT) ?
 322                     Alignment.ALIGN_NORMAL : Alignment.ALIGN_OPPOSITE;
 323             } else if (align == Alignment.ALIGN_RIGHT) {
 324                 align = (dir == DIR_LEFT_TO_RIGHT) ?
 325                     Alignment.ALIGN_OPPOSITE : Alignment.ALIGN_NORMAL;
 326             }
 327
 328             int x;
 329             if (align == Alignment.ALIGN_NORMAL) {
 330                 if (dir == DIR_LEFT_TO_RIGHT) {
 331                     x = left;
 332                 } else {
 333                     x = right;
 334                 }
 335             } else {
 336                 int max = (int)getLineExtent(i, tabStops, false);
 337                 if (align == Alignment.ALIGN_OPPOSITE) {
 338                     if (dir == DIR_LEFT_TO_RIGHT) {
 339                         x = right - max;
 340                     } else {
 341                         x = left - max;
 342                     }
 343                 } else { // Alignment.ALIGN_CENTER
 344                     max = max & ~1;
 345                     x = (right + left - max) >> 1;
 346                 }
 347             }
 348
 349             Directions directions = getLineDirections(i);
 350             if (directions == DIRS_ALL_LEFT_TO_RIGHT && !mSpannedText && !hasTabOrEmoji) {
 351                 // XXX: assumes there's nothing additional to be done
 352                 canvas.drawText(buf, start, end, x, lbaseline, paint);
 353             } else {
 354                 tl.set(paint, buf, start, end, dir, directions, hasTabOrEmoji, tabStops);
 355                 tl.draw(canvas, x, ltop, lbaseline, lbottom);
 356             }
 357         }
 358
 359         TextLine.recycle(tl);
 360     }
 361
 362     /**
 363      * @hide
 364      */
 365     public void drawBackground(Canvas canvas, Path highlight, Paint highlightPaint,
 366             int cursorOffsetVertical, int firstLine, int lastLine) {
 367         // First, draw LineBackgroundSpans.
 368         // LineBackgroundSpans know nothing about the alignment, margins, or
 369         // direction of the layout or line.  XXX: Should they?
 370         // They are evaluated at each line.
 371         if (mSpannedText) {
 372             if (mLineBackgroundSpans == null) {
 373                 mLineBackgroundSpans = new SpanSet<LineBackgroundSpan>(LineBackgroundSpan.class);
 374             }
 375
 376             Spanned buffer = (Spanned) mText;
 377             int textLength = buffer.length();
 378             mLineBackgroundSpans.init(buffer, 0, textLength);
 379
 380             if (mLineBackgroundSpans.numberOfSpans > 0) {
 381                 int previousLineBottom = getLineTop(firstLine);
 382                 int previousLineEnd = getLineStart(firstLine);
 383                 ParagraphStyle[] spans = NO_PARA_SPANS;
 384                 int spansLength = 0;
 385                 TextPaint paint = mPaint;
 386                 int spanEnd = 0;
 387                 final int width = mWidth;
 388                 for (int i = firstLine; i <= lastLine; i++) {
 389                     int start = previousLineEnd;
 390                     int end = getLineStart(i + 1);
 391                     previousLineEnd = end;
 392
 393                     int ltop = previousLineBottom;
 394                     int lbottom = getLineTop(i + 1);
 395                     previousLineBottom = lbottom;
 396                     int lbaseline = lbottom - getLineDescent(i);
 397
 398                     if (start >= spanEnd) {
 399                         // These should be infrequent, so we'll use this so that
 400                         // we don't have to check as often.
 401                         spanEnd = mLineBackgroundSpans.getNextTransition(start, textLength);
 402                         // All LineBackgroundSpans on a line contribute to its background.
 403                         spansLength = 0;
 404                         // Duplication of the logic of getParagraphSpans
 405                         if (start != end || start == 0) {
 406                             // Equivalent to a getSpans(start, end), but filling the 'spans' local
 407                             // array instead to reduce memory allocation
 408                             for (int j = 0; j < mLineBackgroundSpans.numberOfSpans; j++) {
 409                                 // equal test is valid since both intervals are not empty by
 410                                 // construction
 411                                 if (mLineBackgroundSpans.spanStarts[j] >= end ||
 412                                         mLineBackgroundSpans.spanEnds[j] <= start) continue;
 413                                 spans = GrowingArrayUtils.append(
 414                                         spans, spansLength, mLineBackgroundSpans.spans[j]);
 415                                 spansLength++;
 416                             }
 417                         }
 418                     }
 419
 420                     for (int n = 0; n < spansLength; n++) {
 421                         LineBackgroundSpan lineBackgroundSpan = (LineBackgroundSpan) spans[n];
 422                         lineBackgroundSpan.drawBackground(canvas, paint, 0, width,
 423                                 ltop, lbaseline, lbottom,
 424                                 buffer, start, end, i);
 425                     }
 426                 }
 427             }
 428             mLineBackgroundSpans.recycle();
 429         }
 430
 431         // There can be a highlight even without spans if we are drawing
 432         // a non-spanned transformation of a spanned editing buffer.
 433         if (highlight != null) {
 434             if (cursorOffsetVertical != 0) canvas.translate(0, cursorOffsetVertical);
 435             canvas.drawPath(highlight, highlightPaint);
 436             if (cursorOffsetVertical != 0) canvas.translate(0, -cursorOffsetVertical);
 437         }
 438     }
 439
 440     /**
 441      * @param canvas
 442      * @return The range of lines that need to be drawn, possibly empty.
 443      * @hide
 444      */
 445     public long getLineRangeForDraw(Canvas canvas) {
 446         int dtop, dbottom;
 447
 448         synchronized (sTempRect) {
 449             if (!canvas.getClipBounds(sTempRect)) {
 450                 // Negative range end used as a special flag
 451                 return TextUtils.packRangeInLong(0, -1);
 452             }
 453
 454             dtop = sTempRect.top;
 455             dbottom = sTempRect.bottom;
 456         }
 457
 458         final int top = Math.max(dtop, 0);
 459         final int bottom = Math.min(getLineTop(getLineCount()), dbottom);
 460
 461         if (top >= bottom) return TextUtils.packRangeInLong(0, -1);
 462         return TextUtils.packRangeInLong(getLineForVertical(top), getLineForVertical(bottom));
 463     }
 464
 465     /**
 466      * Return the start position of the line, given the left and right bounds
 467      * of the margins.
 468      *
 469      * @param line the line index
 470      * @param left the left bounds (0, or leading margin if ltr para)
 471      * @param right the right bounds (width, minus leading margin if rtl para)
 472      * @return the start position of the line (to right of line if rtl para)
 473      */
 474     private int getLineStartPos(int line, int left, int right) {
 475         // Adjust the point at which to start rendering depending on the
 476         // alignment of the paragraph.
 477         Alignment align = getParagraphAlignment(line);
 478         int dir = getParagraphDirection(line);
 479
 480         if (align == Alignment.ALIGN_LEFT) {
 481             align = (dir == DIR_LEFT_TO_RIGHT) ? Alignment.ALIGN_NORMAL : Alignment.ALIGN_OPPOSITE;
 482         } else if (align == Alignment.ALIGN_RIGHT) {
 483             align = (dir == DIR_LEFT_TO_RIGHT) ? Alignment.ALIGN_OPPOSITE : Alignment.ALIGN_NORMAL;
 484         }
 485
 486         int x;
 487         if (align == Alignment.ALIGN_NORMAL) {
 488             if (dir == DIR_LEFT_TO_RIGHT) {
 489                 x = left;
 490             } else {
 491                 x = right;
 492             }
 493         } else {
 494             TabStops tabStops = null;
 495             if (mSpannedText && getLineContainsTab(line)) {
 496                 Spanned spanned = (Spanned) mText;
 497                 int start = getLineStart(line);
 498                 int spanEnd = spanned.nextSpanTransition(start, spanned.length(),
 499                         TabStopSpan.class);
 500                 TabStopSpan[] tabSpans = getParagraphSpans(spanned, start, spanEnd,
 501                         TabStopSpan.class);
 502                 if (tabSpans.length > 0) {
 503                     tabStops = new TabStops(TAB_INCREMENT, tabSpans);
 504                 }
 505             }
 506             int max = (int)getLineExtent(line, tabStops, false);
 507             if (align == Alignment.ALIGN_OPPOSITE) {
 508                 if (dir == DIR_LEFT_TO_RIGHT) {
 509                     x = right - max;
 510                 } else {
 511                     // max is negative here
 512                     x = left - max;
 513                 }
 514             } else { // Alignment.ALIGN_CENTER
 515                 max = max & ~1;
 516                 x = (left + right - max) >> 1;
 517             }
 518         }
 519         return x;
 520     }
 521
 522     /**
 523      * Return the text that is displayed by this Layout.
 524      */
 525     public final CharSequence getText() {
 526         return mText;
 527     }
 528
 529     /**
 530      * Return the base Paint properties for this layout.
 531      * Do NOT change the paint, which may result in funny
 532      * drawing for this layout.
 533      */
 534     public final TextPaint getPaint() {
 535         return mPaint;
 536     }
 537
 538     /**
 539      * Return the width of this layout.
 540      */
 541     public final int getWidth() {
 542         return mWidth;
 543     }
 544
 545     /**
 546      * Return the width to which this Layout is ellipsizing, or
 547      * {@link #getWidth} if it is not doing anything special.
 548      */
 549     public int getEllipsizedWidth() {
 550         return mWidth;
 551     }
 552
 553     /**
 554      * Increase the width of this layout to the specified width.
 555      * Be careful to use this only when you know it is appropriate&mdash;
 556      * it does not cause the text to reflow to use the full new width.
 557      */
 558     public final void increaseWidthTo(int wid) {
 559         if (wid < mWidth) {
 560             throw new RuntimeException("attempted to reduce Layout width");
 561         }
 562
 563         mWidth = wid;
 564     }
 565
 566     /**
 567      * Return the total height of this layout.
 568      */
 569     public int getHeight() {
 570         return getLineTop(getLineCount());
 571     }
 572
 573     /**
 574      * Return the base alignment of this layout.
 575      */
 576     public final Alignment getAlignment() {
 577         return mAlignment;
 578     }
 579
 580     /**
 581      * Return what the text height is multiplied by to get the line height.
 582      */
 583     public final float getSpacingMultiplier() {
 584         return mSpacingMult;
 585     }
 586
 587     /**
 588      * Return the number of units of leading that are added to each line.
 589      */
 590     public final float getSpacingAdd() {
 591         return mSpacingAdd;
 592     }
 593
 594     /**
 595      * Return the heuristic used to determine paragraph text direction.
 596      * @hide
 597      */
 598     public final TextDirectionHeuristic getTextDirectionHeuristic() {
 599         return mTextDir;
 600     }
 601
 602     /**
 603      * Return the number of lines of text in this layout.
 604      */
 605     public abstract int getLineCount();
 606
 607     /**
 608      * Return the baseline for the specified line (0&hellip;getLineCount() - 1)
 609      * If bounds is not null, return the top, left, right, bottom extents
 610      * of the specified line in it.
 611      * @param line which line to examine (0..getLineCount() - 1)
 612      * @param bounds Optional. If not null, it returns the extent of the line
 613      * @return the Y-coordinate of the baseline
 614      */
 615     public int getLineBounds(int line, Rect bounds) {
 616         if (bounds != null) {
 617             bounds.left = 0;     // ???
 618             bounds.top = getLineTop(line);
 619             bounds.right = mWidth;   // ???
 620             bounds.bottom = getLineTop(line + 1);
 621         }
 622         return getLineBaseline(line);
 623     }
 624
 625     /**
 626      * Return the vertical position of the top of the specified line
 627      * (0&hellip;getLineCount()).
 628      * If the specified line is equal to the line count, returns the
 629      * bottom of the last line.
 630      */
 631     public abstract int getLineTop(int line);
 632
 633     /**
 634      * Return the descent of the specified line(0&hellip;getLineCount() - 1).
 635      */
 636     public abstract int getLineDescent(int line);
 637
 638     /**
 639      * Return the text offset of the beginning of the specified line (
 640      * 0&hellip;getLineCount()). If the specified line is equal to the line
 641      * count, returns the length of the text.
 642      */
 643     public abstract int getLineStart(int line);
 644
 645     /**
 646      * Returns the primary directionality of the paragraph containing the
 647      * specified line, either 1 for left-to-right lines, or -1 for right-to-left
 648      * lines (see {@link #DIR_LEFT_TO_RIGHT}, {@link #DIR_RIGHT_TO_LEFT}).
 649      */
 650     public abstract int getParagraphDirection(int line);
 651
 652     /**
 653      * Returns whether the specified line contains one or more
 654      * characters that need to be handled specially, like tabs
 655      * or emoji.
 656      */
 657     public abstract boolean getLineContainsTab(int line);
 658
 659     /**
 660      * Returns the directional run information for the specified line.
 661      * The array alternates counts of characters in left-to-right
 662      * and right-to-left segments of the line.
 663      *
 664      * <p>NOTE: this is inadequate to support bidirectional text, and will change.
 665      */
 666     public abstract Directions getLineDirections(int line);
 667
 668     /**
 669      * Returns the (negative) number of extra pixels of ascent padding in the
 670      * top line of the Layout.
 671      */
 672     public abstract int getTopPadding();
 673
 674     /**
 675      * Returns the number of extra pixels of descent padding in the
 676      * bottom line of the Layout.
 677      */
 678     public abstract int getBottomPadding();
 679
 680
 681     /**
 682      * Returns true if the character at offset and the preceding character
 683      * are at different run levels (and thus there's a split caret).
 684      * @param offset the offset
 685      * @return true if at a level boundary
 686      * @hide
 687      */
 688     public boolean isLevelBoundary(int offset) {
 689         int line = getLineForOffset(offset);
 690         Directions dirs = getLineDirections(line);
 691         if (dirs == DIRS_ALL_LEFT_TO_RIGHT || dirs == DIRS_ALL_RIGHT_TO_LEFT) {
 692             return false;
 693         }
 694
 695         int[] runs = dirs.mDirections;
 696         int lineStart = getLineStart(line);
 697         int lineEnd = getLineEnd(line);
 698         if (offset == lineStart || offset == lineEnd) {
 699             int paraLevel = getParagraphDirection(line) == 1 ? 0 : 1;
 700             int runIndex = offset == lineStart ? 0 : runs.length - 2;
 701             return ((runs[runIndex + 1] >>> RUN_LEVEL_SHIFT) & RUN_LEVEL_MASK) != paraLevel;
 702         }
 703
 704         offset -= lineStart;
 705         for (int i = 0; i < runs.length; i += 2) {
 706             if (offset == runs[i]) {
 707                 return true;
 708             }
 709         }
 710         return false;
 711     }
 712
 713     /**
 714      * Returns true if the character at offset is right to left (RTL).
 715      * @param offset the offset
 716      * @return true if the character is RTL, false if it is LTR
 717      */
 718     public boolean isRtlCharAt(int offset) {
 719         int line = getLineForOffset(offset);
 720         Directions dirs = getLineDirections(line);
 721         if (dirs == DIRS_ALL_LEFT_TO_RIGHT) {
 722             return false;
 723         }
 724         if (dirs == DIRS_ALL_RIGHT_TO_LEFT) {
 725             return  true;
 726         }
 727         int[] runs = dirs.mDirections;
 728         int lineStart = getLineStart(line);
 729         for (int i = 0; i < runs.length; i += 2) {
 730             int start = lineStart + runs[i];
 731             int limit = start + (runs[i+1] & RUN_LENGTH_MASK);
 732             if (offset >= start && offset < limit) {
 733                 int level = (runs[i+1] >>> RUN_LEVEL_SHIFT) & RUN_LEVEL_MASK;
 734                 return ((level & 1) != 0);
 735             }
 736         }
 737         // Should happen only if the offset is "out of bounds"
 738         return false;
 739     }
 740
 741     private boolean primaryIsTrailingPrevious(int offset) {
 742         int line = getLineForOffset(offset);
 743         int lineStart = getLineStart(line);
 744         int lineEnd = getLineEnd(line);
 745         int[] runs = getLineDirections(line).mDirections;
 746
 747         int levelAt = -1;
 748         for (int i = 0; i < runs.length; i += 2) {
 749             int start = lineStart + runs[i];
 750             int limit = start + (runs[i+1] & RUN_LENGTH_MASK);
 751             if (limit > lineEnd) {
 752                 limit = lineEnd;
 753             }
 754             if (offset >= start && offset < limit) {
 755                 if (offset > start) {
 756                     // Previous character is at same level, so don't use trailing.
 757                     return false;
 758                 }
 759                 levelAt = (runs[i+1] >>> RUN_LEVEL_SHIFT) & RUN_LEVEL_MASK;
 760                 break;
 761             }
 762         }
 763         if (levelAt == -1) {
 764             // Offset was limit of line.
 765             levelAt = getParagraphDirection(line) == 1 ? 0 : 1;
 766         }
 767
 768         // At level boundary, check previous level.
 769         int levelBefore = -1;
 770         if (offset == lineStart) {
 771             levelBefore = getParagraphDirection(line) == 1 ? 0 : 1;
 772         } else {
 773             offset -= 1;
 774             for (int i = 0; i < runs.length; i += 2) {
 775                 int start = lineStart + runs[i];
 776                 int limit = start + (runs[i+1] & RUN_LENGTH_MASK);
 777                 if (limit > lineEnd) {
 778                     limit = lineEnd;
 779                 }
 780                 if (offset >= start && offset < limit) {
 781                     levelBefore = (runs[i+1] >>> RUN_LEVEL_SHIFT) & RUN_LEVEL_MASK;
 782                     break;
 783                 }
 784             }
 785         }
 786
 787         return levelBefore < levelAt;
 788     }
 789
 790     /**
 791      * Get the primary horizontal position for the specified text offset.
 792      * This is the location where a new character would be inserted in
 793      * the paragraph's primary direction.
 794      */
 795     public float getPrimaryHorizontal(int offset) {
 796         return getPrimaryHorizontal(offset, false /* not clamped */);
 797     }
 798
 799     /**
 800      * Get the primary horizontal position for the specified text offset, but
 801      * optionally clamp it so that it doesn't exceed the width of the layout.
 802      * @hide
 803      */
 804     public float getPrimaryHorizontal(int offset, boolean clamped) {
 805         boolean trailing = primaryIsTrailingPrevious(offset);
 806         return getHorizontal(offset, trailing, clamped);
 807     }
 808
 809     /**
 810      * Get the secondary horizontal position for the specified text offset.
 811      * This is the location where a new character would be inserted in
 812      * the direction other than the paragraph's primary direction.
 813      */
 814     public float getSecondaryHorizontal(int offset) {
 815         return getSecondaryHorizontal(offset, false /* not clamped */);
 816     }
 817
 818     /**
 819      * Get the secondary horizontal position for the specified text offset, but
 820      * optionally clamp it so that it doesn't exceed the width of the layout.
 821      * @hide
 822      */
 823     public float getSecondaryHorizontal(int offset, boolean clamped) {
 824         boolean trailing = primaryIsTrailingPrevious(offset);
 825         return getHorizontal(offset, !trailing, clamped);
 826     }
 827
 828     private float getHorizontal(int offset, boolean trailing, boolean clamped) {
 829         int line = getLineForOffset(offset);
 830
 831         return getHorizontal(offset, trailing, line, clamped);
 832     }
 833
 834     private float getHorizontal(int offset, boolean trailing, int line, boolean clamped) {
 835         int start = getLineStart(line);
 836         int end = getLineEnd(line);
 837         int dir = getParagraphDirection(line);
 838         boolean hasTabOrEmoji = getLineContainsTab(line);
 839         Directions directions = getLineDirections(line);
 840
 841         TabStops tabStops = null;
 842         if (hasTabOrEmoji && mText instanceof Spanned) {
 843             // Just checking this line should be good enough, tabs should be
 844             // consistent across all lines in a paragraph.
 845             TabStopSpan[] tabs = getParagraphSpans((Spanned) mText, start, end, TabStopSpan.class);
 846             if (tabs.length > 0) {
 847                 tabStops = new TabStops(TAB_INCREMENT, tabs); // XXX should reuse
 848             }
 849         }
 850
 851         TextLine tl = TextLine.obtain();
 852         tl.set(mPaint, mText, start, end, dir, directions, hasTabOrEmoji, tabStops);
 853         float wid = tl.measure(offset - start, trailing, null);
 854         TextLine.recycle(tl);
 855
 856         if (clamped && wid > mWidth) {
 857             wid = mWidth;
 858         }
 859         int left = getParagraphLeft(line);
 860         int right = getParagraphRight(line);
 861
 862         return getLineStartPos(line, left, right) + wid;
 863     }
 864
 865     /**
 866      * Get the leftmost position that should be exposed for horizontal
 867      * scrolling on the specified line.
 868      */
 869     public float getLineLeft(int line) {
 870         int dir = getParagraphDirection(line);
 871         Alignment align = getParagraphAlignment(line);
 872
 873         if (align == Alignment.ALIGN_LEFT) {
 874             return 0;
 875         } else if (align == Alignment.ALIGN_NORMAL) {
 876             if (dir == DIR_RIGHT_TO_LEFT)
 877                 return getParagraphRight(line) - getLineMax(line);
 878             else
 879                 return 0;
 880         } else if (align == Alignment.ALIGN_RIGHT) {
 881             return mWidth - getLineMax(line);
 882         } else if (align == Alignment.ALIGN_OPPOSITE) {
 883             if (dir == DIR_RIGHT_TO_LEFT)
 884                 return 0;
 885             else
 886                 return mWidth - getLineMax(line);
 887         } else { /* align == Alignment.ALIGN_CENTER */
 888             int left = getParagraphLeft(line);
 889             int right = getParagraphRight(line);
 890             int max = ((int) getLineMax(line)) & ~1;
 891
 892             return left + ((right - left) - max) / 2;
 893         }
 894     }
 895
 896     /**
 897      * Get the rightmost position that should be exposed for horizontal
 898      * scrolling on the specified line.
 899      */
 900     public float getLineRight(int line) {
 901         int dir = getParagraphDirection(line);
 902         Alignment align = getParagraphAlignment(line);
 903
 904         if (align == Alignment.ALIGN_LEFT) {
 905             return getParagraphLeft(line) + getLineMax(line);
 906         } else if (align == Alignment.ALIGN_NORMAL) {
 907             if (dir == DIR_RIGHT_TO_LEFT)
 908                 return mWidth;
 909             else
 910                 return getParagraphLeft(line) + getLineMax(line);
 911         } else if (align == Alignment.ALIGN_RIGHT) {
 912             return mWidth;
 913         } else if (align == Alignment.ALIGN_OPPOSITE) {
 914             if (dir == DIR_RIGHT_TO_LEFT)
 915                 return getLineMax(line);
 916             else
 917                 return mWidth;
 918         } else { /* align == Alignment.ALIGN_CENTER */
 919             int left = getParagraphLeft(line);
 920             int right = getParagraphRight(line);
 921             int max = ((int) getLineMax(line)) & ~1;
 922
 923             return right - ((right - left) - max) / 2;
 924         }
 925     }
 926
 927     /**
 928      * Gets the unsigned horizontal extent of the specified line, including
 929      * leading margin indent, but excluding trailing whitespace.
 930      */
 931     public float getLineMax(int line) {
 932         float margin = getParagraphLeadingMargin(line);
 933         float signedExtent = getLineExtent(line, false);
 934         return margin + (signedExtent >= 0 ? signedExtent : -signedExtent);
 935     }
 936
 937     /**
 938      * Gets the unsigned horizontal extent of the specified line, including
 939      * leading margin indent and trailing whitespace.
 940      */
 941     public float getLineWidth(int line) {
 942         float margin = getParagraphLeadingMargin(line);
 943         float signedExtent = getLineExtent(line, true);
 944         return margin + (signedExtent >= 0 ? signedExtent : -signedExtent);
 945     }
 946
 947     /**
 948      * Like {@link #getLineExtent(int,TabStops,boolean)} but determines the
 949      * tab stops instead of using the ones passed in.
 950      * @param line the index of the line
 951      * @param full whether to include trailing whitespace
 952      * @return the extent of the line
 953      */
 954     private float getLineExtent(int line, boolean full) {
 955         int start = getLineStart(line);
 956         int end = full ? getLineEnd(line) : getLineVisibleEnd(line);
 957
 958         boolean hasTabsOrEmoji = getLineContainsTab(line);
 959         TabStops tabStops = null;
 960         if (hasTabsOrEmoji && mText instanceof Spanned) {
 961             // Just checking this line should be good enough, tabs should be
 962             // consistent across all lines in a paragraph.
 963             TabStopSpan[] tabs = getParagraphSpans((Spanned) mText, start, end, TabStopSpan.class);
 964             if (tabs.length > 0) {
 965                 tabStops = new TabStops(TAB_INCREMENT, tabs); // XXX should reuse
 966             }
 967         }
 968         Directions directions = getLineDirections(line);
 969         // Returned directions can actually be null
 970         if (directions == null) {
 971             return 0f;
 972         }
 973         int dir = getParagraphDirection(line);
 974
 975         TextLine tl = TextLine.obtain();
 976         tl.set(mPaint, mText, start, end, dir, directions, hasTabsOrEmoji, tabStops);
 977         float width = tl.metrics(null);
 978         TextLine.recycle(tl);
 979         return width;
 980     }
 981
 982     /**
 983      * Returns the signed horizontal extent of the specified line, excluding
 984      * leading margin.  If full is false, excludes trailing whitespace.
 985      * @param line the index of the line
 986      * @param tabStops the tab stops, can be null if we know they're not used.
 987      * @param full whether to include trailing whitespace
 988      * @return the extent of the text on this line
 989      */
 990     private float getLineExtent(int line, TabStops tabStops, boolean full) {
 991         int start = getLineStart(line);
 992         int end = full ? getLineEnd(line) : getLineVisibleEnd(line);
 993         boolean hasTabsOrEmoji = getLineContainsTab(line);
 994         Directions directions = getLineDirections(line);
 995         int dir = getParagraphDirection(line);
 996
 997         TextLine tl = TextLine.obtain();
 998         tl.set(mPaint, mText, start, end, dir, directions, hasTabsOrEmoji, tabStops);
 999         float width = tl.metrics(null);
1000         TextLine.recycle(tl);
1001         return width;
1002     }
1003
1004     /**
1005      * Get the line number corresponding to the specified vertical position.
1006      * If you ask for a position above 0, you get 0; if you ask for a position
1007      * below the bottom of the text, you get the last line.
1008      */
1009     // FIXME: It may be faster to do a linear search for layouts without many lines.
1010     public int getLineForVertical(int vertical) {
1011         int high = getLineCount(), low = -1, guess;
1012
1013         while (high - low > 1) {
1014             guess = (high + low) / 2;
1015
1016             if (getLineTop(guess) > vertical)
1017                 high = guess;
1018             else
1019                 low = guess;
1020         }
1021
1022         if (low < 0)
1023             return 0;
1024         else
1025             return low;
1026     }
1027
1028     /**
1029      * Get the line number on which the specified text offset appears.
1030      * If you ask for a position before 0, you get 0; if you ask for a position
1031      * beyond the end of the text, you get the last line.
1032      */
1033     public int getLineForOffset(int offset) {
1034         int high = getLineCount(), low = -1, guess;
1035
1036         while (high - low > 1) {
1037             guess = (high + low) / 2;
1038
1039             if (getLineStart(guess) > offset)
1040                 high = guess;
1041             else
1042                 low = guess;
1043         }
1044
1045         if (low < 0)
1046             return 0;
1047         else
1048             return low;
1049     }
1050
1051     /**
1052      * Get the character offset on the specified line whose position is
1053      * closest to the specified horizontal position.
1054      */
1055     public int getOffsetForHorizontal(int line, float horiz) {
1056         int max = getLineEnd(line) - 1;
1057         int min = getLineStart(line);
1058         Directions dirs = getLineDirections(line);
1059
1060         if (line == getLineCount() - 1)
1061             max++;
1062
1063         int best = min;
1064         float bestdist = Math.abs(getPrimaryHorizontal(best) - horiz);
1065
1066         for (int i = 0; i < dirs.mDirections.length; i += 2) {
1067             int here = min + dirs.mDirections[i];
1068             int there = here + (dirs.mDirections[i+1] & RUN_LENGTH_MASK);
1069             int swap = (dirs.mDirections[i+1] & RUN_RTL_FLAG) != 0 ? -1 : 1;
1070
1071             if (there > max)
1072                 there = max;
1073             int high = there - 1 + 1, low = here + 1 - 1, guess;
1074
1075             while (high - low > 1) {
1076                 guess = (high + low) / 2;
1077                 int adguess = getOffsetAtStartOf(guess);
1078
1079                 if (getPrimaryHorizontal(adguess) * swap >= horiz * swap)
1080                     high = guess;
1081                 else
1082                     low = guess;
1083             }
1084
1085             if (low < here + 1)
1086                 low = here + 1;
1087
1088             if (low < there) {
1089                 low = getOffsetAtStartOf(low);
1090
1091                 float dist = Math.abs(getPrimaryHorizontal(low) - horiz);
1092
1093                 int aft = TextUtils.getOffsetAfter(mText, low);
1094                 if (aft < there) {
1095                     float other = Math.abs(getPrimaryHorizontal(aft) - horiz);
1096
1097                     if (other < dist) {
1098                         dist = other;
1099                         low = aft;
1100                     }
1101                 }
1102
1103                 if (dist < bestdist) {
1104                     bestdist = dist;
1105                     best = low;
1106                 }
1107             }
1108
1109             float dist = Math.abs(getPrimaryHorizontal(here) - horiz);
1110
1111             if (dist < bestdist) {
1112                 bestdist = dist;
1113                 best = here;
1114             }
1115         }
1116
1117         float dist = Math.abs(getPrimaryHorizontal(max) - horiz);
1118
1119         if (dist <= bestdist) {
1120             bestdist = dist;
1121             best = max;
1122         }
1123
1124         return best;
1125     }
1126
1127     /**
1128      * Return the text offset after the last character on the specified line.
1129      */
1130     public final int getLineEnd(int line) {
1131         return getLineStart(line + 1);
1132     }
1133
1134     /**
1135      * Return the text offset after the last visible character (so whitespace
1136      * is not counted) on the specified line.
1137      */
1138     public int getLineVisibleEnd(int line) {
1139         return getLineVisibleEnd(line, getLineStart(line), getLineStart(line+1));
1140     }
1141
1142     private int getLineVisibleEnd(int line, int start, int end) {
1143         CharSequence text = mText;
1144         char ch;
1145         if (line == getLineCount() - 1) {
1146             return end;
1147         }
1148
1149         for (; end > start; end--) {
1150             ch = text.charAt(end - 1);
1151
1152             if (ch == '\n') {
1153                 return end - 1;
1154             }
1155
1156             if (ch != ' ' && ch != '\t') {
1157                 break;
1158             }
1159
1160         }
1161
1162         return end;
1163     }
1164
1165     /**
1166      * Return the vertical position of the bottom of the specified line.
1167      */
1168     public final int getLineBottom(int line) {
1169         return getLineTop(line + 1);
1170     }
1171
1172     /**
1173      * Return the vertical position of the baseline of the specified line.
1174      */
1175     public final int getLineBaseline(int line) {
1176         // getLineTop(line+1) == getLineTop(line)
1177         return getLineTop(line+1) - getLineDescent(line);
1178     }
1179
1180     /**
1181      * Get the ascent of the text on the specified line.
1182      * The return value is negative to match the Paint.ascent() convention.
1183      */
1184     public final int getLineAscent(int line) {
1185         // getLineTop(line+1) - getLineDescent(line) == getLineBaseLine(line)
1186         return getLineTop(line) - (getLineTop(line+1) - getLineDescent(line));
1187     }
1188
1189     public int getOffsetToLeftOf(int offset) {
1190         return getOffsetToLeftRightOf(offset, true);
1191     }
1192
1193     public int getOffsetToRightOf(int offset) {
1194         return getOffsetToLeftRightOf(offset, false);
1195     }
1196
1197     private int getOffsetToLeftRightOf(int caret, boolean toLeft) {
1198         int line = getLineForOffset(caret);
1199         int lineStart = getLineStart(line);
1200         int lineEnd = getLineEnd(line);
1201         int lineDir = getParagraphDirection(line);
1202
1203         boolean lineChanged = false;
1204         boolean advance = toLeft == (lineDir == DIR_RIGHT_TO_LEFT);
1205         // if walking off line, look at the line we're headed to
1206         if (advance) {
1207             if (caret == lineEnd) {
1208                 if (line < getLineCount() - 1) {
1209                     lineChanged = true;
1210                     ++line;
1211                 } else {
1212                     return caret; // at very end, don't move
1213                 }
1214             }
1215         } else {
1216             if (caret == lineStart) {
1217                 if (line > 0) {
1218                     lineChanged = true;
1219                     --line;
1220                 } else {
1221                     return caret; // at very start, don't move
1222                 }
1223             }
1224         }
1225
1226         if (lineChanged) {
1227             lineStart = getLineStart(line);
1228             lineEnd = getLineEnd(line);
1229             int newDir = getParagraphDirection(line);
1230             if (newDir != lineDir) {
1231                 // unusual case.  we want to walk onto the line, but it runs
1232                 // in a different direction than this one, so we fake movement
1233                 // in the opposite direction.
1234                 toLeft = !toLeft;
1235                 lineDir = newDir;
1236             }
1237         }
1238
1239         Directions directions = getLineDirections(line);
1240
1241         TextLine tl = TextLine.obtain();
1242         // XXX: we don't care about tabs
1243         tl.set(mPaint, mText, lineStart, lineEnd, lineDir, directions, false, null);
1244         caret = lineStart + tl.getOffsetToLeftRightOf(caret - lineStart, toLeft);
1245         tl = TextLine.recycle(tl);
1246         return caret;
1247     }
1248
1249     private int getOffsetAtStartOf(int offset) {
1250         // XXX this probably should skip local reorderings and
1251         // zero-width characters, look at callers
1252         if (offset == 0)
1253             return 0;
1254
1255         CharSequence text = mText;
1256         char c = text.charAt(offset);
1257
1258         if (c >= '\uDC00' && c <= '\uDFFF') {
1259             char c1 = text.charAt(offset - 1);
1260
1261             if (c1 >= '\uD800' && c1 <= '\uDBFF')
1262                 offset -= 1;
1263         }
1264
1265         if (mSpannedText) {
1266             ReplacementSpan[] spans = ((Spanned) text).getSpans(offset, offset,
1267                                                        ReplacementSpan.class);
1268
1269             for (int i = 0; i < spans.length; i++) {
1270                 int start = ((Spanned) text).getSpanStart(spans[i]);
1271                 int end = ((Spanned) text).getSpanEnd(spans[i]);
1272
1273                 if (start < offset && end > offset)
1274                     offset = start;
1275             }
1276         }
1277
1278         return offset;
1279     }
1280
1281     /**
1282      * Determine whether we should clamp cursor position. Currently it's
1283      * only robust for left-aligned displays.
1284      * @hide
1285      */
1286     public boolean shouldClampCursor(int line) {
1287         // Only clamp cursor position in left-aligned displays.
1288         switch (getParagraphAlignment(line)) {
1289             case ALIGN_LEFT:
1290                 return true;
1291             case ALIGN_NORMAL:
1292                 return getParagraphDirection(line) > 0;
1293             default:
1294                 return false;
1295         }
1296
1297     }
1298     /**
1299      * Fills in the specified Path with a representation of a cursor
1300      * at the specified offset.  This will often be a vertical line
1301      * but can be multiple discontinuous lines in text with multiple
1302      * directionalities.
1303      */
1304     public void getCursorPath(int point, Path dest,
1305                               CharSequence editingBuffer) {
1306         dest.reset();
1307
1308         int line = getLineForOffset(point);
1309         int top = getLineTop(line);
1310         int bottom = getLineTop(line+1);
1311
1312         boolean clamped = shouldClampCursor(line);
1313         float h1 = getPrimaryHorizontal(point, clamped) - 0.5f;
1314         float h2 = isLevelBoundary(point) ? getSecondaryHorizontal(point, clamped) - 0.5f : h1;
1315
1316         int caps = TextKeyListener.getMetaState(editingBuffer, TextKeyListener.META_SHIFT_ON) |
1317                    TextKeyListener.getMetaState(editingBuffer, TextKeyListener.META_SELECTING);
1318         int fn = TextKeyListener.getMetaState(editingBuffer, TextKeyListener.META_ALT_ON);
1319         int dist = 0;
1320
1321         if (caps != 0 || fn != 0) {
1322             dist = (bottom - top) >> 2;
1323
1324             if (fn != 0)
1325                 top += dist;
1326             if (caps != 0)
1327                 bottom -= dist;
1328         }
1329
1330         if (h1 < 0.5f)
1331             h1 = 0.5f;
1332         if (h2 < 0.5f)
1333             h2 = 0.5f;
1334
1335         if (Float.compare(h1, h2) == 0) {
1336             dest.moveTo(h1, top);
1337             dest.lineTo(h1, bottom);
1338         } else {
1339             dest.moveTo(h1, top);
1340             dest.lineTo(h1, (top + bottom) >> 1);
1341
1342             dest.moveTo(h2, (top + bottom) >> 1);
1343             dest.lineTo(h2, bottom);
1344         }
1345
1346         if (caps == 2) {
1347             dest.moveTo(h2, bottom);
1348             dest.lineTo(h2 - dist, bottom + dist);
1349             dest.lineTo(h2, bottom);
1350             dest.lineTo(h2 + dist, bottom + dist);
1351         } else if (caps == 1) {
1352             dest.moveTo(h2, bottom);
1353             dest.lineTo(h2 - dist, bottom + dist);
1354
1355             dest.moveTo(h2 - dist, bottom + dist - 0.5f);
1356             dest.lineTo(h2 + dist, bottom + dist - 0.5f);
1357
1358             dest.moveTo(h2 + dist, bottom + dist);
1359             dest.lineTo(h2, bottom);
1360         }
1361
1362         if (fn == 2) {
1363             dest.moveTo(h1, top);
1364             dest.lineTo(h1 - dist, top - dist);
1365             dest.lineTo(h1, top);
1366             dest.lineTo(h1 + dist, top - dist);
1367         } else if (fn == 1) {
1368             dest.moveTo(h1, top);
1369             dest.lineTo(h1 - dist, top - dist);
1370
1371             dest.moveTo(h1 - dist, top - dist + 0.5f);
1372             dest.lineTo(h1 + dist, top - dist + 0.5f);
1373
1374             dest.moveTo(h1 + dist, top - dist);
1375             dest.lineTo(h1, top);
1376         }
1377     }
1378
1379     private void addSelection(int line, int start, int end,
1380                               int top, int bottom, Path dest) {
1381         int linestart = getLineStart(line);
1382         int lineend = getLineEnd(line);
1383         Directions dirs = getLineDirections(line);
1384
1385         if (lineend > linestart && mText.charAt(lineend - 1) == '\n')
1386             lineend--;
1387
1388         for (int i = 0; i < dirs.mDirections.length; i += 2) {
1389             int here = linestart + dirs.mDirections[i];
1390             int there = here + (dirs.mDirections[i+1] & RUN_LENGTH_MASK);
1391
1392             if (there > lineend)
1393                 there = lineend;
1394
1395             if (start <= there && end >= here) {
1396                 int st = Math.max(start, here);
1397                 int en = Math.min(end, there);
1398
1399                 if (st != en) {
1400                     float h1 = getHorizontal(st, false, line, false /* not clamped */);
1401                     float h2 = getHorizontal(en, true, line, false /* not clamped */);
1402
1403                     float left = Math.min(h1, h2);
1404                     float right = Math.max(h1, h2);
1405
1406                     dest.addRect(left, top, right, bottom, Path.Direction.CW);
1407                 }
1408             }
1409         }
1410     }
1411
1412     /**
1413      * Fills in the specified Path with a representation of a highlight
1414      * between the specified offsets.  This will often be a rectangle
1415      * or a potentially discontinuous set of rectangles.  If the start
1416      * and end are the same, the returned path is empty.
1417      */
1418     public void getSelectionPath(int start, int end, Path dest) {
1419         dest.reset();
1420
1421         if (start == end)
1422             return;
1423
1424         if (end < start) {
1425             int temp = end;
1426             end = start;
1427             start = temp;
1428         }
1429
1430         int startline = getLineForOffset(start);
1431         int endline = getLineForOffset(end);
1432
1433         int top = getLineTop(startline);
1434         int bottom = getLineBottom(endline);
1435
1436         if (startline == endline) {
1437             addSelection(startline, start, end, top, bottom, dest);
1438         } else {
1439             final float width = mWidth;
1440
1441             addSelection(startline, start, getLineEnd(startline),
1442                          top, getLineBottom(startline), dest);
1443
1444             if (getParagraphDirection(startline) == DIR_RIGHT_TO_LEFT)
1445                 dest.addRect(getLineLeft(startline), top,
1446                               0, getLineBottom(startline), Path.Direction.CW);
1447             else
1448                 dest.addRect(getLineRight(startline), top,
1449                               width, getLineBottom(startline), Path.Direction.CW);
1450
1451             for (int i = startline + 1; i < endline; i++) {
1452                 top = getLineTop(i);
1453                 bottom = getLineBottom(i);
1454                 dest.addRect(0, top, width, bottom, Path.Direction.CW);
1455             }
1456
1457             top = getLineTop(endline);
1458             bottom = getLineBottom(endline);
1459
1460             addSelection(endline, getLineStart(endline), end,
1461                          top, bottom, dest);
1462
1463             if (getParagraphDirection(endline) == DIR_RIGHT_TO_LEFT)
1464                 dest.addRect(width, top, getLineRight(endline), bottom, Path.Direction.CW);
1465             else
1466                 dest.addRect(0, top, getLineLeft(endline), bottom, Path.Direction.CW);
1467         }
1468     }
1469
1470     /**
1471      * Get the alignment of the specified paragraph, taking into account
1472      * markup attached to it.
1473      */
1474     public final Alignment getParagraphAlignment(int line) {
1475         Alignment align = mAlignment;
1476
1477         if (mSpannedText) {
1478             Spanned sp = (Spanned) mText;
1479             AlignmentSpan[] spans = getParagraphSpans(sp, getLineStart(line),
1480                                                 getLineEnd(line),
1481                                                 AlignmentSpan.class);
1482
1483             int spanLength = spans.length;
1484             if (spanLength > 0) {
1485                 align = spans[spanLength-1].getAlignment();
1486             }
1487         }
1488
1489         return align;
1490     }
1491
1492     /**
1493      * Get the left edge of the specified paragraph, inset by left margins.
1494      */
1495     public final int getParagraphLeft(int line) {
1496         int left = 0;
1497         int dir = getParagraphDirection(line);
1498         if (dir == DIR_RIGHT_TO_LEFT || !mSpannedText) {
1499             return left; // leading margin has no impact, or no styles
1500         }
1501         return getParagraphLeadingMargin(line);
1502     }
1503
1504     /**
1505      * Get the right edge of the specified paragraph, inset by right margins.
1506      */
1507     public final int getParagraphRight(int line) {
1508         int right = mWidth;
1509         int dir = getParagraphDirection(line);
1510         if (dir == DIR_LEFT_TO_RIGHT || !mSpannedText) {
1511             return right; // leading margin has no impact, or no styles
1512         }
1513         return right - getParagraphLeadingMargin(line);
1514     }
1515
1516     /**
1517      * Returns the effective leading margin (unsigned) for this line,
1518      * taking into account LeadingMarginSpan and LeadingMarginSpan2.
1519      * @param line the line index
1520      * @return the leading margin of this line
1521      */
1522     private int getParagraphLeadingMargin(int line) {
1523         if (!mSpannedText) {
1524             return 0;
1525         }
1526         Spanned spanned = (Spanned) mText;
1527
1528         int lineStart = getLineStart(line);
1529         int lineEnd = getLineEnd(line);
1530         int spanEnd = spanned.nextSpanTransition(lineStart, lineEnd,
1531                 LeadingMarginSpan.class);
1532         LeadingMarginSpan[] spans = getParagraphSpans(spanned, lineStart, spanEnd,
1533                                                 LeadingMarginSpan.class);
1534         if (spans.length == 0) {
1535             return 0; // no leading margin span;
1536         }
1537
1538         int margin = 0;
1539
1540         boolean isFirstParaLine = lineStart == 0 ||
1541             spanned.charAt(lineStart - 1) == '\n';
1542
1543         boolean useFirstLineMargin = isFirstParaLine;
1544         for (int i = 0; i < spans.length; i++) {
1545             if (spans[i] instanceof LeadingMarginSpan2) {
1546                 int spStart = spanned.getSpanStart(spans[i]);
1547                 int spanLine = getLineForOffset(spStart);
1548                 int count = ((LeadingMarginSpan2) spans[i]).getLeadingMarginLineCount();
1549                 // if there is more than one LeadingMarginSpan2, use the count that is greatest
1550                 useFirstLineMargin |= line < spanLine + count;
1551             }
1552         }
1553         for (int i = 0; i < spans.length; i++) {
1554             LeadingMarginSpan span = spans[i];
1555             margin += span.getLeadingMargin(useFirstLineMargin);
1556         }
1557
1558         return margin;
1559     }
1560
1561     /* package */
1562     static float measurePara(TextPaint paint, CharSequence text, int start, int end) {
1563
1564         MeasuredText mt = MeasuredText.obtain();
1565         TextLine tl = TextLine.obtain();
1566         try {
1567             mt.setPara(text, start, end, TextDirectionHeuristics.LTR);
1568             Directions directions;
1569             int dir;
1570             if (mt.mEasy) {
1571                 directions = DIRS_ALL_LEFT_TO_RIGHT;
1572                 dir = Layout.DIR_LEFT_TO_RIGHT;
1573             } else {
1574                 directions = AndroidBidi.directions(mt.mDir, mt.mLevels,
1575                     0, mt.mChars, 0, mt.mLen);
1576                 dir = mt.mDir;
1577             }
1578             char[] chars = mt.mChars;
1579             int len = mt.mLen;
1580             boolean hasTabs = false;
1581             TabStops tabStops = null;
1582             // leading margins should be taken into account when measuring a paragraph
1583             int margin = 0;
1584             if (text instanceof Spanned) {
1585                 Spanned spanned = (Spanned) text;
1586                 LeadingMarginSpan[] spans = getParagraphSpans(spanned, start, end,
1587                         LeadingMarginSpan.class);
1588                 for (LeadingMarginSpan lms : spans) {
1589                     margin += lms.getLeadingMargin(true);
1590                 }
1591             }
1592             for (int i = 0; i < len; ++i) {
1593                 if (chars[i] == '\t') {
1594                     hasTabs = true;
1595                     if (text instanceof Spanned) {
1596                         Spanned spanned = (Spanned) text;
1597                         int spanEnd = spanned.nextSpanTransition(start, end,
1598                                 TabStopSpan.class);
1599                         TabStopSpan[] spans = getParagraphSpans(spanned, start, spanEnd,
1600                                 TabStopSpan.class);
1601                         if (spans.length > 0) {
1602                             tabStops = new TabStops(TAB_INCREMENT, spans);
1603                         }
1604                     }
1605                     break;
1606                 }
1607             }
1608             tl.set(paint, text, start, end, dir, directions, hasTabs, tabStops);
1609             return margin + tl.metrics(null);
1610         } finally {
1611             TextLine.recycle(tl);
1612             MeasuredText.recycle(mt);
1613         }
1614     }
1615
1616     /**
1617      * @hide
1618      */
1619     /* package */ static class TabStops {
1620         private int[] mStops;
1621         private int mNumStops;
1622         private int mIncrement;
1623
1624         TabStops(int increment, Object[] spans) {
1625             reset(increment, spans);
1626         }
1627
1628         void reset(int increment, Object[] spans) {
1629             this.mIncrement = increment;
1630
1631             int ns = 0;
1632             if (spans != null) {
1633                 int[] stops = this.mStops;
1634                 for (Object o : spans) {
1635                     if (o instanceof TabStopSpan) {
1636                         if (stops == null) {
1637                             stops = new int[10];
1638                         } else if (ns == stops.length) {
1639                             int[] nstops = new int[ns * 2];
1640                             for (int i = 0; i < ns; ++i) {
1641                                 nstops[i] = stops[i];
1642                             }
1643                             stops = nstops;
1644                         }
1645                         stops[ns++] = ((TabStopSpan) o).getTabStop();
1646                     }
1647                 }
1648                 if (ns > 1) {
1649                     Arrays.sort(stops, 0, ns);
1650                 }
1651                 if (stops != this.mStops) {
1652                     this.mStops = stops;
1653                 }
1654             }
1655             this.mNumStops = ns;
1656         }
1657
1658         float nextTab(float h) {
1659             int ns = this.mNumStops;
1660             if (ns > 0) {
1661                 int[] stops = this.mStops;
1662                 for (int i = 0; i < ns; ++i) {
1663                     int stop = stops[i];
1664                     if (stop > h) {
1665                         return stop;
1666                     }
1667                 }
1668             }
1669             return nextDefaultStop(h, mIncrement);
1670         }
1671
1672         public static float nextDefaultStop(float h, int inc) {
1673             return ((int) ((h + inc) / inc)) * inc;
1674         }
1675     }
1676
1677     /**
1678      * Returns the position of the next tab stop after h on the line.
1679      *
1680      * @param text the text
1681      * @param start start of the line
1682      * @param end limit of the line
1683      * @param h the current horizontal offset
1684      * @param tabs the tabs, can be null.  If it is null, any tabs in effect
1685      * on the line will be used.  If there are no tabs, a default offset
1686      * will be used to compute the tab stop.
1687      * @return the offset of the next tab stop.
1688      */
1689     /* package */ static float nextTab(CharSequence text, int start, int end,
1690                                        float h, Object[] tabs) {
1691         float nh = Float.MAX_VALUE;
1692         boolean alltabs = false;
1693
1694         if (text instanceof Spanned) {
1695             if (tabs == null) {
1696                 tabs = getParagraphSpans((Spanned) text, start, end, TabStopSpan.class);
1697                 alltabs = true;
1698             }
1699
1700             for (int i = 0; i < tabs.length; i++) {
1701                 if (!alltabs) {
1702                     if (!(tabs[i] instanceof TabStopSpan))
1703                         continue;
1704                 }
1705
1706                 int where = ((TabStopSpan) tabs[i]).getTabStop();
1707
1708                 if (where < nh && where > h)
1709                     nh = where;
1710             }
1711
1712             if (nh != Float.MAX_VALUE)
1713                 return nh;
1714         }
1715
1716         return ((int) ((h + TAB_INCREMENT) / TAB_INCREMENT)) * TAB_INCREMENT;
1717     }
1718
1719     protected final boolean isSpanned() {
1720         return mSpannedText;
1721     }
1722
1723     /**
1724      * Returns the same as <code>text.getSpans()</code>, except where
1725      * <code>start</code> and <code>end</code> are the same and are not
1726      * at the very beginning of the text, in which case an empty array
1727      * is returned instead.
1728      * <p>
1729      * This is needed because of the special case that <code>getSpans()</code>
1730      * on an empty range returns the spans adjacent to that range, which is
1731      * primarily for the sake of <code>TextWatchers</code> so they will get
1732      * notifications when text goes from empty to non-empty.  But it also
1733      * has the unfortunate side effect that if the text ends with an empty
1734      * paragraph, that paragraph accidentally picks up the styles of the
1735      * preceding paragraph (even though those styles will not be picked up
1736      * by new text that is inserted into the empty paragraph).
1737      * <p>
1738      * The reason it just checks whether <code>start</code> and <code>end</code>
1739      * is the same is that the only time a line can contain 0 characters
1740      * is if it is the final paragraph of the Layout; otherwise any line will
1741      * contain at least one printing or newline character.  The reason for the
1742      * additional check if <code>start</code> is greater than 0 is that
1743      * if the empty paragraph is the entire content of the buffer, paragraph
1744      * styles that are already applied to the buffer will apply to text that
1745      * is inserted into it.
1746      */
1747     /* package */static <T> T[] getParagraphSpans(Spanned text, int start, int end, Class<T> type) {
1748         if (start == end && start > 0) {
1749             return ArrayUtils.emptyArray(type);
1750         }
1751
1752         return text.getSpans(start, end, type);
1753     }
1754
1755     private char getEllipsisChar(TextUtils.TruncateAt method) {
1756         return (method == TextUtils.TruncateAt.END_SMALL) ?
1757                 ELLIPSIS_TWO_DOTS[0] :
1758                 ELLIPSIS_NORMAL[0];
1759     }
1760
1761     private void ellipsize(int start, int end, int line,
1762                            char[] dest, int destoff, TextUtils.TruncateAt method) {
1763         int ellipsisCount = getEllipsisCount(line);
1764
1765         if (ellipsisCount == 0) {
1766             return;
1767         }
1768
1769         int ellipsisStart = getEllipsisStart(line);
1770         int linestart = getLineStart(line);
1771
1772         for (int i = ellipsisStart; i < ellipsisStart + ellipsisCount; i++) {
1773             char c;
1774
1775             if (i == ellipsisStart) {
1776                 c = getEllipsisChar(method); // ellipsis
1777             } else {
1778                 c = '\uFEFF'; // 0-width space
1779             }
1780
1781             int a = i + linestart;
1782
1783             if (a >= start && a < end) {
1784                 dest[destoff + a - start] = c;
1785             }
1786         }
1787     }
1788
1789     /**
1790      * Stores information about bidirectional (left-to-right or right-to-left)
1791      * text within the layout of a line.
1792      */
1793     public static class Directions {
1794         // Directions represents directional runs within a line of text.
1795         // Runs are pairs of ints listed in visual order, starting from the
1796         // leading margin.  The first int of each pair is the offset from
1797         // the first character of the line to the start of the run.  The
1798         // second int represents both the length and level of the run.
1799         // The length is in the lower bits, accessed by masking with
1800         // DIR_LENGTH_MASK.  The level is in the higher bits, accessed
1801         // by shifting by DIR_LEVEL_SHIFT and masking by DIR_LEVEL_MASK.
1802         // To simply test for an RTL direction, test the bit using
1803         // DIR_RTL_FLAG, if set then the direction is rtl.
1804
1805         /* package */ int[] mDirections;
1806         /* package */ Directions(int[] dirs) {
1807             mDirections = dirs;
1808         }
1809     }
1810
1811     /**
1812      * Return the offset of the first character to be ellipsized away,
1813      * relative to the start of the line.  (So 0 if the beginning of the
1814      * line is ellipsized, not getLineStart().)
1815      */
1816     public abstract int getEllipsisStart(int line);
1817
1818     /**
1819      * Returns the number of characters to be ellipsized away, or 0 if
1820      * no ellipsis is to take place.
1821      */
1822     public abstract int getEllipsisCount(int line);
1823
1824     /* package */ static class Ellipsizer implements CharSequence, GetChars {
1825         /* package */ CharSequence mText;
1826         /* package */ Layout mLayout;
1827         /* package */ int mWidth;
1828         /* package */ TextUtils.TruncateAt mMethod;
1829
1830         public Ellipsizer(CharSequence s) {
1831             mText = s;
1832         }
1833
1834         public char charAt(int off) {
1835             char[] buf = TextUtils.obtain(1);
1836             getChars(off, off + 1, buf, 0);
1837             char ret = buf[0];
1838
1839             TextUtils.recycle(buf);
1840             return ret;
1841         }
1842
1843         public void getChars(int start, int end, char[] dest, int destoff) {
1844             int line1 = mLayout.getLineForOffset(start);
1845             int line2 = mLayout.getLineForOffset(end);
1846
1847             TextUtils.getChars(mText, start, end, dest, destoff);
1848
1849             for (int i = line1; i <= line2; i++) {
1850                 mLayout.ellipsize(start, end, i, dest, destoff, mMethod);
1851             }
1852         }
1853
1854         public int length() {
1855             return mText.length();
1856         }
1857
1858         public CharSequence subSequence(int start, int end) {
1859             char[] s = new char[end - start];
1860             getChars(start, end, s, 0);
1861             return new String(s);
1862         }
1863
1864         @Override
1865         public String toString() {
1866             char[] s = new char[length()];
1867             getChars(0, length(), s, 0);
1868             return new String(s);
1869         }
1870
1871     }
1872
1873     /* package */ static class SpannedEllipsizer extends Ellipsizer implements Spanned {
1874         private Spanned mSpanned;
1875
1876         public SpannedEllipsizer(CharSequence display) {
1877             super(display);
1878             mSpanned = (Spanned) display;
1879         }
1880
1881         public <T> T[] getSpans(int start, int end, Class<T> type) {
1882             return mSpanned.getSpans(start, end, type);
1883         }
1884
1885         public int getSpanStart(Object tag) {
1886             return mSpanned.getSpanStart(tag);
1887         }
1888
1889         public int getSpanEnd(Object tag) {
1890             return mSpanned.getSpanEnd(tag);
1891         }
1892
1893         public int getSpanFlags(Object tag) {
1894             return mSpanned.getSpanFlags(tag);
1895         }
1896
1897         @SuppressWarnings("rawtypes")
1898         public int nextSpanTransition(int start, int limit, Class type) {
1899             return mSpanned.nextSpanTransition(start, limit, type);
1900         }
1901
1902         @Override
1903         public CharSequence subSequence(int start, int end) {
1904             char[] s = new char[end - start];
1905             getChars(start, end, s, 0);
1906
1907             SpannableString ss = new SpannableString(new String(s));
1908             TextUtils.copySpansFrom(mSpanned, start, end, Object.class, ss, 0);
1909             return ss;
1910         }
1911     }
1912
1913     private CharSequence mText;
1914     private TextPaint mPaint;
1915     /* package */ TextPaint mWorkPaint;
1916     private int mWidth;
1917     private Alignment mAlignment = Alignment.ALIGN_NORMAL;
1918     private float mSpacingMult;
1919     private float mSpacingAdd;
1920     private static final Rect sTempRect = new Rect();
1921     private boolean mSpannedText;
1922     private TextDirectionHeuristic mTextDir;
1923     private SpanSet<LineBackgroundSpan> mLineBackgroundSpans;
1924
1925     public static final int DIR_LEFT_TO_RIGHT = 1;
1926     public static final int DIR_RIGHT_TO_LEFT = -1;
1927
1928     /* package */ static final int DIR_REQUEST_LTR = 1;
1929     /* package */ static final int DIR_REQUEST_RTL = -1;
1930     /* package */ static final int DIR_REQUEST_DEFAULT_LTR = 2;
1931     /* package */ static final int DIR_REQUEST_DEFAULT_RTL = -2;
1932
1933     /* package */ static final int RUN_LENGTH_MASK = 0x03ffffff;
1934     /* package */ static final int RUN_LEVEL_SHIFT = 26;
1935     /* package */ static final int RUN_LEVEL_MASK = 0x3f;
1936     /* package */ static final int RUN_RTL_FLAG = 1 << RUN_LEVEL_SHIFT;
1937
1938     public enum Alignment {
1939         ALIGN_NORMAL,
1940         ALIGN_OPPOSITE,
1941         ALIGN_CENTER,
1942         /** @hide */
1943         ALIGN_LEFT,
1944         /** @hide */
1945         ALIGN_RIGHT,
1946     }
1947
1948     private static final int TAB_INCREMENT = 20;
1949
1950     /* package */ static final Directions DIRS_ALL_LEFT_TO_RIGHT =
1951         new Directions(new int[] { 0, RUN_LENGTH_MASK });
1952     /* package */ static final Directions DIRS_ALL_RIGHT_TO_LEFT =
1953         new Directions(new int[] { 0, RUN_LENGTH_MASK | RUN_RTL_FLAG });
1954
1955     /* package */ static final char[] ELLIPSIS_NORMAL = { '\u2026' }; // this is "..."
1956     /* package */ static final char[] ELLIPSIS_TWO_DOTS = { '\u2025' }; // this is ".."
1957 }