1679 lines
67 KiB
Java
1679 lines
67 KiB
Java
|
/*
|
||
|
|
* Copyright (C) 2006 The Android Open Source Project
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
* you may not use this file except in compliance with the License.
|
||
|
|
* You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*/
|
||
|
|
|
||
|
|
package android.text;
|
||
|
|
|
||
|
|
import static com.android.text.flags.Flags.FLAG_FIX_LINE_HEIGHT_FOR_LOCALE;
|
||
|
|
import static com.android.text.flags.Flags.FLAG_USE_BOUNDS_FOR_WIDTH;
|
||
|
|
|
||
|
|
import android.annotation.FlaggedApi;
|
||
|
|
import android.annotation.FloatRange;
|
||
|
|
import android.annotation.IntRange;
|
||
|
|
import android.annotation.NonNull;
|
||
|
|
import android.annotation.Nullable;
|
||
|
|
import android.annotation.SuppressLint;
|
||
|
|
import android.compat.annotation.UnsupportedAppUsage;
|
||
|
|
import android.graphics.Paint;
|
||
|
|
import android.graphics.RectF;
|
||
|
|
import android.graphics.text.LineBreakConfig;
|
||
|
|
import android.graphics.text.LineBreaker;
|
||
|
|
import android.os.Build;
|
||
|
|
import android.os.Trace;
|
||
|
|
import android.text.style.LeadingMarginSpan;
|
||
|
|
import android.text.style.LeadingMarginSpan.LeadingMarginSpan2;
|
||
|
|
import android.text.style.LineHeightSpan;
|
||
|
|
import android.text.style.TabStopSpan;
|
||
|
|
import android.util.Log;
|
||
|
|
import android.util.Pools.SynchronizedPool;
|
||
|
|
|
||
|
|
import com.android.internal.util.ArrayUtils;
|
||
|
|
import com.android.internal.util.GrowingArrayUtils;
|
||
|
|
|
||
|
|
import java.util.Arrays;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* StaticLayout is a Layout for text that will not be edited after it
|
||
|
|
* is laid out. Use {@link DynamicLayout} for text that may change.
|
||
|
|
* <p>This is used by widgets to control text layout. You should not need
|
||
|
|
* to use this class directly unless you are implementing your own widget
|
||
|
|
* or custom display object, or would be tempted to call
|
||
|
|
* {@link android.graphics.Canvas#drawText(java.lang.CharSequence, int, int,
|
||
|
|
* float, float, android.graphics.Paint)
|
||
|
|
* Canvas.drawText()} directly.</p>
|
||
|
|
*/
|
||
|
|
public class StaticLayout extends Layout {
|
||
|
|
/*
|
||
|
|
* The break iteration is done in native code. The protocol for using the native code is as
|
||
|
|
* follows.
|
||
|
|
*
|
||
|
|
* First, call nInit to setup native line breaker object. Then, for each paragraph, do the
|
||
|
|
* following:
|
||
|
|
*
|
||
|
|
* - Create MeasuredParagraph by MeasuredParagraph.buildForStaticLayout which measures in
|
||
|
|
* native.
|
||
|
|
* - Run LineBreaker.computeLineBreaks() to obtain line breaks for the paragraph.
|
||
|
|
*
|
||
|
|
* After all paragraphs, call finish() to release expensive buffers.
|
||
|
|
*/
|
||
|
|
|
||
|
|
static final String TAG = "StaticLayout";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Builder for static layouts. The builder is the preferred pattern for constructing
|
||
|
|
* StaticLayout objects and should be preferred over the constructors, particularly to access
|
||
|
|
* newer features. To build a static layout, first call {@link #obtain} with the required
|
||
|
|
* arguments (text, paint, and width), then call setters for optional parameters, and finally
|
||
|
|
* {@link #build} to build the StaticLayout object. Parameters not explicitly set will get
|
||
|
|
* default values.
|
||
|
|
*/
|
||
|
|
public final static class Builder {
|
||
|
|
private Builder() {}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Obtain a builder for constructing StaticLayout objects.
|
||
|
|
*
|
||
|
|
* @param source The text to be laid out, optionally with spans
|
||
|
|
* @param start The index of the start of the text
|
||
|
|
* @param end The index + 1 of the end of the text
|
||
|
|
* @param paint The base paint used for layout
|
||
|
|
* @param width The width in pixels
|
||
|
|
* @return a builder object used for constructing the StaticLayout
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public static Builder obtain(@NonNull CharSequence source, @IntRange(from = 0) int start,
|
||
|
|
@IntRange(from = 0) int end, @NonNull TextPaint paint,
|
||
|
|
@IntRange(from = 0) int width) {
|
||
|
|
Builder b = sPool.acquire();
|
||
|
|
if (b == null) {
|
||
|
|
b = new Builder();
|
||
|
|
}
|
||
|
|
|
||
|
|
// set default initial values
|
||
|
|
b.mText = source;
|
||
|
|
b.mStart = start;
|
||
|
|
b.mEnd = end;
|
||
|
|
b.mPaint = paint;
|
||
|
|
b.mWidth = width;
|
||
|
|
b.mAlignment = Alignment.ALIGN_NORMAL;
|
||
|
|
b.mTextDir = TextDirectionHeuristics.FIRSTSTRONG_LTR;
|
||
|
|
b.mSpacingMult = DEFAULT_LINESPACING_MULTIPLIER;
|
||
|
|
b.mSpacingAdd = DEFAULT_LINESPACING_ADDITION;
|
||
|
|
b.mIncludePad = true;
|
||
|
|
b.mFallbackLineSpacing = false;
|
||
|
|
b.mEllipsizedWidth = width;
|
||
|
|
b.mEllipsize = null;
|
||
|
|
b.mMaxLines = Integer.MAX_VALUE;
|
||
|
|
b.mBreakStrategy = Layout.BREAK_STRATEGY_SIMPLE;
|
||
|
|
b.mHyphenationFrequency = Layout.HYPHENATION_FREQUENCY_NONE;
|
||
|
|
b.mJustificationMode = Layout.JUSTIFICATION_MODE_NONE;
|
||
|
|
b.mLineBreakConfig = LineBreakConfig.NONE;
|
||
|
|
b.mMinimumFontMetrics = null;
|
||
|
|
return b;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method should be called after the layout is finished getting constructed and the
|
||
|
|
* builder needs to be cleaned up and returned to the pool.
|
||
|
|
*/
|
||
|
|
private static void recycle(@NonNull Builder b) {
|
||
|
|
b.mPaint = null;
|
||
|
|
b.mText = null;
|
||
|
|
b.mLeftIndents = null;
|
||
|
|
b.mRightIndents = null;
|
||
|
|
b.mMinimumFontMetrics = null;
|
||
|
|
sPool.release(b);
|
||
|
|
}
|
||
|
|
|
||
|
|
// release any expensive state
|
||
|
|
/* package */ void finish() {
|
||
|
|
mText = null;
|
||
|
|
mPaint = null;
|
||
|
|
mLeftIndents = null;
|
||
|
|
mRightIndents = null;
|
||
|
|
mMinimumFontMetrics = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
public Builder setText(CharSequence source) {
|
||
|
|
return setText(source, 0, source.length());
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the text. Only useful when re-using the builder, which is done for
|
||
|
|
* the internal implementation of {@link DynamicLayout} but not as part
|
||
|
|
* of normal {@link StaticLayout} usage.
|
||
|
|
*
|
||
|
|
* @param source The text to be laid out, optionally with spans
|
||
|
|
* @param start The index of the start of the text
|
||
|
|
* @param end The index + 1 of the end of the text
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setText(@NonNull CharSequence source, int start, int end) {
|
||
|
|
mText = source;
|
||
|
|
mStart = start;
|
||
|
|
mEnd = end;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the paint. Internal for reuse cases only.
|
||
|
|
*
|
||
|
|
* @param paint The base paint used for layout
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setPaint(@NonNull TextPaint paint) {
|
||
|
|
mPaint = paint;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the width. Internal for reuse cases only.
|
||
|
|
*
|
||
|
|
* @param width The width in pixels
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setWidth(@IntRange(from = 0) int width) {
|
||
|
|
mWidth = width;
|
||
|
|
if (mEllipsize == null) {
|
||
|
|
mEllipsizedWidth = width;
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the alignment. The default is {@link Layout.Alignment#ALIGN_NORMAL}.
|
||
|
|
*
|
||
|
|
* @param alignment Alignment for the resulting {@link StaticLayout}
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setAlignment(@NonNull Alignment alignment) {
|
||
|
|
mAlignment = alignment;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the text direction heuristic. The text direction heuristic is used to
|
||
|
|
* resolve text direction per-paragraph based on the input text. The default is
|
||
|
|
* {@link TextDirectionHeuristics#FIRSTSTRONG_LTR}.
|
||
|
|
*
|
||
|
|
* @param textDir text direction heuristic for resolving bidi behavior.
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setTextDirection(@NonNull TextDirectionHeuristic textDir) {
|
||
|
|
mTextDir = textDir;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set line spacing parameters. Each line will have its line spacing multiplied by
|
||
|
|
* {@code spacingMult} and then increased by {@code spacingAdd}. The default is 0.0 for
|
||
|
|
* {@code spacingAdd} and 1.0 for {@code spacingMult}.
|
||
|
|
*
|
||
|
|
* @param spacingAdd the amount of line spacing addition
|
||
|
|
* @param spacingMult the line spacing multiplier
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
* @see android.widget.TextView#setLineSpacing
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setLineSpacing(float spacingAdd, @FloatRange(from = 0.0) float spacingMult) {
|
||
|
|
mSpacingAdd = spacingAdd;
|
||
|
|
mSpacingMult = spacingMult;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set whether to include extra space beyond font ascent and descent (which is
|
||
|
|
* needed to avoid clipping in some languages, such as Arabic and Kannada). The
|
||
|
|
* default is {@code true}.
|
||
|
|
*
|
||
|
|
* @param includePad whether to include padding
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
* @see android.widget.TextView#setIncludeFontPadding
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setIncludePad(boolean includePad) {
|
||
|
|
mIncludePad = includePad;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set whether to respect the ascent and descent of the fallback fonts that are used in
|
||
|
|
* displaying the text (which is needed to avoid text from consecutive lines running into
|
||
|
|
* each other). If set, fallback fonts that end up getting used can increase the ascent
|
||
|
|
* and descent of the lines that they are used on.
|
||
|
|
*
|
||
|
|
* <p>For backward compatibility reasons, the default is {@code false}, but setting this to
|
||
|
|
* true is strongly recommended. It is required to be true if text could be in languages
|
||
|
|
* like Burmese or Tibetan where text is typically much taller or deeper than Latin text.
|
||
|
|
*
|
||
|
|
* @param useLineSpacingFromFallbacks whether to expand linespacing based on fallback fonts
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setUseLineSpacingFromFallbacks(boolean useLineSpacingFromFallbacks) {
|
||
|
|
mFallbackLineSpacing = useLineSpacingFromFallbacks;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the width as used for ellipsizing purposes, if it differs from the
|
||
|
|
* normal layout width. The default is the {@code width}
|
||
|
|
* passed to {@link #obtain}.
|
||
|
|
*
|
||
|
|
* @param ellipsizedWidth width used for ellipsizing, in pixels
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
* @see android.widget.TextView#setEllipsize
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setEllipsizedWidth(@IntRange(from = 0) int ellipsizedWidth) {
|
||
|
|
mEllipsizedWidth = ellipsizedWidth;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set ellipsizing on the layout. Causes words that are longer than the view
|
||
|
|
* is wide, or exceeding the number of lines (see #setMaxLines) in the case
|
||
|
|
* of {@link android.text.TextUtils.TruncateAt#END} or
|
||
|
|
* {@link android.text.TextUtils.TruncateAt#MARQUEE}, to be ellipsized instead
|
||
|
|
* of broken. The default is {@code null}, indicating no ellipsis is to be applied.
|
||
|
|
*
|
||
|
|
* @param ellipsize type of ellipsis behavior
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
* @see android.widget.TextView#setEllipsize
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setEllipsize(@Nullable TextUtils.TruncateAt ellipsize) {
|
||
|
|
mEllipsize = ellipsize;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set maximum number of lines. This is particularly useful in the case of
|
||
|
|
* ellipsizing, where it changes the layout of the last line. The default is
|
||
|
|
* unlimited.
|
||
|
|
*
|
||
|
|
* @param maxLines maximum number of lines in the layout
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
* @see android.widget.TextView#setMaxLines
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setMaxLines(@IntRange(from = 0) int maxLines) {
|
||
|
|
mMaxLines = maxLines;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set break strategy, useful for selecting high quality or balanced paragraph
|
||
|
|
* layout options. The default is {@link Layout#BREAK_STRATEGY_SIMPLE}.
|
||
|
|
* <p/>
|
||
|
|
* Enabling hyphenation with either using {@link Layout#HYPHENATION_FREQUENCY_NORMAL} or
|
||
|
|
* {@link Layout#HYPHENATION_FREQUENCY_FULL} while line breaking is set to one of
|
||
|
|
* {@link Layout#BREAK_STRATEGY_BALANCED}, {@link Layout#BREAK_STRATEGY_HIGH_QUALITY}
|
||
|
|
* improves the structure of text layout however has performance impact and requires more
|
||
|
|
* time to do the text layout.
|
||
|
|
*
|
||
|
|
* @param breakStrategy break strategy for paragraph layout
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
* @see android.widget.TextView#setBreakStrategy
|
||
|
|
* @see #setHyphenationFrequency(int)
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setBreakStrategy(@BreakStrategy int breakStrategy) {
|
||
|
|
mBreakStrategy = breakStrategy;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set hyphenation frequency, to control the amount of automatic hyphenation used. The
|
||
|
|
* possible values are defined in {@link Layout}, by constants named with the pattern
|
||
|
|
* {@code HYPHENATION_FREQUENCY_*}. The default is
|
||
|
|
* {@link Layout#HYPHENATION_FREQUENCY_NONE}.
|
||
|
|
* <p/>
|
||
|
|
* Enabling hyphenation with either using {@link Layout#HYPHENATION_FREQUENCY_NORMAL} or
|
||
|
|
* {@link Layout#HYPHENATION_FREQUENCY_FULL} while line breaking is set to one of
|
||
|
|
* {@link Layout#BREAK_STRATEGY_BALANCED}, {@link Layout#BREAK_STRATEGY_HIGH_QUALITY}
|
||
|
|
* improves the structure of text layout however has performance impact and requires more
|
||
|
|
* time to do the text layout.
|
||
|
|
*
|
||
|
|
* @param hyphenationFrequency hyphenation frequency for the paragraph
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
* @see android.widget.TextView#setHyphenationFrequency
|
||
|
|
* @see #setBreakStrategy(int)
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setHyphenationFrequency(@HyphenationFrequency int hyphenationFrequency) {
|
||
|
|
mHyphenationFrequency = hyphenationFrequency;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set indents. Arguments are arrays holding an indent amount, one per line, measured in
|
||
|
|
* pixels. For lines past the last element in the array, the last element repeats.
|
||
|
|
*
|
||
|
|
* @param leftIndents array of indent values for left margin, in pixels
|
||
|
|
* @param rightIndents array of indent values for right margin, in pixels
|
||
|
|
* @return this builder, useful for chaining
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setIndents(@Nullable int[] leftIndents, @Nullable int[] rightIndents) {
|
||
|
|
mLeftIndents = leftIndents;
|
||
|
|
mRightIndents = rightIndents;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set paragraph justification mode. The default value is
|
||
|
|
* {@link Layout#JUSTIFICATION_MODE_NONE}. If the last line is too short for justification,
|
||
|
|
* the last line will be displayed with the alignment set by {@link #setAlignment}.
|
||
|
|
* When Justification mode is JUSTIFICATION_MODE_INTER_WORD, wordSpacing on the given
|
||
|
|
* {@link Paint} will be ignored. This behavior also affects Spans which change the
|
||
|
|
* wordSpacing.
|
||
|
|
*
|
||
|
|
* @param justificationMode justification mode for the paragraph.
|
||
|
|
* @return this builder, useful for chaining.
|
||
|
|
* @see Paint#setWordSpacing(float)
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setJustificationMode(@JustificationMode int justificationMode) {
|
||
|
|
mJustificationMode = justificationMode;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets whether the line spacing should be applied for the last line. Default value is
|
||
|
|
* {@code false}.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
/* package */ Builder setAddLastLineLineSpacing(boolean value) {
|
||
|
|
mAddLastLineLineSpacing = value;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the line break configuration. The line break will be passed to native used for
|
||
|
|
* calculating the text wrapping. The default value of the line break style is
|
||
|
|
* {@link LineBreakConfig#LINE_BREAK_STYLE_NONE}
|
||
|
|
*
|
||
|
|
* @param lineBreakConfig the line break configuration for text wrapping.
|
||
|
|
* @return this builder, useful for chaining.
|
||
|
|
* @see android.widget.TextView#setLineBreakStyle
|
||
|
|
* @see android.widget.TextView#setLineBreakWordStyle
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public Builder setLineBreakConfig(@NonNull LineBreakConfig lineBreakConfig) {
|
||
|
|
mLineBreakConfig = lineBreakConfig;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set true for using width of bounding box as a source of automatic line breaking and
|
||
|
|
* drawing.
|
||
|
|
*
|
||
|
|
* If this value is false, the Layout determines the drawing offset and automatic line
|
||
|
|
* breaking based on total advances. By setting true, use all joined glyph's bounding boxes
|
||
|
|
* as a source of text width.
|
||
|
|
*
|
||
|
|
* If the font has glyphs that have negative bearing X or its xMax is greater than advance,
|
||
|
|
* the glyph clipping can happen because the drawing area may be bigger. By setting this to
|
||
|
|
* true, the Layout will reserve more spaces for drawing.
|
||
|
|
*
|
||
|
|
* @param useBoundsForWidth True for using bounding box, false for advances.
|
||
|
|
* @return this builder instance
|
||
|
|
* @see Layout#getUseBoundsForWidth()
|
||
|
|
* @see Layout.Builder#setUseBoundsForWidth(boolean)
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
@FlaggedApi(FLAG_USE_BOUNDS_FOR_WIDTH)
|
||
|
|
public Builder setUseBoundsForWidth(boolean useBoundsForWidth) {
|
||
|
|
mUseBoundsForWidth = useBoundsForWidth;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set true for shifting the drawing x offset for showing overhang at the start position.
|
||
|
|
*
|
||
|
|
* This flag is ignored if the {@link #getUseBoundsForWidth()} is false.
|
||
|
|
*
|
||
|
|
* If this value is false, the Layout draws text from the zero even if there is a glyph
|
||
|
|
* stroke in a region where the x coordinate is negative.
|
||
|
|
*
|
||
|
|
* If this value is true, the Layout draws text with shifting the x coordinate of the
|
||
|
|
* drawing bounding box.
|
||
|
|
*
|
||
|
|
* This value is false by default.
|
||
|
|
*
|
||
|
|
* @param shiftDrawingOffsetForStartOverhang true for shifting the drawing offset for
|
||
|
|
* showing the stroke that is in the region where
|
||
|
|
* the x coordinate is negative.
|
||
|
|
* @see #setUseBoundsForWidth(boolean)
|
||
|
|
* @see #getUseBoundsForWidth()
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
// The corresponding getter is getShiftDrawingOffsetForStartOverhang()
|
||
|
|
@SuppressLint("MissingGetterMatchingBuilder")
|
||
|
|
@FlaggedApi(FLAG_USE_BOUNDS_FOR_WIDTH)
|
||
|
|
public Builder setShiftDrawingOffsetForStartOverhang(
|
||
|
|
boolean shiftDrawingOffsetForStartOverhang) {
|
||
|
|
mShiftDrawingOffsetForStartOverhang = shiftDrawingOffsetForStartOverhang;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Internal API that tells underlying line breaker that calculating bounding boxes even if
|
||
|
|
* the line break is performed with advances. This is useful for DynamicLayout internal
|
||
|
|
* implementation because it uses bounding box as well as advances.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public Builder setCalculateBounds(boolean value) {
|
||
|
|
mCalculateBounds = value;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the minimum font metrics used for line spacing.
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* {@code null} is the default value. If {@code null} is set or left as default, the
|
||
|
|
* font metrics obtained by {@link Paint#getFontMetricsForLocale(Paint.FontMetrics)} is
|
||
|
|
* used.
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* The minimum meaning here is the minimum value of line spacing: maximum value of
|
||
|
|
* {@link Paint#ascent()}, minimum value of {@link Paint#descent()}.
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* By setting this value, each line will have minimum line spacing regardless of the text
|
||
|
|
* rendered. For example, usually Japanese script has larger vertical metrics than Latin
|
||
|
|
* script. By setting the metrics obtained by
|
||
|
|
* {@link Paint#getFontMetricsForLocale(Paint.FontMetrics)} for Japanese or leave it
|
||
|
|
* {@code null} if the Paint's locale is Japanese, the line spacing for Japanese is reserved
|
||
|
|
* if the text is an English text. If the vertical metrics of the text is larger than
|
||
|
|
* Japanese, for example Burmese, the bigger font metrics is used.
|
||
|
|
*
|
||
|
|
* @param minimumFontMetrics A minimum font metrics. Passing {@code null} for using the
|
||
|
|
* value obtained by
|
||
|
|
* {@link Paint#getFontMetricsForLocale(Paint.FontMetrics)}
|
||
|
|
* @see android.widget.TextView#setMinimumFontMetrics(Paint.FontMetrics)
|
||
|
|
* @see android.widget.TextView#getMinimumFontMetrics()
|
||
|
|
* @see Layout#getMinimumFontMetrics()
|
||
|
|
* @see Layout.Builder#setMinimumFontMetrics(Paint.FontMetrics)
|
||
|
|
* @see DynamicLayout.Builder#setMinimumFontMetrics(Paint.FontMetrics)
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
@FlaggedApi(FLAG_FIX_LINE_HEIGHT_FOR_LOCALE)
|
||
|
|
public Builder setMinimumFontMetrics(@Nullable Paint.FontMetrics minimumFontMetrics) {
|
||
|
|
mMinimumFontMetrics = minimumFontMetrics;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Build the {@link StaticLayout} after options have been set.
|
||
|
|
*
|
||
|
|
* <p>Note: the builder object must not be reused in any way after calling this
|
||
|
|
* method. Setting parameters after calling this method, or calling it a second
|
||
|
|
* time on the same builder object, will likely lead to unexpected results.
|
||
|
|
*
|
||
|
|
* @return the newly constructed {@link StaticLayout} object
|
||
|
|
*/
|
||
|
|
@NonNull
|
||
|
|
public StaticLayout build() {
|
||
|
|
StaticLayout result = new StaticLayout(this, mIncludePad, mEllipsize != null
|
||
|
|
? COLUMNS_ELLIPSIZE : COLUMNS_NORMAL);
|
||
|
|
Builder.recycle(this);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* DO NOT USE THIS METHOD OTHER THAN DynamicLayout.
|
||
|
|
*
|
||
|
|
* This class generates a very weird StaticLayout only for getting a result of line break.
|
||
|
|
* Since DynamicLayout keeps StaticLayout reference in the static context for object
|
||
|
|
* recycling but keeping text reference in static context will end up with leaking Context
|
||
|
|
* due to TextWatcher via TextView.
|
||
|
|
*
|
||
|
|
* So, this is a dirty work around that creating StaticLayout without passing text reference
|
||
|
|
* to the super constructor, but calculating the text layout by calling generate function
|
||
|
|
* directly.
|
||
|
|
*/
|
||
|
|
/* package */ @NonNull StaticLayout buildPartialStaticLayoutForDynamicLayout(
|
||
|
|
boolean trackpadding, StaticLayout recycle) {
|
||
|
|
if (recycle == null) {
|
||
|
|
recycle = new StaticLayout();
|
||
|
|
}
|
||
|
|
Trace.beginSection("Generating StaticLayout For DynamicLayout");
|
||
|
|
try {
|
||
|
|
recycle.generate(this, mIncludePad, trackpadding);
|
||
|
|
} finally {
|
||
|
|
Trace.endSection();
|
||
|
|
}
|
||
|
|
return recycle;
|
||
|
|
}
|
||
|
|
|
||
|
|
private CharSequence mText;
|
||
|
|
private int mStart;
|
||
|
|
private int mEnd;
|
||
|
|
private TextPaint mPaint;
|
||
|
|
private int mWidth;
|
||
|
|
private Alignment mAlignment;
|
||
|
|
private TextDirectionHeuristic mTextDir;
|
||
|
|
private float mSpacingMult;
|
||
|
|
private float mSpacingAdd;
|
||
|
|
private boolean mIncludePad;
|
||
|
|
private boolean mFallbackLineSpacing;
|
||
|
|
private int mEllipsizedWidth;
|
||
|
|
private TextUtils.TruncateAt mEllipsize;
|
||
|
|
private int mMaxLines;
|
||
|
|
private int mBreakStrategy;
|
||
|
|
private int mHyphenationFrequency;
|
||
|
|
@Nullable private int[] mLeftIndents;
|
||
|
|
@Nullable private int[] mRightIndents;
|
||
|
|
private int mJustificationMode;
|
||
|
|
private boolean mAddLastLineLineSpacing;
|
||
|
|
private LineBreakConfig mLineBreakConfig = LineBreakConfig.NONE;
|
||
|
|
private boolean mUseBoundsForWidth;
|
||
|
|
private boolean mShiftDrawingOffsetForStartOverhang;
|
||
|
|
private boolean mCalculateBounds;
|
||
|
|
@Nullable private Paint.FontMetrics mMinimumFontMetrics;
|
||
|
|
|
||
|
|
private final Paint.FontMetricsInt mFontMetricsInt = new Paint.FontMetricsInt();
|
||
|
|
|
||
|
|
private static final SynchronizedPool<Builder> sPool = new SynchronizedPool<>(3);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* DO NOT USE THIS CONSTRUCTOR OTHER THAN FOR DYNAMIC LAYOUT.
|
||
|
|
* See Builder#buildPartialStaticLayoutForDynamicLayout for the reason of this constructor.
|
||
|
|
*/
|
||
|
|
private StaticLayout() {
|
||
|
|
super(
|
||
|
|
null, // text
|
||
|
|
null, // paint
|
||
|
|
0, // width
|
||
|
|
null, // alignment
|
||
|
|
null, // textDir
|
||
|
|
1, // spacing multiplier
|
||
|
|
0, // spacing amount
|
||
|
|
false, // include font padding
|
||
|
|
false, // fallback line spacing
|
||
|
|
0, // ellipsized width
|
||
|
|
null, // ellipsize
|
||
|
|
1, // maxLines
|
||
|
|
BREAK_STRATEGY_SIMPLE,
|
||
|
|
HYPHENATION_FREQUENCY_NONE,
|
||
|
|
null, // leftIndents
|
||
|
|
null, // rightIndents
|
||
|
|
JUSTIFICATION_MODE_NONE,
|
||
|
|
null, // lineBreakConfig,
|
||
|
|
false, // useBoundsForWidth
|
||
|
|
false, // shiftDrawingOffsetForStartOverhang
|
||
|
|
null // minimumFontMetrics
|
||
|
|
);
|
||
|
|
|
||
|
|
mColumns = COLUMNS_ELLIPSIZE;
|
||
|
|
mLineDirections = ArrayUtils.newUnpaddedArray(Directions.class, 2);
|
||
|
|
mLines = ArrayUtils.newUnpaddedIntArray(2 * mColumns);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @deprecated Use {@link Builder} instead.
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
public StaticLayout(CharSequence source, TextPaint paint,
|
||
|
|
int width,
|
||
|
|
Alignment align, float spacingmult, float spacingadd,
|
||
|
|
boolean includepad) {
|
||
|
|
this(source, 0, source.length(), paint, width, align,
|
||
|
|
spacingmult, spacingadd, includepad);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @deprecated Use {@link Builder} instead.
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
public StaticLayout(CharSequence source, int bufstart, int bufend,
|
||
|
|
TextPaint paint, int outerwidth,
|
||
|
|
Alignment align,
|
||
|
|
float spacingmult, float spacingadd,
|
||
|
|
boolean includepad) {
|
||
|
|
this(source, bufstart, bufend, paint, outerwidth, align,
|
||
|
|
spacingmult, spacingadd, includepad, null, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @deprecated Use {@link Builder} instead.
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
public StaticLayout(CharSequence source, int bufstart, int bufend,
|
||
|
|
TextPaint paint, int outerwidth,
|
||
|
|
Alignment align,
|
||
|
|
float spacingmult, float spacingadd,
|
||
|
|
boolean includepad,
|
||
|
|
TextUtils.TruncateAt ellipsize, int ellipsizedWidth) {
|
||
|
|
this(source, bufstart, bufend, paint, outerwidth, align,
|
||
|
|
TextDirectionHeuristics.FIRSTSTRONG_LTR,
|
||
|
|
spacingmult, spacingadd, includepad, ellipsize, ellipsizedWidth, Integer.MAX_VALUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @hide
|
||
|
|
* @deprecated Use {@link Builder} instead.
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 117521430)
|
||
|
|
public StaticLayout(CharSequence source, int bufstart, int bufend,
|
||
|
|
TextPaint paint, int outerwidth,
|
||
|
|
Alignment align, TextDirectionHeuristic textDir,
|
||
|
|
float spacingmult, float spacingadd,
|
||
|
|
boolean includepad,
|
||
|
|
TextUtils.TruncateAt ellipsize, int ellipsizedWidth, int maxLines) {
|
||
|
|
this(Builder.obtain(source, bufstart, bufend, paint, outerwidth)
|
||
|
|
.setAlignment(align)
|
||
|
|
.setTextDirection(textDir)
|
||
|
|
.setLineSpacing(spacingadd, spacingmult)
|
||
|
|
.setIncludePad(includepad)
|
||
|
|
.setEllipsize(ellipsize)
|
||
|
|
.setEllipsizedWidth(ellipsizedWidth)
|
||
|
|
.setMaxLines(maxLines), includepad,
|
||
|
|
ellipsize != null ? COLUMNS_ELLIPSIZE : COLUMNS_NORMAL);
|
||
|
|
}
|
||
|
|
|
||
|
|
private StaticLayout(Builder b, boolean trackPadding, int columnSize) {
|
||
|
|
super((b.mEllipsize == null) ? b.mText : (b.mText instanceof Spanned)
|
||
|
|
? new SpannedEllipsizer(b.mText) : new Ellipsizer(b.mText),
|
||
|
|
b.mPaint, b.mWidth, b.mAlignment, b.mTextDir, b.mSpacingMult, b.mSpacingAdd,
|
||
|
|
b.mIncludePad, b.mFallbackLineSpacing, b.mEllipsizedWidth, b.mEllipsize,
|
||
|
|
b.mMaxLines, b.mBreakStrategy, b.mHyphenationFrequency, b.mLeftIndents,
|
||
|
|
b.mRightIndents, b.mJustificationMode, b.mLineBreakConfig, b.mUseBoundsForWidth,
|
||
|
|
b.mShiftDrawingOffsetForStartOverhang, b.mMinimumFontMetrics);
|
||
|
|
|
||
|
|
mColumns = columnSize;
|
||
|
|
if (b.mEllipsize != null) {
|
||
|
|
Ellipsizer e = (Ellipsizer) getText();
|
||
|
|
|
||
|
|
e.mLayout = this;
|
||
|
|
e.mWidth = b.mEllipsizedWidth;
|
||
|
|
e.mMethod = b.mEllipsize;
|
||
|
|
}
|
||
|
|
|
||
|
|
mLineDirections = ArrayUtils.newUnpaddedArray(Directions.class, 2);
|
||
|
|
mLines = ArrayUtils.newUnpaddedIntArray(2 * mColumns);
|
||
|
|
mMaximumVisibleLineCount = b.mMaxLines;
|
||
|
|
|
||
|
|
mLeftIndents = b.mLeftIndents;
|
||
|
|
mRightIndents = b.mRightIndents;
|
||
|
|
|
||
|
|
Trace.beginSection("Constructing StaticLayout");
|
||
|
|
try {
|
||
|
|
generate(b, b.mIncludePad, trackPadding);
|
||
|
|
} finally {
|
||
|
|
Trace.endSection();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static int getBaseHyphenationFrequency(int frequency) {
|
||
|
|
switch (frequency) {
|
||
|
|
case Layout.HYPHENATION_FREQUENCY_FULL:
|
||
|
|
case Layout.HYPHENATION_FREQUENCY_FULL_FAST:
|
||
|
|
return LineBreaker.HYPHENATION_FREQUENCY_FULL;
|
||
|
|
case Layout.HYPHENATION_FREQUENCY_NORMAL:
|
||
|
|
case Layout.HYPHENATION_FREQUENCY_NORMAL_FAST:
|
||
|
|
return LineBreaker.HYPHENATION_FREQUENCY_NORMAL;
|
||
|
|
case Layout.HYPHENATION_FREQUENCY_NONE:
|
||
|
|
default:
|
||
|
|
return LineBreaker.HYPHENATION_FREQUENCY_NONE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* package */ void generate(Builder b, boolean includepad, boolean trackpad) {
|
||
|
|
final CharSequence source = b.mText;
|
||
|
|
final int bufStart = b.mStart;
|
||
|
|
final int bufEnd = b.mEnd;
|
||
|
|
TextPaint paint = b.mPaint;
|
||
|
|
int outerWidth = b.mWidth;
|
||
|
|
TextDirectionHeuristic textDir = b.mTextDir;
|
||
|
|
float spacingmult = b.mSpacingMult;
|
||
|
|
float spacingadd = b.mSpacingAdd;
|
||
|
|
float ellipsizedWidth = b.mEllipsizedWidth;
|
||
|
|
TextUtils.TruncateAt ellipsize = b.mEllipsize;
|
||
|
|
final boolean addLastLineSpacing = b.mAddLastLineLineSpacing;
|
||
|
|
|
||
|
|
int lineBreakCapacity = 0;
|
||
|
|
int[] breaks = null;
|
||
|
|
float[] lineWidths = null;
|
||
|
|
float[] ascents = null;
|
||
|
|
float[] descents = null;
|
||
|
|
boolean[] hasTabs = null;
|
||
|
|
int[] hyphenEdits = null;
|
||
|
|
|
||
|
|
mLineCount = 0;
|
||
|
|
mEllipsized = false;
|
||
|
|
mMaxLineHeight = mMaximumVisibleLineCount < 1 ? 0 : DEFAULT_MAX_LINE_HEIGHT;
|
||
|
|
mDrawingBounds = null;
|
||
|
|
boolean isFallbackLineSpacing = b.mFallbackLineSpacing;
|
||
|
|
|
||
|
|
int v = 0;
|
||
|
|
boolean needMultiply = (spacingmult != 1 || spacingadd != 0);
|
||
|
|
|
||
|
|
Paint.FontMetricsInt fm = b.mFontMetricsInt;
|
||
|
|
int[] chooseHtv = null;
|
||
|
|
|
||
|
|
final int[] indents;
|
||
|
|
if (mLeftIndents != null || mRightIndents != null) {
|
||
|
|
final int leftLen = mLeftIndents == null ? 0 : mLeftIndents.length;
|
||
|
|
final int rightLen = mRightIndents == null ? 0 : mRightIndents.length;
|
||
|
|
final int indentsLen = Math.max(leftLen, rightLen);
|
||
|
|
indents = new int[indentsLen];
|
||
|
|
for (int i = 0; i < leftLen; i++) {
|
||
|
|
indents[i] = mLeftIndents[i];
|
||
|
|
}
|
||
|
|
for (int i = 0; i < rightLen; i++) {
|
||
|
|
indents[i] += mRightIndents[i];
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
indents = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
int defaultTop;
|
||
|
|
final int defaultAscent;
|
||
|
|
final int defaultDescent;
|
||
|
|
int defaultBottom;
|
||
|
|
if (ClientFlags.fixLineHeightForLocale() && b.mMinimumFontMetrics != null) {
|
||
|
|
defaultTop = (int) Math.floor(b.mMinimumFontMetrics.top);
|
||
|
|
defaultAscent = Math.round(b.mMinimumFontMetrics.ascent);
|
||
|
|
defaultDescent = Math.round(b.mMinimumFontMetrics.descent);
|
||
|
|
defaultBottom = (int) Math.ceil(b.mMinimumFontMetrics.bottom);
|
||
|
|
|
||
|
|
// Because the font metrics is provided by public APIs, adjust the top/bottom with
|
||
|
|
// ascent/descent: top must be smaller than ascent, bottom must be larger than descent.
|
||
|
|
defaultTop = Math.min(defaultTop, defaultAscent);
|
||
|
|
defaultBottom = Math.max(defaultBottom, defaultDescent);
|
||
|
|
} else {
|
||
|
|
defaultTop = 0;
|
||
|
|
defaultAscent = 0;
|
||
|
|
defaultDescent = 0;
|
||
|
|
defaultBottom = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
final LineBreaker lineBreaker = new LineBreaker.Builder()
|
||
|
|
.setBreakStrategy(b.mBreakStrategy)
|
||
|
|
.setHyphenationFrequency(getBaseHyphenationFrequency(b.mHyphenationFrequency))
|
||
|
|
// TODO: Support more justification mode, e.g. letter spacing, stretching.
|
||
|
|
.setJustificationMode(b.mJustificationMode)
|
||
|
|
.setIndents(indents)
|
||
|
|
.setUseBoundsForWidth(b.mUseBoundsForWidth)
|
||
|
|
.build();
|
||
|
|
|
||
|
|
LineBreaker.ParagraphConstraints constraints =
|
||
|
|
new LineBreaker.ParagraphConstraints();
|
||
|
|
|
||
|
|
PrecomputedText.ParagraphInfo[] paragraphInfo = null;
|
||
|
|
final Spanned spanned = (source instanceof Spanned) ? (Spanned) source : null;
|
||
|
|
if (source instanceof PrecomputedText) {
|
||
|
|
PrecomputedText precomputed = (PrecomputedText) source;
|
||
|
|
final @PrecomputedText.Params.CheckResultUsableResult int checkResult =
|
||
|
|
precomputed.checkResultUsable(bufStart, bufEnd, textDir, paint,
|
||
|
|
b.mBreakStrategy, b.mHyphenationFrequency, b.mLineBreakConfig);
|
||
|
|
switch (checkResult) {
|
||
|
|
case PrecomputedText.Params.UNUSABLE:
|
||
|
|
break;
|
||
|
|
case PrecomputedText.Params.NEED_RECOMPUTE:
|
||
|
|
final PrecomputedText.Params newParams =
|
||
|
|
new PrecomputedText.Params.Builder(paint)
|
||
|
|
.setBreakStrategy(b.mBreakStrategy)
|
||
|
|
.setHyphenationFrequency(b.mHyphenationFrequency)
|
||
|
|
.setTextDirection(textDir)
|
||
|
|
.setLineBreakConfig(b.mLineBreakConfig)
|
||
|
|
.build();
|
||
|
|
precomputed = PrecomputedText.create(precomputed, newParams);
|
||
|
|
paragraphInfo = precomputed.getParagraphInfo();
|
||
|
|
break;
|
||
|
|
case PrecomputedText.Params.USABLE:
|
||
|
|
// Some parameters are different from the ones when measured text is created.
|
||
|
|
paragraphInfo = precomputed.getParagraphInfo();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (paragraphInfo == null) {
|
||
|
|
final PrecomputedText.Params param = new PrecomputedText.Params(paint,
|
||
|
|
b.mLineBreakConfig, textDir, b.mBreakStrategy, b.mHyphenationFrequency);
|
||
|
|
paragraphInfo = PrecomputedText.createMeasuredParagraphs(source, param, bufStart,
|
||
|
|
bufEnd, false /* computeLayout */, b.mCalculateBounds);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int paraIndex = 0; paraIndex < paragraphInfo.length; paraIndex++) {
|
||
|
|
final int paraStart = paraIndex == 0
|
||
|
|
? bufStart : paragraphInfo[paraIndex - 1].paragraphEnd;
|
||
|
|
final int paraEnd = paragraphInfo[paraIndex].paragraphEnd;
|
||
|
|
|
||
|
|
int firstWidthLineCount = 1;
|
||
|
|
int firstWidth = outerWidth;
|
||
|
|
int restWidth = outerWidth;
|
||
|
|
|
||
|
|
LineHeightSpan[] chooseHt = null;
|
||
|
|
if (spanned != null) {
|
||
|
|
LeadingMarginSpan[] sp = getParagraphSpans(spanned, paraStart, paraEnd,
|
||
|
|
LeadingMarginSpan.class);
|
||
|
|
for (int i = 0; i < sp.length; i++) {
|
||
|
|
LeadingMarginSpan lms = sp[i];
|
||
|
|
firstWidth -= sp[i].getLeadingMargin(true);
|
||
|
|
restWidth -= sp[i].getLeadingMargin(false);
|
||
|
|
|
||
|
|
// LeadingMarginSpan2 is odd. The count affects all
|
||
|
|
// leading margin spans, not just this particular one
|
||
|
|
if (lms instanceof LeadingMarginSpan2) {
|
||
|
|
LeadingMarginSpan2 lms2 = (LeadingMarginSpan2) lms;
|
||
|
|
firstWidthLineCount = Math.max(firstWidthLineCount,
|
||
|
|
lms2.getLeadingMarginLineCount());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
chooseHt = getParagraphSpans(spanned, paraStart, paraEnd, LineHeightSpan.class);
|
||
|
|
|
||
|
|
if (chooseHt.length == 0) {
|
||
|
|
chooseHt = null; // So that out() would not assume it has any contents
|
||
|
|
} else {
|
||
|
|
if (chooseHtv == null || chooseHtv.length < chooseHt.length) {
|
||
|
|
chooseHtv = ArrayUtils.newUnpaddedIntArray(chooseHt.length);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = 0; i < chooseHt.length; i++) {
|
||
|
|
int o = spanned.getSpanStart(chooseHt[i]);
|
||
|
|
|
||
|
|
if (o < paraStart) {
|
||
|
|
// starts in this layout, before the
|
||
|
|
// current paragraph
|
||
|
|
|
||
|
|
chooseHtv[i] = getLineTop(getLineForOffset(o));
|
||
|
|
} else {
|
||
|
|
// starts in this paragraph
|
||
|
|
|
||
|
|
chooseHtv[i] = v;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// tab stop locations
|
||
|
|
float[] variableTabStops = null;
|
||
|
|
if (spanned != null) {
|
||
|
|
TabStopSpan[] spans = getParagraphSpans(spanned, paraStart,
|
||
|
|
paraEnd, TabStopSpan.class);
|
||
|
|
if (spans.length > 0) {
|
||
|
|
float[] stops = new float[spans.length];
|
||
|
|
for (int i = 0; i < spans.length; i++) {
|
||
|
|
stops[i] = (float) spans[i].getTabStop();
|
||
|
|
}
|
||
|
|
Arrays.sort(stops, 0, stops.length);
|
||
|
|
variableTabStops = stops;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
final MeasuredParagraph measuredPara = paragraphInfo[paraIndex].measured;
|
||
|
|
final char[] chs = measuredPara.getChars();
|
||
|
|
final int[] spanEndCache = measuredPara.getSpanEndCache().getRawArray();
|
||
|
|
final int[] fmCache = measuredPara.getFontMetrics().getRawArray();
|
||
|
|
|
||
|
|
constraints.setWidth(restWidth);
|
||
|
|
constraints.setIndent(firstWidth, firstWidthLineCount);
|
||
|
|
constraints.setTabStops(variableTabStops, TAB_INCREMENT);
|
||
|
|
|
||
|
|
LineBreaker.Result res = lineBreaker.computeLineBreaks(
|
||
|
|
measuredPara.getMeasuredText(), constraints, mLineCount);
|
||
|
|
int breakCount = res.getLineCount();
|
||
|
|
if (lineBreakCapacity < breakCount) {
|
||
|
|
lineBreakCapacity = breakCount;
|
||
|
|
breaks = new int[lineBreakCapacity];
|
||
|
|
lineWidths = new float[lineBreakCapacity];
|
||
|
|
ascents = new float[lineBreakCapacity];
|
||
|
|
descents = new float[lineBreakCapacity];
|
||
|
|
hasTabs = new boolean[lineBreakCapacity];
|
||
|
|
hyphenEdits = new int[lineBreakCapacity];
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = 0; i < breakCount; ++i) {
|
||
|
|
breaks[i] = res.getLineBreakOffset(i);
|
||
|
|
lineWidths[i] = res.getLineWidth(i);
|
||
|
|
ascents[i] = res.getLineAscent(i);
|
||
|
|
descents[i] = res.getLineDescent(i);
|
||
|
|
hasTabs[i] = res.hasLineTab(i);
|
||
|
|
hyphenEdits[i] =
|
||
|
|
packHyphenEdit(res.getStartLineHyphenEdit(i), res.getEndLineHyphenEdit(i));
|
||
|
|
}
|
||
|
|
|
||
|
|
final int remainingLineCount = mMaximumVisibleLineCount - mLineCount;
|
||
|
|
final boolean ellipsisMayBeApplied = ellipsize != null
|
||
|
|
&& (ellipsize == TextUtils.TruncateAt.END
|
||
|
|
|| (mMaximumVisibleLineCount == 1
|
||
|
|
&& ellipsize != TextUtils.TruncateAt.MARQUEE));
|
||
|
|
if (0 < remainingLineCount && remainingLineCount < breakCount
|
||
|
|
&& ellipsisMayBeApplied) {
|
||
|
|
// Calculate width
|
||
|
|
float width = 0;
|
||
|
|
boolean hasTab = false; // XXX May need to also have starting hyphen edit
|
||
|
|
for (int i = remainingLineCount - 1; i < breakCount; i++) {
|
||
|
|
if (i == breakCount - 1) {
|
||
|
|
width += lineWidths[i];
|
||
|
|
} else {
|
||
|
|
for (int j = (i == 0 ? 0 : breaks[i - 1]); j < breaks[i]; j++) {
|
||
|
|
width += measuredPara.getCharWidthAt(j);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
hasTab |= hasTabs[i];
|
||
|
|
}
|
||
|
|
// Treat the last line and overflowed lines as a single line.
|
||
|
|
breaks[remainingLineCount - 1] = breaks[breakCount - 1];
|
||
|
|
lineWidths[remainingLineCount - 1] = width;
|
||
|
|
hasTabs[remainingLineCount - 1] = hasTab;
|
||
|
|
|
||
|
|
breakCount = remainingLineCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
// here is the offset of the starting character of the line we are currently
|
||
|
|
// measuring
|
||
|
|
int here = paraStart;
|
||
|
|
|
||
|
|
int fmTop = defaultTop;
|
||
|
|
int fmBottom = defaultBottom;
|
||
|
|
int fmAscent = defaultAscent;
|
||
|
|
int fmDescent = defaultDescent;
|
||
|
|
int fmCacheIndex = 0;
|
||
|
|
int spanEndCacheIndex = 0;
|
||
|
|
int breakIndex = 0;
|
||
|
|
for (int spanStart = paraStart, spanEnd; spanStart < paraEnd; spanStart = spanEnd) {
|
||
|
|
// retrieve end of span
|
||
|
|
spanEnd = spanEndCache[spanEndCacheIndex++];
|
||
|
|
|
||
|
|
// retrieve cached metrics, order matches above
|
||
|
|
fm.top = fmCache[fmCacheIndex * 4 + 0];
|
||
|
|
fm.bottom = fmCache[fmCacheIndex * 4 + 1];
|
||
|
|
fm.ascent = fmCache[fmCacheIndex * 4 + 2];
|
||
|
|
fm.descent = fmCache[fmCacheIndex * 4 + 3];
|
||
|
|
fmCacheIndex++;
|
||
|
|
|
||
|
|
if (fm.top < fmTop) {
|
||
|
|
fmTop = fm.top;
|
||
|
|
}
|
||
|
|
if (fm.ascent < fmAscent) {
|
||
|
|
fmAscent = fm.ascent;
|
||
|
|
}
|
||
|
|
if (fm.descent > fmDescent) {
|
||
|
|
fmDescent = fm.descent;
|
||
|
|
}
|
||
|
|
if (fm.bottom > fmBottom) {
|
||
|
|
fmBottom = fm.bottom;
|
||
|
|
}
|
||
|
|
|
||
|
|
// skip breaks ending before current span range
|
||
|
|
while (breakIndex < breakCount && paraStart + breaks[breakIndex] < spanStart) {
|
||
|
|
breakIndex++;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (breakIndex < breakCount && paraStart + breaks[breakIndex] <= spanEnd) {
|
||
|
|
int endPos = paraStart + breaks[breakIndex];
|
||
|
|
|
||
|
|
boolean moreChars = (endPos < bufEnd);
|
||
|
|
|
||
|
|
final int ascent = isFallbackLineSpacing
|
||
|
|
? Math.min(fmAscent, Math.round(ascents[breakIndex]))
|
||
|
|
: fmAscent;
|
||
|
|
final int descent = isFallbackLineSpacing
|
||
|
|
? Math.max(fmDescent, Math.round(descents[breakIndex]))
|
||
|
|
: fmDescent;
|
||
|
|
|
||
|
|
// The fallback ascent/descent may be larger than top/bottom of the default font
|
||
|
|
// metrics. Adjust top/bottom with ascent/descent for avoiding unexpected
|
||
|
|
// clipping.
|
||
|
|
if (isFallbackLineSpacing) {
|
||
|
|
if (ascent < fmTop) {
|
||
|
|
fmTop = ascent;
|
||
|
|
}
|
||
|
|
if (descent > fmBottom) {
|
||
|
|
fmBottom = descent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
v = out(source, here, endPos,
|
||
|
|
ascent, descent, fmTop, fmBottom,
|
||
|
|
v, spacingmult, spacingadd, chooseHt, chooseHtv, fm,
|
||
|
|
hasTabs[breakIndex], hyphenEdits[breakIndex], needMultiply,
|
||
|
|
measuredPara, bufEnd, includepad, trackpad, addLastLineSpacing, chs,
|
||
|
|
paraStart, ellipsize, ellipsizedWidth, lineWidths[breakIndex],
|
||
|
|
paint, moreChars);
|
||
|
|
|
||
|
|
if (endPos < spanEnd) {
|
||
|
|
// preserve metrics for current span
|
||
|
|
fmTop = Math.min(defaultTop, fm.top);
|
||
|
|
fmBottom = Math.max(defaultBottom, fm.bottom);
|
||
|
|
fmAscent = Math.min(defaultAscent, fm.ascent);
|
||
|
|
fmDescent = Math.max(defaultDescent, fm.descent);
|
||
|
|
} else {
|
||
|
|
fmTop = fmBottom = fmAscent = fmDescent = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
here = endPos;
|
||
|
|
breakIndex++;
|
||
|
|
|
||
|
|
if (mLineCount >= mMaximumVisibleLineCount && mEllipsized) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (paraEnd == bufEnd) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((bufEnd == bufStart || source.charAt(bufEnd - 1) == CHAR_NEW_LINE)
|
||
|
|
&& mLineCount < mMaximumVisibleLineCount) {
|
||
|
|
final MeasuredParagraph measuredPara =
|
||
|
|
MeasuredParagraph.buildForBidi(source, bufEnd, bufEnd, textDir, null);
|
||
|
|
if (defaultAscent != 0 && defaultDescent != 0) {
|
||
|
|
fm.top = defaultTop;
|
||
|
|
fm.ascent = defaultAscent;
|
||
|
|
fm.descent = defaultDescent;
|
||
|
|
fm.bottom = defaultBottom;
|
||
|
|
} else {
|
||
|
|
paint.getFontMetricsInt(fm);
|
||
|
|
}
|
||
|
|
|
||
|
|
v = out(source,
|
||
|
|
bufEnd, bufEnd, fm.ascent, fm.descent,
|
||
|
|
fm.top, fm.bottom,
|
||
|
|
v,
|
||
|
|
spacingmult, spacingadd, null,
|
||
|
|
null, fm, false, 0,
|
||
|
|
needMultiply, measuredPara, bufEnd,
|
||
|
|
includepad, trackpad, addLastLineSpacing, null,
|
||
|
|
bufStart, ellipsize,
|
||
|
|
ellipsizedWidth, 0, paint, false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private int out(final CharSequence text, final int start, final int end, int above, int below,
|
||
|
|
int top, int bottom, int v, final float spacingmult, final float spacingadd,
|
||
|
|
final LineHeightSpan[] chooseHt, final int[] chooseHtv, final Paint.FontMetricsInt fm,
|
||
|
|
final boolean hasTab, final int hyphenEdit, final boolean needMultiply,
|
||
|
|
@NonNull final MeasuredParagraph measured,
|
||
|
|
final int bufEnd, final boolean includePad, final boolean trackPad,
|
||
|
|
final boolean addLastLineLineSpacing, final char[] chs,
|
||
|
|
final int widthStart, final TextUtils.TruncateAt ellipsize, final float ellipsisWidth,
|
||
|
|
final float textWidth, final TextPaint paint, final boolean moreChars) {
|
||
|
|
final int j = mLineCount;
|
||
|
|
final int off = j * mColumns;
|
||
|
|
final int want = off + mColumns + TOP;
|
||
|
|
int[] lines = mLines;
|
||
|
|
final int dir = measured.getParagraphDir();
|
||
|
|
|
||
|
|
if (want >= lines.length) {
|
||
|
|
final int[] grow = ArrayUtils.newUnpaddedIntArray(GrowingArrayUtils.growSize(want));
|
||
|
|
System.arraycopy(lines, 0, grow, 0, lines.length);
|
||
|
|
mLines = grow;
|
||
|
|
lines = grow;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (j >= mLineDirections.length) {
|
||
|
|
final Directions[] grow = ArrayUtils.newUnpaddedArray(Directions.class,
|
||
|
|
GrowingArrayUtils.growSize(j));
|
||
|
|
System.arraycopy(mLineDirections, 0, grow, 0, mLineDirections.length);
|
||
|
|
mLineDirections = grow;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (chooseHt != null) {
|
||
|
|
fm.ascent = above;
|
||
|
|
fm.descent = below;
|
||
|
|
fm.top = top;
|
||
|
|
fm.bottom = bottom;
|
||
|
|
|
||
|
|
for (int i = 0; i < chooseHt.length; i++) {
|
||
|
|
if (chooseHt[i] instanceof LineHeightSpan.WithDensity) {
|
||
|
|
((LineHeightSpan.WithDensity) chooseHt[i])
|
||
|
|
.chooseHeight(text, start, end, chooseHtv[i], v, fm, paint);
|
||
|
|
} else {
|
||
|
|
chooseHt[i].chooseHeight(text, start, end, chooseHtv[i], v, fm);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
above = fm.ascent;
|
||
|
|
below = fm.descent;
|
||
|
|
top = fm.top;
|
||
|
|
bottom = fm.bottom;
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean firstLine = (j == 0);
|
||
|
|
boolean currentLineIsTheLastVisibleOne = (j + 1 == mMaximumVisibleLineCount);
|
||
|
|
|
||
|
|
if (ellipsize != null) {
|
||
|
|
// If there is only one line, then do any type of ellipsis except when it is MARQUEE
|
||
|
|
// if there are multiple lines, just allow END ellipsis on the last line
|
||
|
|
boolean forceEllipsis = moreChars && (mLineCount + 1 == mMaximumVisibleLineCount);
|
||
|
|
|
||
|
|
boolean doEllipsis =
|
||
|
|
(((mMaximumVisibleLineCount == 1 && moreChars) || (firstLine && !moreChars)) &&
|
||
|
|
ellipsize != TextUtils.TruncateAt.MARQUEE) ||
|
||
|
|
(!firstLine && (currentLineIsTheLastVisibleOne || !moreChars) &&
|
||
|
|
ellipsize == TextUtils.TruncateAt.END);
|
||
|
|
if (doEllipsis) {
|
||
|
|
calculateEllipsis(start, end, measured, widthStart,
|
||
|
|
ellipsisWidth, ellipsize, j,
|
||
|
|
textWidth, paint, forceEllipsis);
|
||
|
|
} else {
|
||
|
|
mLines[mColumns * j + ELLIPSIS_START] = 0;
|
||
|
|
mLines[mColumns * j + ELLIPSIS_COUNT] = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
final boolean lastLine;
|
||
|
|
if (mEllipsized) {
|
||
|
|
lastLine = true;
|
||
|
|
} else {
|
||
|
|
final boolean lastCharIsNewLine = widthStart != bufEnd && bufEnd > 0
|
||
|
|
&& text.charAt(bufEnd - 1) == CHAR_NEW_LINE;
|
||
|
|
if (end == bufEnd && !lastCharIsNewLine) {
|
||
|
|
lastLine = true;
|
||
|
|
} else if (start == bufEnd && lastCharIsNewLine) {
|
||
|
|
lastLine = true;
|
||
|
|
} else {
|
||
|
|
lastLine = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (firstLine) {
|
||
|
|
if (trackPad) {
|
||
|
|
mTopPadding = top - above;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (includePad) {
|
||
|
|
above = top;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int extra;
|
||
|
|
|
||
|
|
if (lastLine) {
|
||
|
|
if (trackPad) {
|
||
|
|
mBottomPadding = bottom - below;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (includePad) {
|
||
|
|
below = bottom;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (needMultiply && (addLastLineLineSpacing || !lastLine)) {
|
||
|
|
double ex = (below - above) * (spacingmult - 1) + spacingadd;
|
||
|
|
if (ex >= 0) {
|
||
|
|
extra = (int)(ex + EXTRA_ROUNDING);
|
||
|
|
} else {
|
||
|
|
extra = -(int)(-ex + EXTRA_ROUNDING);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
extra = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
lines[off + START] = start;
|
||
|
|
lines[off + TOP] = v;
|
||
|
|
lines[off + DESCENT] = below + extra;
|
||
|
|
lines[off + EXTRA] = extra;
|
||
|
|
|
||
|
|
// special case for non-ellipsized last visible line when maxLines is set
|
||
|
|
// store the height as if it was ellipsized
|
||
|
|
if (!mEllipsized && currentLineIsTheLastVisibleOne) {
|
||
|
|
// below calculation as if it was the last line
|
||
|
|
int maxLineBelow = includePad ? bottom : below;
|
||
|
|
// similar to the calculation of v below, without the extra.
|
||
|
|
mMaxLineHeight = v + (maxLineBelow - above);
|
||
|
|
}
|
||
|
|
|
||
|
|
v += (below - above) + extra;
|
||
|
|
lines[off + mColumns + START] = end;
|
||
|
|
lines[off + mColumns + TOP] = v;
|
||
|
|
|
||
|
|
// TODO: could move TAB to share same column as HYPHEN, simplifying this code and gaining
|
||
|
|
// one bit for start field
|
||
|
|
lines[off + TAB] |= hasTab ? TAB_MASK : 0;
|
||
|
|
if (mEllipsized) {
|
||
|
|
if (ellipsize == TextUtils.TruncateAt.START) {
|
||
|
|
lines[off + HYPHEN] = packHyphenEdit(Paint.START_HYPHEN_EDIT_NO_EDIT,
|
||
|
|
unpackEndHyphenEdit(hyphenEdit));
|
||
|
|
} else if (ellipsize == TextUtils.TruncateAt.END) {
|
||
|
|
lines[off + HYPHEN] = packHyphenEdit(unpackStartHyphenEdit(hyphenEdit),
|
||
|
|
Paint.END_HYPHEN_EDIT_NO_EDIT);
|
||
|
|
} else { // Middle and marquee ellipsize should show text at the start/end edge.
|
||
|
|
lines[off + HYPHEN] = packHyphenEdit(
|
||
|
|
Paint.START_HYPHEN_EDIT_NO_EDIT, Paint.END_HYPHEN_EDIT_NO_EDIT);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
lines[off + HYPHEN] = hyphenEdit;
|
||
|
|
}
|
||
|
|
|
||
|
|
lines[off + DIR] |= dir << DIR_SHIFT;
|
||
|
|
mLineDirections[j] = measured.getDirections(start - widthStart, end - widthStart);
|
||
|
|
|
||
|
|
mLineCount++;
|
||
|
|
return v;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void calculateEllipsis(int lineStart, int lineEnd,
|
||
|
|
MeasuredParagraph measured, int widthStart,
|
||
|
|
float avail, TextUtils.TruncateAt where,
|
||
|
|
int line, float textWidth, TextPaint paint,
|
||
|
|
boolean forceEllipsis) {
|
||
|
|
avail -= getTotalInsets(line);
|
||
|
|
if (textWidth <= avail && !forceEllipsis) {
|
||
|
|
// Everything fits!
|
||
|
|
mLines[mColumns * line + ELLIPSIS_START] = 0;
|
||
|
|
mLines[mColumns * line + ELLIPSIS_COUNT] = 0;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
float ellipsisWidth = paint.measureText(TextUtils.getEllipsisString(where));
|
||
|
|
int ellipsisStart = 0;
|
||
|
|
int ellipsisCount = 0;
|
||
|
|
int len = lineEnd - lineStart;
|
||
|
|
|
||
|
|
// We only support start ellipsis on a single line
|
||
|
|
if (where == TextUtils.TruncateAt.START) {
|
||
|
|
if (mMaximumVisibleLineCount == 1) {
|
||
|
|
float sum = 0;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
for (i = len; i > 0; i--) {
|
||
|
|
float w = measured.getCharWidthAt(i - 1 + lineStart - widthStart);
|
||
|
|
if (w + sum + ellipsisWidth > avail) {
|
||
|
|
while (i < len
|
||
|
|
&& measured.getCharWidthAt(i + lineStart - widthStart) == 0.0f) {
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
sum += w;
|
||
|
|
}
|
||
|
|
|
||
|
|
ellipsisStart = 0;
|
||
|
|
ellipsisCount = i;
|
||
|
|
} else {
|
||
|
|
if (Log.isLoggable(TAG, Log.WARN)) {
|
||
|
|
Log.w(TAG, "Start Ellipsis only supported with one line");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (where == TextUtils.TruncateAt.END || where == TextUtils.TruncateAt.MARQUEE ||
|
||
|
|
where == TextUtils.TruncateAt.END_SMALL) {
|
||
|
|
float sum = 0;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
for (i = 0; i < len; i++) {
|
||
|
|
float w = measured.getCharWidthAt(i + lineStart - widthStart);
|
||
|
|
|
||
|
|
if (w + sum + ellipsisWidth > avail) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
sum += w;
|
||
|
|
}
|
||
|
|
|
||
|
|
ellipsisStart = i;
|
||
|
|
ellipsisCount = len - i;
|
||
|
|
if (forceEllipsis && ellipsisCount == 0 && len > 0) {
|
||
|
|
ellipsisStart = len - 1;
|
||
|
|
ellipsisCount = 1;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// where = TextUtils.TruncateAt.MIDDLE We only support middle ellipsis on a single line
|
||
|
|
if (mMaximumVisibleLineCount == 1) {
|
||
|
|
float lsum = 0, rsum = 0;
|
||
|
|
int left = 0, right = len;
|
||
|
|
|
||
|
|
float ravail = (avail - ellipsisWidth) / 2;
|
||
|
|
for (right = len; right > 0; right--) {
|
||
|
|
float w = measured.getCharWidthAt(right - 1 + lineStart - widthStart);
|
||
|
|
|
||
|
|
if (w + rsum > ravail) {
|
||
|
|
while (right < len
|
||
|
|
&& measured.getCharWidthAt(right + lineStart - widthStart)
|
||
|
|
== 0.0f) {
|
||
|
|
right++;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
rsum += w;
|
||
|
|
}
|
||
|
|
|
||
|
|
float lavail = avail - ellipsisWidth - rsum;
|
||
|
|
for (left = 0; left < right; left++) {
|
||
|
|
float w = measured.getCharWidthAt(left + lineStart - widthStart);
|
||
|
|
|
||
|
|
if (w + lsum > lavail) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
lsum += w;
|
||
|
|
}
|
||
|
|
|
||
|
|
ellipsisStart = left;
|
||
|
|
ellipsisCount = right - left;
|
||
|
|
} else {
|
||
|
|
if (Log.isLoggable(TAG, Log.WARN)) {
|
||
|
|
Log.w(TAG, "Middle Ellipsis only supported with one line");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
mEllipsized = true;
|
||
|
|
mLines[mColumns * line + ELLIPSIS_START] = ellipsisStart;
|
||
|
|
mLines[mColumns * line + ELLIPSIS_COUNT] = ellipsisCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
private float getTotalInsets(int line) {
|
||
|
|
int totalIndent = 0;
|
||
|
|
if (mLeftIndents != null) {
|
||
|
|
totalIndent = mLeftIndents[Math.min(line, mLeftIndents.length - 1)];
|
||
|
|
}
|
||
|
|
if (mRightIndents != null) {
|
||
|
|
totalIndent += mRightIndents[Math.min(line, mRightIndents.length - 1)];
|
||
|
|
}
|
||
|
|
return totalIndent;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Override the base class so we can directly access our members,
|
||
|
|
// rather than relying on member functions.
|
||
|
|
// The logic mirrors that of Layout.getLineForVertical
|
||
|
|
// FIXME: It may be faster to do a linear search for layouts without many lines.
|
||
|
|
@Override
|
||
|
|
public int getLineForVertical(int vertical) {
|
||
|
|
int high = mLineCount;
|
||
|
|
int low = -1;
|
||
|
|
int guess;
|
||
|
|
int[] lines = mLines;
|
||
|
|
while (high - low > 1) {
|
||
|
|
guess = (high + low) >> 1;
|
||
|
|
if (lines[mColumns * guess + TOP] > vertical){
|
||
|
|
high = guess;
|
||
|
|
} else {
|
||
|
|
low = guess;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (low < 0) {
|
||
|
|
return 0;
|
||
|
|
} else {
|
||
|
|
return low;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int getLineCount() {
|
||
|
|
return mLineCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int getLineTop(int line) {
|
||
|
|
return mLines[mColumns * line + TOP];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public int getLineExtra(int line) {
|
||
|
|
return mLines[mColumns * line + EXTRA];
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int getLineDescent(int line) {
|
||
|
|
return mLines[mColumns * line + DESCENT];
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int getLineStart(int line) {
|
||
|
|
return mLines[mColumns * line + START] & START_MASK;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int getParagraphDirection(int line) {
|
||
|
|
return mLines[mColumns * line + DIR] >> DIR_SHIFT;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public boolean getLineContainsTab(int line) {
|
||
|
|
return (mLines[mColumns * line + TAB] & TAB_MASK) != 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public final Directions getLineDirections(int line) {
|
||
|
|
if (line > getLineCount()) {
|
||
|
|
throw new ArrayIndexOutOfBoundsException();
|
||
|
|
}
|
||
|
|
return mLineDirections[line];
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int getTopPadding() {
|
||
|
|
return mTopPadding;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int getBottomPadding() {
|
||
|
|
return mBottomPadding;
|
||
|
|
}
|
||
|
|
|
||
|
|
// To store into single int field, pack the pair of start and end hyphen edit.
|
||
|
|
static int packHyphenEdit(
|
||
|
|
@Paint.StartHyphenEdit int start, @Paint.EndHyphenEdit int end) {
|
||
|
|
return start << START_HYPHEN_BITS_SHIFT | end;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int unpackStartHyphenEdit(int packedHyphenEdit) {
|
||
|
|
return (packedHyphenEdit & START_HYPHEN_MASK) >> START_HYPHEN_BITS_SHIFT;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int unpackEndHyphenEdit(int packedHyphenEdit) {
|
||
|
|
return packedHyphenEdit & END_HYPHEN_MASK;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the start hyphen edit value for this line.
|
||
|
|
*
|
||
|
|
* @param lineNumber a line number
|
||
|
|
* @return A start hyphen edit value.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public @Paint.StartHyphenEdit int getStartHyphenEdit(int lineNumber) {
|
||
|
|
return unpackStartHyphenEdit(mLines[mColumns * lineNumber + HYPHEN] & HYPHEN_MASK);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the packed hyphen edit value for this line.
|
||
|
|
*
|
||
|
|
* @param lineNumber a line number
|
||
|
|
* @return An end hyphen edit value.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public @Paint.EndHyphenEdit int getEndHyphenEdit(int lineNumber) {
|
||
|
|
return unpackEndHyphenEdit(mLines[mColumns * lineNumber + HYPHEN] & HYPHEN_MASK);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public int getIndentAdjust(int line, Alignment align) {
|
||
|
|
if (align == Alignment.ALIGN_LEFT) {
|
||
|
|
if (mLeftIndents == null) {
|
||
|
|
return 0;
|
||
|
|
} else {
|
||
|
|
return mLeftIndents[Math.min(line, mLeftIndents.length - 1)];
|
||
|
|
}
|
||
|
|
} else if (align == Alignment.ALIGN_RIGHT) {
|
||
|
|
if (mRightIndents == null) {
|
||
|
|
return 0;
|
||
|
|
} else {
|
||
|
|
return -mRightIndents[Math.min(line, mRightIndents.length - 1)];
|
||
|
|
}
|
||
|
|
} else if (align == Alignment.ALIGN_CENTER) {
|
||
|
|
int left = 0;
|
||
|
|
if (mLeftIndents != null) {
|
||
|
|
left = mLeftIndents[Math.min(line, mLeftIndents.length - 1)];
|
||
|
|
}
|
||
|
|
int right = 0;
|
||
|
|
if (mRightIndents != null) {
|
||
|
|
right = mRightIndents[Math.min(line, mRightIndents.length - 1)];
|
||
|
|
}
|
||
|
|
return (left - right) >> 1;
|
||
|
|
} else {
|
||
|
|
throw new AssertionError("unhandled alignment " + align);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int getEllipsisCount(int line) {
|
||
|
|
if (mColumns < COLUMNS_ELLIPSIZE) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return mLines[mColumns * line + ELLIPSIS_COUNT];
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int getEllipsisStart(int line) {
|
||
|
|
if (mColumns < COLUMNS_ELLIPSIZE) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return mLines[mColumns * line + ELLIPSIS_START];
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
@NonNull
|
||
|
|
public RectF computeDrawingBoundingBox() {
|
||
|
|
// Cache the drawing bounds result because it does not change after created.
|
||
|
|
if (mDrawingBounds == null) {
|
||
|
|
mDrawingBounds = super.computeDrawingBoundingBox();
|
||
|
|
}
|
||
|
|
return mDrawingBounds;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Return the total height of this layout.
|
||
|
|
*
|
||
|
|
* @param cap if true and max lines is set, returns the height of the layout at the max lines.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
|
||
|
|
public int getHeight(boolean cap) {
|
||
|
|
if (cap && mLineCount > mMaximumVisibleLineCount && mMaxLineHeight == -1
|
||
|
|
&& Log.isLoggable(TAG, Log.WARN)) {
|
||
|
|
Log.w(TAG, "maxLineHeight should not be -1. "
|
||
|
|
+ " maxLines:" + mMaximumVisibleLineCount
|
||
|
|
+ " lineCount:" + mLineCount);
|
||
|
|
}
|
||
|
|
|
||
|
|
return cap && mLineCount > mMaximumVisibleLineCount && mMaxLineHeight != -1
|
||
|
|
? mMaxLineHeight : super.getHeight();
|
||
|
|
}
|
||
|
|
|
||
|
|
@UnsupportedAppUsage
|
||
|
|
private int mLineCount;
|
||
|
|
private int mTopPadding, mBottomPadding;
|
||
|
|
@UnsupportedAppUsage
|
||
|
|
private int mColumns;
|
||
|
|
private RectF mDrawingBounds = null; // lazy calculation.
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Keeps track if ellipsize is applied to the text.
|
||
|
|
*/
|
||
|
|
private boolean mEllipsized;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* If maxLines is set, ellipsize is not set, and the actual line count of text is greater than
|
||
|
|
* or equal to maxLine, this variable holds the ideal visual height of the maxLine'th line
|
||
|
|
* starting from the top of the layout. If maxLines is not set its value will be -1.
|
||
|
|
*
|
||
|
|
* The value is the same as getLineTop(maxLines) for ellipsized version where structurally no
|
||
|
|
* more than maxLines is contained.
|
||
|
|
*/
|
||
|
|
private int mMaxLineHeight = DEFAULT_MAX_LINE_HEIGHT;
|
||
|
|
|
||
|
|
private static final int COLUMNS_NORMAL = 5;
|
||
|
|
private static final int COLUMNS_ELLIPSIZE = 7;
|
||
|
|
private static final int START = 0;
|
||
|
|
private static final int DIR = START;
|
||
|
|
private static final int TAB = START;
|
||
|
|
private static final int TOP = 1;
|
||
|
|
private static final int DESCENT = 2;
|
||
|
|
private static final int EXTRA = 3;
|
||
|
|
private static final int HYPHEN = 4;
|
||
|
|
@UnsupportedAppUsage
|
||
|
|
private static final int ELLIPSIS_START = 5;
|
||
|
|
private static final int ELLIPSIS_COUNT = 6;
|
||
|
|
|
||
|
|
@UnsupportedAppUsage
|
||
|
|
private int[] mLines;
|
||
|
|
@UnsupportedAppUsage
|
||
|
|
private Directions[] mLineDirections;
|
||
|
|
@UnsupportedAppUsage
|
||
|
|
private int mMaximumVisibleLineCount = Integer.MAX_VALUE;
|
||
|
|
|
||
|
|
private static final int START_MASK = 0x1FFFFFFF;
|
||
|
|
private static final int DIR_SHIFT = 30;
|
||
|
|
private static final int TAB_MASK = 0x20000000;
|
||
|
|
private static final int HYPHEN_MASK = 0xFF;
|
||
|
|
private static final int START_HYPHEN_BITS_SHIFT = 3;
|
||
|
|
private static final int START_HYPHEN_MASK = 0x18; // 0b11000
|
||
|
|
private static final int END_HYPHEN_MASK = 0x7; // 0b00111
|
||
|
|
|
||
|
|
private static final float TAB_INCREMENT = 20; // same as Layout, but that's private
|
||
|
|
|
||
|
|
private static final char CHAR_NEW_LINE = '\n';
|
||
|
|
|
||
|
|
private static final double EXTRA_ROUNDING = 0.5;
|
||
|
|
|
||
|
|
private static final int DEFAULT_MAX_LINE_HEIGHT = -1;
|
||
|
|
|
||
|
|
// Unused, here because of gray list private API accesses.
|
||
|
|
/*package*/ static class LineBreaks {
|
||
|
|
private static final int INITIAL_SIZE = 16;
|
||
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
||
|
|
public int[] breaks = new int[INITIAL_SIZE];
|
||
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
||
|
|
public float[] widths = new float[INITIAL_SIZE];
|
||
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
||
|
|
public float[] ascents = new float[INITIAL_SIZE];
|
||
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
||
|
|
public float[] descents = new float[INITIAL_SIZE];
|
||
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
||
|
|
public int[] flags = new int[INITIAL_SIZE]; // hasTab
|
||
|
|
// breaks, widths, and flags should all have the same length
|
||
|
|
}
|
||
|
|
|
||
|
|
@Nullable private int[] mLeftIndents;
|
||
|
|
@Nullable private int[] mRightIndents;
|
||
|
|
}
|