简介
看段Android官方的简介
Class Overview
Displays text to the user and optionally allows them to edit it. A TextView is a complete text editor, however the basic class is configured to not allow editing; see EditText for a subclass that configures the text view for editing.
To allow users to copy some or all of the TextView’s value and paste it somewhere else, set the XML attribute android:textIsSelectable to “true” or call setTextIsSelectable(true). The textIsSelectable flag allows users to make selection gestures in the TextView, which in turn triggers the system’s built-in copy/paste controls.
TextView主要用于给用户展示文字，并且让用户随意的可以对文字进行编辑。但是普通的TextView是不允许用来编辑的，只有EditText才可以。
如果在XML中设置了android:textIsSelectable 或者在Java代码中调用了setTextIsSelectable(true)方法，就可以允许对TextView的部分或者全部文字进行复制，然后粘贴到其他地方。textIsSelectable 标签是允许用户在TextView上使用选择手势。
顺便提下，大家如果想看API文档的话，可以在
file:///E:/AndroidEnvironment/SDK/docs/reference/android/widget/TextView.html
你安装SDK的目录下/docs/reference/android/widget/TextView.html找到你想要查看控件的API
分析思路
一般自定义view都需要满足2个条件，展示我们期望的UI，正确传递或者接收处理点击或者触摸事件。
所以对于TextView的分析也从这三个地方展开
-
绘制过程
onMeasure()
onLayout()
onDraw() -
事件接收处理
由于TextView继承于View，所以主要分析onTouchEvent()方法就好了
一些和TextView有关的类如何实现，比如Spans，Layout,接收输入的InputConnection
本文基于Android SDK API-19的基础上分析
在分析之前，我们先来看个小彩蛋
不知道这个//TODO是某个哥们自问自答呢，还是别人在对他的代码review的时候给注上的
再分析之前，顺便抛出一个问题供大家思考下，maxEms这个属性到底是用来做什么的？
网上的答案五花八门，在下面的源码中我们可以一窥究竟。
绘制过程
首先来看onMeasure()部分代码
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
//首先接收到父容器传递过来的MeasureSpec
//关于MeasureSpec是如果计算的，可以查看之前的博文
//[LinearLayout源码解析](http://blog.csdn.net/wz249863091/article/details/51702980)
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int widthSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSize = MeasureSpec.getSize(heightMeasureSpec);
int width;
int height;
//这里解释下什么叫作boring
//A BoringLayout is a very simple Layout implementation for text that
//fits on a single line and is all left-to-right characters.
//boring就是指布局所用的文本里面不包含任何Span，所有的文本方向都是从左到右的布局，
//并且仅需一行就能显示完全的布局
//这里将TextView和Hint的boring初始化
BoringLayout.Metrics boring = UNKNOWN_BORING;
BoringLayout.Metrics hintBoring = UNKNOWN_BORING;
//获得文字的排序方式。一共有6种
//FIRSTSTRONG_RTL,FIRSTSTRONG_LTR Unicode双向算法
//ANYRTL_LTR
//LTR,RTL 左到右或者右到左排序
//LOCALE
//first strong算法 有兴趣的同学可以自行研究下，一般情况下都是左到右排序
if (mTextDir == null) {
mTextDir = getTextDirectionHeuristic();
}
int des = -1;
boolean fromexisting = false;
//如果宽度是精确模式了，那就那父容器给的宽度当作当前TextView的宽度
if (widthMode == MeasureSpec.EXACTLY) {
// Parent has told us how big to be. So be it.
width = widthSize;
} else {
if (mLayout != null && mEllipsize == null) {
//首先计算下期望值，如果行数大于1就返回-1，否则返回单行宽度
//具体代码贴在下面
des = desired(mLayout);
}
//如果小于0，即行数大于1行，就去判断是否是boring
//isBoring()这个方法也在下面有详细分析，大家可以阅读后
//再回过头来看看
if (des < 0) {
boring = BoringLayout.isBoring(mTransformed, mTextPaint, mTextDir, mBoring);
//阅读过下面的方法，就知道boring是一个Metrics矩阵，
//包含了文本样式 width, ascent, and descen等
if (boring != null) {
mBoring = boring;
}
} else {
fromexisting = true;
}
//再次判断boring是否为null
//这里有2种情况会为null
//1.des>0,即Textview只显示一行文字，就不会去计算boring的值了
//2.Textview包含的内容不是boring的，多行，有缩进或者包含spann
if (boring == null || boring == UNKNOWN_BORING) {
//如果是多行文字的
if (des < 0) {
des = (int) FloatMath.ceil(Layout.getDesiredWidth(mTransformed, mTextPaint));
}
width = des;
} else {
//如果是boring模式的就很简单了，把boring刚测量得到的width赋给TextView
//即文字的宽度
width = boring.width;
}
//这里就是加上Drawable的宽度
final Drawables dr = mDrawables;
if (dr != null) {
width = Math.max(width, dr.mDrawableWidthTop);
width = Math.max(width, dr.mDrawableWidthBottom);
}
//这里会再计算一次hint的宽度，流程和上面的一模一样，就不再重复了
if (mHint != null) {
int hintDes = -1;
int hintWidth;
if (mHintLayout != null && mEllipsize == null) {
hintDes = desired(mHintLayout);
}
if (hintDes < 0) {
hintBoring = BoringLayout.isBoring(mHint, mTextPaint, mTextDir, mHintBoring);
if (hintBoring != null) {
mHintBoring = hintBoring;
}
}
if (hintBoring == null || hintBoring == UNKNOWN_BORING) {
if (hintDes < 0) {
hintDes = (int) FloatMath.ceil(Layout.getDesiredWidth(mHint, mTextPaint));
}
hintWidth = hintDes;
} else {
hintWidth = hintBoring.width;
}
if (hintWidth > width) {
width = hintWidth;
}
}
//这里再加上padding的值
//顺便说一句，padding的值是在子view里自己算的
//margin的值是在父容器里算的
//在自定义view和viewgroup的时候，千万注意
//width += getCompoundPaddingLeft() + getCompoundPaddingRight();
//在这，就能解答之前的疑问，EMS这个属性到底是干嘛的
//如果我们设置了maxEms这个属性
//public void setMaxEms(int maxems) {
// mMaxWidth = maxems;
//mMaxWidthMode = EMS;
//requestLayout();
//invalidate();
//}
//mMaxWidth的值就是EMS的值
//如果设置了maxLength，那么mMaxWidth的值就是maxWidth的值
//然后再来看如果是EMS模式
//Math.min(width, mMaxWidth * getLineHeight())
//我们的最大宽度就是EMS的值乘以lineHeight的值
//而lineHeight的值 官方是这么解释的
//return the height of one standard line in pixels
//public int getLineHeight() {
// return FastMath.round(mTextPaint.getFontMetricsInt(null) *
//mSpacingMult + mSpacingAdd);
//就是行间距乘以字体大小
//所以在不同行间距和字体大小下，EMS所产生的mMaxWidth也是不同的
}
if (mMaxWidthMode == EMS) {
width = Math.min(width, mMaxWidth * getLineHeight());
} else {
width = Math.min(width, mMaxWidth);
}
if (mMinWidthMode == EMS) {
width = Math.max(width, mMinWidth * getLineHeight());
} else {
width = Math.max(width, mMinWidth);
}
// Check against our minimum width
width = Math.max(width, getSuggestedMinimumWidth());
//如果是Wrap的，会在父容器给的size和实际最大size中取小的
if (widthMode == MeasureSpec.AT_MOST) {
width = Math.min(widthSize, width);
}
}
//最后根据上面计算得到的size-padding的值就是我们单行text实际可以展示的大小
int want = width - getCompoundPaddingLeft() - getCompoundPaddingRight();
int unpaddedWidth = want;
//如果是水平方向可以scroll的，那么宽度就是无限大了，因为可以滑嘛
if (mHorizontallyScrolling) want = VERY_WIDE;
int hintWant = want;
int hintWidth = (mHintLayout == null) ? hintWant : mHintLayout.getWidth();
//这里会牵扯到makeNewLayout（...）这个方法，也会在下面得到详细分析
if (mLayout == null) {
makeNewLayout(want, hintWant, boring, hintBoring,
width - getCompoundPaddingLeft() - getCompoundPaddingRight(), false);
} else {
final boolean layoutChanged = (mLayout.getWidth() != want) ||
(hintWidth != hintWant) ||
(mLayout.getEllipsizedWidth() !=
width - getCompoundPaddingLeft() - getCompoundPaddingRight());
final boolean widthChanged = (mHint == null) &&
(mEllipsize == null) &&
(want > mLayout.getWidth()) &&
(mLayout instanceof BoringLayout || (fromexisting && des >= 0 && des <= want));
final boolean maximumChanged = (mMaxMode != mOldMaxMode) || (mMaximum != mOldMaximum);
if (layoutChanged || maximumChanged) {
if (!maximumChanged && widthChanged) {
mLayout.increaseWidthTo(want);
} else {
makeNewLayout(want, hintWant, boring, hintBoring,
width - getCompoundPaddingLeft() - getCompoundPaddingRight(), false);
}
} else {
// Nothing has changed
}
}
//然后开始计算高度，这部分代码相对于宽度，就简单的多了
//如果是精确模式，那么高度就等于TextView要求的高度
if (heightMode == MeasureSpec.EXACTLY) {
// Parent has told us how big to be. So be it.
height = heightSize;
mDesiredHeightAtMeasure = -1;
} else {
//计算下想要的高度
//这里逻辑比较简单
//只需要比较下文字高度和hint的高度，取大的那个值就可以了
//至于文字高度和hint高度的计算：
//1.当行高度*行数
//如果设置了Drawable的话，比较2个值得大小，取大的
//如果设置了maxLines或者maxHeight计算下当前高度有没超过最大高度，超过的话取最大高度
//如果设置了minLines或者minHeight的话，比较下当前高度和最小高度，取小的
int desired = getDesiredHeight();
height = desired;
mDesiredHeightAtMeasure = desired;
//如果是warp模式，就取父容器算的和实际需要小的值
if (heightMode == MeasureSpec.AT_MOST) {
height = Math.min(desired, heightSize);
}
}
int unpaddedHeight = height - getCompoundPaddingTop() - getCompoundPaddingBottom();
if (mMaxMode == LINES && mLayout.getLineCount() > mMaximum) {
unpaddedHeight = Math.min(unpaddedHeight, mLayout.getLineTop(mMaximum));
}
/*
* We didn't let makeNewLayout() register to bring the cursor into view,
* so do it here if there is any possibility that it is needed.
*/
//这里就是处理下滚动条
if (mMovement != null ||
mLayout.getWidth() > unpaddedWidth ||
mLayout.getHeight() > unpaddedHeight) {
registerForPreDraw();
} else {
scrollTo(0, 0);
}
setMeasuredDimension(width, height);
}desire()方法
private static int desired(Layout layout) {
//首先获得行数
int n = layout.getLineCount();
CharSequence text = layout.getText();
float max = 0;
// if any line was wrapped, we can't use it.
// but it's ok for the last line not to have a newline
//如果行数大于1，就返回-1
for (int i = 0; i < n - 1; i++) {
if (text.charAt(layout.getLineEnd(i) - 1) != '\n')
return -1;
}
//将宽度和0比较，如果大于0，就取宽度
for (int i = 0; i < n; i++) {
max = Math.max(max, layout.getLineWidth(i));
}
return (int) FloatMath.ceil(max);
}isBoring()实现
/**
* Returns null if not boring; the width, ascent, and descent in the
* provided Metrics object (or a new one if the provided one was null)
* if boring.
* @hide
*/
//如果是boring模式的就返回Metrics object，不是就返回null
//什么是boring模式 开头已经讲过了，根据他的定义也不难猜到这个方法有几个条件判断
public static Metrics isBoring(CharSequence text, TextPaint paint,
TextDirectionHeuristic textDir, Metrics metrics) {
//首先获得一个char型数组，这里值得一提的是TextUtils.obtain(500)这个方法
//在我们自己写代码的时候也可以借鉴，减少内存的交换
//这里把字符串分成了以500个字符为一组
char[] temp = TextUtils.obtain(500);
int length = text.length();
boolean boring = true;
outer:
for (int i = 0; i < length; i += 500) {
int j = i + 500;
//首先判断是否当前组的字符串是否有500个
//没有就取实际长度
if (j > length)
j = length;
//根据长度取出字符串的子串
TextUtils.getChars(text, i, j, temp, 0);
//子串的长度
int n = j - i;
//遍历整个子串
for (int a = 0; a < n; a++) {
char c = temp[a];
//这里有3个条件
//1.如果有换行 \n
//2.如果有缩进 \t
//3.如果不是LTR 左到右模式
//如果有其中1种情况，就视为不是boring模式
if (c == '\n' || c == '\t' || c >= FIRST_RIGHT_TO_LEFT) {
boring = false;
break outer;
}
}
if (textDir != null && textDir.isRtl(temp, 0, n)) {
boring = false;
break outer;
}
}
//把temp回收
TextUtils.recycle(temp);
//如果包含了span，那么也视为不是boring模式
if (boring && text instanceof Spanned) {
Spanned sp = (Spanned) text;
Object[] styles = sp.getSpans(0, length, ParagraphStyle.class);
if (styles.length > 0) {
boring = false;
}
}
//如果是boring模式，那就返回Metrics对象
if (boring) {
Metrics fm = metrics;
//首先判断传进来的Metrics是否为空，如果为空，就新建一个对象
if (fm == null) {
fm = new Metrics();
}
//设置TextLine，文本样式
TextLine line = TextLine.obtain();
line.set(paint, text, 0, length, Layout.DIR_LEFT_TO_RIGHT,
Layout.DIRS_ALL_LEFT_TO_RIGHT, false, null);
fm.width = (int) FloatMath.ceil(line.metrics(fm));
TextLine.recycle(line);
return fm;
} else {
return null;
}
}makeNewLayout（…）方法
/**
* The width passed in is now the desired layout width,
* not the full view width with padding.
* {@hide}
*/
protected void makeNewLayout(int wantWidth, int hintWidth,
BoringLayout.Metrics boring,
BoringLayout.Metrics hintBoring,
int ellipsisWidth, boolean bringIntoView) {
//首先，如果有跑马灯效果，先把跑马灯停了
stopMarquee();
// Update "old" cached values
//把最大宽度和最大行数先保存起来
mOldMaximum = mMaximum;
mOldMaxMode = mMaxMode;
mHighlightPathBogus = true;
if (wantWidth < 0) {
wantWidth = 0;
}
if (hintWidth < 0) {
hintWidth = 0;
}
//获得对其方式
Layout.Alignment alignment = getLayoutAlignment();
final boolean testDirChange = mSingleLine && mLayout != null &&
(alignment == Layout.Alignment.ALIGN_NORMAL ||
alignment == Layout.Alignment.ALIGN_OPPOSITE);
int oldDir = 0;
if (testDirChange) oldDir = mLayout.getParagraphDirection(0);
//是否需要省略号，这个值是根据我们在XML中写的Ellipsize来定的
boolean shouldEllipsize = mEllipsize != null && getKeyListener() == null;
//省略号主要分开始位置，中间位置和结束位置3个常规位置
//还有跑马灯这种非常规位置
//mMarqueeFadeMode分为3种效果
//MARQUEE_FADE_NORMAL
//MARQUEE_FADE_SWITCH_SHOW_ELLIPSIS
//MARQUEE_FADE_SWITCH_SHOW_FADE
//这里判断是否为常规的marquee
final boolean switchEllipsize = mEllipsize == TruncateAt.MARQUEE &&
mMarqueeFadeMode != MARQUEE_FADE_NORMAL;
TruncateAt effectiveEllipsize = mEllipsize;
if (mEllipsize == TruncateAt.MARQUEE &&
mMarqueeFadeMode == MARQUEE_FADE_SWITCH_SHOW_ELLIPSIS) {
effectiveEllipsize = TruncateAt.END_SMALL;
}
//获得排序方向，一般是LTR 左到右
if (mTextDir == null) {
mTextDir = getTextDirectionHeuristic();
}
//获得一个singleLayout,这个方法在下面分析
mLayout = makeSingleLayout(wantWidth, boring, ellipsisWidth, alignment, shouldEllipsize,
effectiveEllipsize, effectiveEllipsize == mEllipsize);
//如果是非常规的跑马灯，需要再创建一个mSavedMarqueeModeLayout，在播放跑马灯的时候
//把这个layout作为mLayout
if (switchEllipsize) {
TruncateAt oppositeEllipsize = effectiveEllipsize == TruncateAt.MARQUEE ?
TruncateAt.END : TruncateAt.MARQUEE;
mSavedMarqueeModeLayout = makeSingleLayout(wantWidth, boring, ellipsisWidth, alignment,
shouldEllipsize, oppositeEllipsize, effectiveEllipsize != mEllipsize);
}
shouldEllipsize = mEllipsize != null;
mHintLayout = null;
//如果有默认提示，还要计算hintLayout
if (mHint != null) {
//如果有省略号，那么提示文字的宽度就是实际能分配的宽度
if (shouldEllipsize) hintWidth = wantWidth;
//这段代码看着眼熟不？就是刚在onLayout()里分析的那段
if (hintBoring == UNKNOWN_BORING) {
//如果hint只是单行，无缩进，无spann那么就是把boring的矩阵赋值hintBoring
hintBoring = BoringLayout.isBoring(mHint, mTextPaint, mTextDir,
mHintBoring);
if (hintBoring != null) {
mHintBoring = hintBoring;
}
}
//这里有3层if嵌套，如果不仔细看，很容易晕
//主要分为3层逻辑
//最外层当前的hint是否是boring的，即单行无span
//第二层主要判断是否需要省略号，当前hint实际需要宽度是否大于计算得到的宽度
//如果仔细看了前面分析可以知道wantWidth,hintWidth和ellipsisWidth
//其实都是一个值 width-paddingleft-paddingRight
//即实际可以提供的宽度
//然后最里面那层就是判断mSavedHintLayout是否为null
//如果为null就make一个新的，不为null就把老的值更新
//先看如果是boring模式
if (hintBoring != null) {
//首先判断hint需要宽度是否小于实际给的宽度
if (hintBoring.width <= hintWidth &&
(!shouldEllipsize || hintBoring.width <= ellipsisWidth)) {
if (mSavedHintLayout != null) {
mHintLayout = mSavedHintLayout.
replaceOrMake(mHint, mTextPaint,
hintWidth, alignment, mSpacingMult, mSpacingAdd,
hintBoring, mIncludePad);
} else {
mHintLayout = BoringLayout.make(mHint, mTextPaint,
hintWidth, alignment, mSpacingMult, mSpacingAdd,
hintBoring, mIncludePad);
}
mSavedHintLayout = (BoringLayout) mHintLayout;
//如果不满足上面的要求
//再判断是否需要省略号，并且需要宽度是否小于实际给的宽度
//如果进入这个if条件的，都是设置了省略号，但是不需要显示的
} else if (shouldEllipsize && hintBoring.width <= hintWidth) {
if (mSavedHintLayout != null) {
mHintLayout = mSavedHintLayout.
replaceOrMake(mHint, mTextPaint,
hintWidth, alignment, mSpacingMult, mSpacingAdd,
hintBoring, mIncludePad, mEllipsize,
ellipsisWidth);
} else {
mHintLayout = BoringLayout.make(mHint, mTextPaint,
hintWidth, alignment, mSpacingMult, mSpacingAdd,
hintBoring, mIncludePad, mEllipsize,
ellipsisWidth);
}
//如果还是不满足
//到了这就应该是需要省略号，但是需要宽度是大于实际给的宽度
//那么就应该显示省略号了
} else if (shouldEllipsize) {
mHintLayout = new StaticLayout(mHint,
0, mHint.length(),
mTextPaint, hintWidth, alignment, mTextDir, mSpacingMult,
mSpacingAdd, mIncludePad, mEllipsize,
ellipsisWidth, mMaxMode == LINES ? mMaximum : Integer.MAX_VALUE);
} else {
mHintLayout = new StaticLayout(mHint, mTextPaint,
hintWidth, alignment, mTextDir, mSpacingMult, mSpacingAdd,
mIncludePad);
}
//到了这开始处理不是boring的hint
//如果不是boring的，需要省略号
} else if (shouldEllipsize) {
mHintLayout = new StaticLayout(mHint,
0, mHint.length(),
mTextPaint, hintWidth, alignment, mTextDir, mSpacingMult,
mSpacingAdd, mIncludePad, mEllipsize,
ellipsisWidth, mMaxMode == LINES ? mMaximum : Integer.MAX_VALUE);
//如果不是boring的，不需要省略号
} else {
mHintLayout = new StaticLayout(mHint, mTextPaint,
hintWidth, alignment, mTextDir, mSpacingMult, mSpacingAdd,
mIncludePad);
}
}
//如果文字方向发生变化了，就重新注册OnPreDrawListener
//OnPreDrawListener回调的时机是
//即将绘制视图树时执行的回调函数。这时所有的视图都测量完成并确定了框架。 客户端可以
//使用该方法来调整滚动边框，甚至可以在绘制之前请求新的布局。
if (bringIntoView || (testDirChange && oldDir != mLayout.getParagraphDirection(0))) {
registerForPreDraw();
}
//这里开始处理跑马灯
//如果需要播放跑马灯
if (mEllipsize == TextUtils.TruncateAt.MARQUEE) {
if (!compressText(ellipsisWidth)) {
final int height = mLayoutParams.height;
// If the size of the view does not depend on the size of the text, try to
// start the marquee immediately
//这里值得稍微留意是
//如果当前TextView的宽度不需要依赖内部文字的话
//直接就可以播放跑马灯了
if (height != LayoutParams.WRAP_CONTENT && height != LayoutParams.MATCH_PARENT) {
startMarquee();
} else {
// Defer the start of the marquee until we know our width (see setFrame())
mRestartMarquee = true;
}
}
}
// CursorControllers need a non-null mLayout
if (mEditor != null) mEditor.prepareCursorControllers();
}分析到这onMeasure()就结束了
让我们来看下onLayout()是如何实现的
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
//这里主要的逻辑就是bringPointIntoView
if (mDeferScroll >= 0) {
int curs = mDeferScroll;
mDeferScroll = -1;
bringPointIntoView(Math.min(curs, mText.length()));
}
}最后我们看下onDraw()的实现，看看文字是如何被绘制到屏幕上的
@Override
protected void onDraw(Canvas canvas) {
restartMarqueeIfNeeded();
// Draw the background for this view
super.onDraw(canvas);
//首先先计算padding和scorll的值
//还有判断是LTR还是RTS方向
final int compoundPaddingLeft = getCompoundPaddingLeft();
final int compoundPaddingTop = getCompoundPaddingTop();
final int compoundPaddingRight = getCompoundPaddingRight();
final int compoundPaddingBottom = getCompoundPaddingBottom();
final int scrollX = mScrollX;
final int scrollY = mScrollY;
final int right = mRight;
final int left = mLeft;
final int bottom = mBottom;
final int top = mTop;
final boolean isLayoutRtl = isLayoutRtl();
final int offset = getHorizontalOffsetForDrawables();
final int leftOffset = isLayoutRtl ? 0 : offset;
final int rightOffset = isLayoutRtl ? offset : 0 ;
//如果有drawable，那么先绘制draw
final Drawables dr = mDrawables;
if (dr != null) {
/*
* Compound, not extended, because the icon is not clipped
* if the text height is smaller.
*/
//计算水平和垂直空间
int vspace = bottom - top - compoundPaddingBottom - compoundPaddingTop;
int hspace = right - left - compoundPaddingRight - compoundPaddingLeft;
// IMPORTANT: The coordinates computed are also used in invalidateDrawable()
// Make sure to update invalidateDrawable() when changing this code.
//开始绘制DrawableLeft
if (dr.mDrawableLeft != null) {
//这里简单介绍下canvas.save()和canvas.restore()
//调用save之后，可以对canvas进行平移和旋转，确定新的原点然后绘制
//等绘制完了之后，可以把原点恢复原状
canvas.save();
canvas.translate(scrollX + mPaddingLeft + leftOffset,
scrollY + compoundPaddingTop +
(vspace - dr.mDrawableHeightLeft) / 2);
//个人认为TextView整个控件写了十分出彩
//TextView需要绘制背景，文字，Drawable
//谷歌在处理这个控件的时候，把不同的事交给不同的类去完成，充分解耦
//文字部分用Editor和layout处理
//图片部分用Drawable自行绘制
//整个TextView其实只是充当了容器作用
dr.mDrawableLeft.draw(canvas);
canvas.restore();
}
// IMPORTANT: The coordinates computed are also used in invalidateDrawable()
// Make sure to update invalidateDrawable() when changing this code.
if (dr.mDrawableRight != null) {
canvas.save();
canvas.translate(scrollX + right - left - mPaddingRight
- dr.mDrawableSizeRight - rightOffset,
scrollY + compoundPaddingTop + (vspace - dr.mDrawableHeightRight) / 2);
dr.mDrawableRight.draw(canvas);
canvas.restore();
}
// IMPORTANT: The coordinates computed are also used in invalidateDrawable()
// Make sure to update invalidateDrawable() when changing this code.
if (dr.mDrawableTop != null) {
canvas.save();
canvas.translate(scrollX + compoundPaddingLeft +
(hspace - dr.mDrawableWidthTop) / 2, scrollY + mPaddingTop);
dr.mDrawableTop.draw(canvas);
canvas.restore();
}
// IMPORTANT: The coordinates computed are also used in invalidateDrawable()
// Make sure to update invalidateDrawable() when changing this code.
if (dr.mDrawableBottom != null) {
canvas.save();
canvas.translate(scrollX + compoundPaddingLeft +
(hspace - dr.mDrawableWidthBottom) / 2,
scrollY + bottom - top - mPaddingBottom - dr.mDrawableSizeBottom);
dr.mDrawableBottom.draw(canvas);
canvas.restore();
}
}
int color = mCurTextColor;
//如果layout为null，通过刚分析的makeNewLayout()方法，再去获得一个Layout
if (mLayout == null) {
assumeLayout();
}
Layout layout = mLayout;
//如果当前没有文字，并且设置了hint，那么就显示hint
if (mHint != null && mText.length() == 0) {
if (mHintTextColor != null) {
color = mCurHintTextColor;
}
layout = mHintLayout;
}
mTextPaint.setColor(color);
mTextPaint.drawableState = getDrawableState();
canvas.save();
//感觉写TextView控件这位工程师对自己写的代码不是很自信，留下了很多疑问
//也许是Review之后忘了删除了，自己看的时候有时候会和有代入感，感觉在给别人review代码
/* Would be faster if we didn't have to do this. Can we chop the
(displayable) text so that we don't need to do this ever?
*/
int extendedPaddingTop = getExtendedPaddingTop();
int extendedPaddingBottom = getExtendedPaddingBottom();
final int vspace = mBottom - mTop - compoundPaddingBottom - compoundPaddingTop;
final int maxScrollY = mLayout.getHeight() - vspace;
//计算矩阵的上下左右4个坐标值
float clipLeft = compoundPaddingLeft + scrollX;
float clipTop = (scrollY == 0) ? 0 : extendedPaddingTop + scrollY;
float clipRight = right - left - compoundPaddingRight + scrollX;
float clipBottom = bottom - top + scrollY -
((scrollY == maxScrollY) ? 0 : extendedPaddingBottom);
//这里是处理文字阴影
if (mShadowRadius != 0) {
clipLeft += Math.min(0, mShadowDx - mShadowRadius);
clipRight += Math.max(0, mShadowDx + mShadowRadius);
clipTop += Math.min(0, mShadowDy - mShadowRadius);
clipBottom += Math.max(0, mShadowDy + mShadowRadius);
}
//在画布中裁剪出刚计算出来的矩阵大小
canvas.clipRect(clipLeft, clipTop, clipRight, clipBottom);
int voffsetText = 0;
int voffsetCursor = 0;
// translate in by our padding
/* shortcircuit calling getVerticaOffset() */
if ((mGravity & Gravity.VERTICAL_GRAVITY_MASK) != Gravity.TOP) {
voffsetText = getVerticalOffset(false);
voffsetCursor = getVerticalOffset(true);
}
canvas.translate(compoundPaddingLeft, extendedPaddingTop + voffsetText);
final int layoutDirection = getLayoutDirection();
final int absoluteGravity = Gravity.getAbsoluteGravity(mGravity, layoutDirection);
//如果有跑马灯，并且不是MARQUEE_FADE_SWITCH_SHOW_ELLIPSIS模式的话
if (mEllipsize == TextUtils.TruncateAt.MARQUEE &&
mMarqueeFadeMode != MARQUEE_FADE_SWITCH_SHOW_ELLIPSIS) {
//如果当前只有1行显示，并且不是SingleLine的，也不是Gravity.LEFT
if (!mSingleLine && getLineCount() == 1 && canMarquee() &&
(absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) != Gravity.LEFT) {
final int width = mRight - mLeft;
final int padding = getCompoundPaddingLeft() + getCompoundPaddingRight();
//dx值就是layout的宽度减去实际宽度再减去padding的值，主要是给RTL模式计算偏移量
final float dx = mLayout.getLineRight(0) - (width - padding);
canvas.translate(isLayoutRtl ? -dx : +dx, 0.0f);
}
if (mMarquee != null && mMarquee.isRunning()) {
final float dx = -mMarquee.getScroll();
canvas.translate(isLayoutRtl ? -dx : +dx, 0.0f);
}
}
final int cursorOffsetVertical = voffsetCursor - voffsetText;
//这里终于开始绘制文字了
Path highlight = getUpdatedHighlightPath();
//如果是EditText的就交给mEditor绘制，普通TextView，就交给layout处理
if (mEditor != null) {
mEditor.onDraw(canvas, layout, highlight, mHighlightPaint, cursorOffsetVertical);
} else {
layout.draw(canvas, highlight, mHighlightPaint, cursorOffsetVertical);
}
if (mMarquee != null && mMarquee.shouldDrawGhost()) {
final int dx = (int) mMarquee.getGhostOffset();
canvas.translate(isLayoutRtl ? -dx : dx, 0.0f);
layout.draw(canvas, highlight, mHighlightPaint, cursorOffsetVertical);
}
canvas.restore();
}总结
上文中主要分析了TextView的整个绘制流程，主要是从过程的角度分析了几个比较重要的阶段。
在下一篇TextView源码分析（二）中会具体分析Layout,Editor和Drawable是如何完成绘制，排版。