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