1
2
3
4
public class SlidingMenu extends RelativeLayout {
private CustomViewAbove mViewAbove;
private CustomViewBehind mViewBehind;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class SlidingMenu extends RelativeLayout {
public void setContent(int res) {
this.setContent(LayoutInflater.from(this.getContext()).inflate(res, (ViewGroup)null));
}
//设置Activity主视图
public void setContent(View view) {
this.mViewAbove.setContent(view);
this.showContent();
}
public void setMenu(int res) {
this.setMenu(LayoutInflater.from(this.getContext()).inflate(res, (ViewGroup)null));
}
//设置左侧菜单栏视图
public void setMenu(View v) {
this.mViewBehind.setContent(v);
}
public void setSecondaryMenu(int res) {
this.setSecondaryMenu(LayoutInflater.from(this.getContext()).inflate(res, (ViewGroup)null));
}
//设置右侧菜单栏视图
public void setSecondaryMenu(View v) {
this.mViewBehind.setSecondaryContent(v);
}
}

1
slidingMenu = new SlidingMenu(this);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
public SlidingMenu(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
this.mActionbarOverlay = false;
LayoutParams behindParams = new LayoutParams(-1, -1);
//底层视图主要添加左右菜单栏使用
this.mViewBehind = new CustomViewBehind(context);
this.addView(this.mViewBehind, behindParams);
LayoutParams aboveParams = new LayoutParams(-1, -1);
//上层视图主要添加主视图（当前Activity的视图）
this.mViewAbove = new CustomViewAbove(context);
this.addView(this.mViewAbove, aboveParams);
this.mViewAbove.setCustomViewBehind(this.mViewBehind);
this.mViewBehind.setCustomViewAbove(this.mViewAbove);
//设置监听菜单栏打开或者关闭接口
this.mViewAbove.setOnPageChangeListener(new OnPageChangeListener() {
public static final int POSITION_OPEN = 0;
public static final int POSITION_CLOSE = 1;
public static final int POSITION_SECONDARY_OPEN = 2;
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
}
public void onPageSelected(int position) {
if(position == 0 && SlidingMenu.this.mOpenListener != null) {
SlidingMenu.this.mOpenListener.onOpen();
} else if(position == 1 && SlidingMenu.this.mCloseListener != null) {
SlidingMenu.this.mCloseListener.onClose();
} else if(position == 2 && SlidingMenu.this.mSecondaryOpenListner != null) {
SlidingMenu.this.mSecondaryOpenListner.onOpen();
}
}
});
//设置菜单栏模式，左侧，右侧，左右同时同存在
//public static final int LEFT = 0;
//public static final int RIGHT = 1;
//public static final int LEFT_RIGHT = 2;
TypedArray ta = context.obtainStyledAttributes(attrs, styleable.SlidingMenu);
int mode = ta.getInt(styleable.SlidingMenu_mode, 0);
this.setMode(mode);
int viewAbove = ta.getResourceId(styleable.SlidingMenu_viewAbove, -1);
//设置空的主视图
if(viewAbove != -1) {
this.setContent(viewAbove);
} else {
this.setContent(new FrameLayout(context));
}
//设置空的菜单栏视图
int viewBehind = ta.getResourceId(styleable.SlidingMenu_viewBehind, -1);
if(viewBehind != -1) {
this.setMenu(viewBehind);
} else {
this.setMenu(new FrameLayout(context));
}
//设置显示菜单栏显示操作模式
//public static final int TOUCHMODE_MARGIN = 0;
// public static final int TOUCHMODE_FULLSCREEN = 1;
//public static final int TOUCHMODE_NONE = 2;
int touchModeAbove = ta.getInt(styleable.SlidingMenu_touchModeAbove, 0);
this.setTouchModeAbove(touchModeAbove);
int touchModeBehind = ta.getInt(styleable.SlidingMenu_touchModeBehind, 0);
this.setTouchModeBehind(touchModeBehind);
//设置视图显示样式
int offsetBehind = (int)ta.getDimension(styleable.SlidingMenu_behindOffset, -1.0F);
int widthBehind = (int)ta.getDimension(styleable.SlidingMenu_behindWidth, -1.0F);
if(offsetBehind != -1 && widthBehind != -1) {
throw new IllegalStateException("Cannot set both behindOffset and behindWidth for a SlidingMenu");
} else {
if(offsetBehind != -1) {
this.setBehindOffset(offsetBehind);
} else if(widthBehind != -1) {
this.setBehindWidth(widthBehind);
} else {
this.setBehindOffset(0);
}
float scrollOffsetBehind = ta.getFloat(styleable.SlidingMenu_behindScrollScale, 0.33F);
this.setBehindScrollScale(scrollOffsetBehind);
int shadowRes = ta.getResourceId(styleable.SlidingMenu_shadowDrawable, -1);
if(shadowRes != -1) {
this.setShadowDrawable(shadowRes);
}
//设置阴影效果
int shadowWidth = (int)ta.getDimension(styleable.SlidingMenu_shadowWidth, 0.0F);
this.setShadowWidth(shadowWidth);
boolean fadeEnabled = ta.getBoolean(styleable.SlidingMenu_fadeEnabled, true);
this.setFadeEnabled(fadeEnabled);
float fadeDeg = ta.getFloat(styleable.SlidingMenu_fadeDegree, 0.33F);
this.setFadeDegree(fadeDeg);
boolean selectorEnabled = ta.getBoolean(styleable.SlidingMenu_selectorEnabled, false);
this.setSelectorEnabled(selectorEnabled);
int selectorRes = ta.getResourceId(styleable.SlidingMenu_selectorDrawable, -1);
if(selectorRes != -1) {
this.setSelectorDrawable(selectorRes);
}
ta.recycle();
}
}

1
2
3
4
5
6
slidingMenu.setMode(SlidingMenu.LEFT_RIGHT);
// 设置触摸屏幕的模式
slidingMenu.setTouchModeAbove(SlidingMenu.TOUCHMODE_FULLSCREEN);
// 设置渐入渐出效果的值
slidingMenu.setFadeDegree(0.35f);
slidingMenu.setFadeEnabled(true);

1
2
3
4
5
6
7
8
9
10
11
12
/** Constant value for use with setMode(). Puts the menu to the left of the content.
*/
/**方法setMode()使用的常量.把菜单放在内容的左边*/
public static final int LEFT = 0;
/** Constant value for use with setMode(). Puts the menu to the right of the content.
*/
/**方法setMode()使用的常量.把菜单放在内容的右边*/
public static final int RIGHT = 1;
/** Constant value for use with setMode(). Puts menus to the left and right of the content.
*/
/**方法setMode()使用的常量.把菜单放在内容的左边和右边*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/** Constant value for use with setTouchModeAbove(). Allows the SlidingMenu to be opened with a swipe
* gesture on the screen's margin
*/
/**使用setTouchModeAbove()的常量.允许SlidingMenu在屏幕的边缘通过一个猛击的手势打开.
*/
public static final int TOUCHMODE_MARGIN = 0;
/** Constant value for use with setTouchModeAbove(). Allows the SlidingMenu to be opened with a swipe
* gesture anywhere on the screen
*/
/**使用setTouchModeAbove()的常量.允许SlidingMenu在屏幕的任何地方通过一个猛击的手势打开.
*/
public static final int TOUCHMODE_FULLSCREEN = 1;
/** Constant value for use with setTouchModeAbove(). Denies the SlidingMenu to be opened with a swipe
* gesture
*/
/**使用setTouchModeAbove()的常量.不允许SlidingMenu通过一个猛击的手势打开.
*/
public static final int TOUCHMODE_NONE = 2;

1
2
//使SlidingMenu附加在Activity上
slidingMenu.attachToActivity(this, SlidingMenu.SLIDING_CONTENT);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public void attachToActivity(Activity activity, int slideStyle, boolean actionbarOverlay) {
if(slideStyle != 0 && slideStyle != 1) {
throw new IllegalArgumentException("slideStyle must be either SLIDING_WINDOW or SLIDING_CONTENT");
} else if(this.getParent() != null) {
throw new IllegalStateException("This SlidingMenu appears to already be attached");
} else {
TypedArray a = activity.getTheme().obtainStyledAttributes(new int[]{16842836});
int background = a.getResourceId(0, 0);
a.recycle();
switch(slideStyle) {
case 0:
this.mActionbarOverlay = false;
ViewGroup decor = (ViewGroup)activity.getWindow().getDecorView();
ViewGroup decorChild = (ViewGroup)decor.getChildAt(0);
decorChild.setBackgroundResource(background);
decor.removeView(decorChild);
decor.addView(this);
this.setContent(decorChild);
break;
case 1:
this.mActionbarOverlay = actionbarOverlay;
ViewGroup contentParent = (ViewGroup)activity.findViewById(16908290);//获取Activity根视图
View content = contentParent.getChildAt(0); //获取Activity根视图下的第一个视图（setContentView添加的）
contentParent.removeView(content);//Activity根视图下的第一个视图（setContentView添加的）
contentParent.addView(this);将SlidingMenu视图添加到根视图
this.setContent(content);//将Activity根视图下的第一个视图（setContentView添加的）添加到SlidingMenu下的上层视图
if(content.getBackground() == null) {
content.setBackgroundResource(background);
}
}
}
}

1
2
3
4
5
6
slidingMenu.setMenu(R.layout.left_menu);
leftMenu = new LeftMenuFragment();
getSupportFragmentManager().beginTransaction().add(R.id.left_menu, leftMenu).commit();
slidingMenu.setSecondaryMenu(R.layout.right_menu);
rightMenu = new RightMenuFragment();
getSupportFragmentManager().beginTransaction().add(R.id.right_menu, rightMenu).commit();

1
2
3
4
5
6
7
8
9
10
11
12
13
SlidingView
public void setMenu(int res) {
this.setMenu(LayoutInflater.from(this.getContext()).inflate(res, (ViewGroup)null));
}
public void setMenu(View v) {
this.mViewBehind.setContent(v);
}
public void setSecondaryMenu(int res) {
this.setSecondaryMenu(LayoutInflater.from(this.getContext()).inflate(res, (ViewGroup)null));
}
public void setSecondaryMenu(View v) {
this.mViewBehind.setSecondaryContent(v);
}

1
slidingMenu.showContent();

1
2
3
4
5
6
7

public static final int ACTION_DOWN
= 0; //按下
public static final int ACTION_UP
= 1; //抬起
public static final int ACTION_MOVE
= 2; //滑动

1
2
3
4
5
6
7

case MotionEvent.ACTION_DOWN:
this.completeScroll();
int index = MotionEventCompat.getActionIndex(ev);
this.mActivePointerId = MotionEventCompat.getPointerId(ev, index);
this.mLastMotionX = this.mInitialMotionX = ev.getX();
break;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
case MotionEvent.ACTION_MOVE:
if(!this.mIsBeingDragged) {
this.determineDrag(ev);
if(this.mIsUnableToDrag) {
return false;
}
}
if(this.mIsBeingDragged) {
activePointerIndex = this.getPointerIndex(ev, this.mActivePointerId);
if(this.mActivePointerId != -1) {
float x = MotionEventCompat.getX(ev, activePointerIndex);
float deltaX = this.mLastMotionX - x;
this.mLastMotionX = x;
oldScrollX = (float)this.getScrollX();
float scrollX = oldScrollX + deltaX;
leftBound = (float)this.getLeftBound();
float rightBound = (float)this.getRightBound();
if(scrollX < leftBound) {
scrollX = leftBound;
} else if(scrollX > rightBound) {
scrollX = rightBound;
}
this.mLastMotionX += scrollX - (float)((int)scrollX);
this.scrollTo((int)scrollX, this.getScrollY());
this.pageScrolled((int)scrollX);
}
}
break;
case 3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private void determineDrag(MotionEvent ev) {
//多点触碰的activity第一个点的id
int activePointerId = this.mActivePointerId;
//多点触碰的activity第一个点的id对应的索引，代表每个手指的索引值
int pointerIndex = this.getPointerIndex(ev, activePointerId);
if(activePointerId != -1 && pointerIndex != -1) {
float x = MotionEventCompat.getX(ev, pointerIndex);
float dx = x - this.mLastMotionX;
float xDiff = Math.abs(dx);
float y = MotionEventCompat.getY(ev, pointerIndex);
float dy = y - this.mLastMotionY;
float yDiff = Math.abs(dy);
if(xDiff > (float)(this.isMenuOpen()?this.mTouchSlop / 2:this.mTouchSlop) && xDiff > yDiff && this.thisSlideAllowed(dx)) {
this.startDrag();
this.mLastMotionX = x;
this.mLastMotionY = y;
this.setScrollingCacheEnabled(true);
} else if(xDiff > (float)this.mTouchSlop) {
this.mIsUnableToDrag = true;
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//CustomViewAbove
private boolean thisSlideAllowed(float dx) {
boolean allowed = false;
if(this.isMenuOpen()) {
allowed = this.mViewBehind.menuOpenSlideAllowed(dx);
} else {
allowed = this.mViewBehind.menuClosedSlideAllowed(dx);
}
return allowed;
}
//CustomViewBehind
public boolean menuClosedSlideAllowed(float dx) {
return this.mMode == 0?dx > 0.0F:(this.mMode == 1?dx < 0.0F:this.mMode == 2);
}
public boolean menuOpenSlideAllowed(float dx) {
return this.mMode == 0?dx < 0.0F:(this.mMode == 1?dx > 0.0F:this.mMode == 2);
}

1
2
3
4
5
6
public void scrollTo(int x, int y) {
super.scrollTo(x, y);
this.mScrollX = (float)x;
this.mViewBehind.scrollBehindTo(this.mContent, x, y);
((SlidingMenu)this.getParent()).manageLayers(this.getPercentOpen());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
case MotionEvent.ACTION_UP:
if(this.mIsBeingDragged) {
VelocityTracker velocityTracker = this.mVelocityTracker;
velocityTracker.computeCurrentVelocity(1000, (float)this.mMaximumVelocity);
int initialVelocity = (int)VelocityTrackerCompat.getXVelocity(velocityTracker, this.mActivePointerId);
int scrollX = this.getScrollX();
oldScrollX = (float)(scrollX - this.getDestScrollX(this.mCurItem)) / (float)this.getBehindWidth();
int activePointerIndex = this.getPointerIndex(ev, this.mActivePointerId);
if(this.mActivePointerId != -1) {
leftBound = MotionEventCompat.getX(ev, activePointerIndex);
int totalDelta = (int)(leftBound - this.mInitialMotionX);
int nextPage = this.determineTargetPage(oldScrollX, initialVelocity, totalDelta);
this.setCurrentItemInternal(nextPage, true, true, initialVelocity);
} else {
this.setCurrentItemInternal(this.mCurItem, true, true, initialVelocity);
}
this.mActivePointerId = -1;
this.endDrag();
} else if(this.mQuickReturn && this.mViewBehind.menuTouchInQuickReturn(this.mContent, this.mCurItem, ev.getX() + this.mScrollX)) {
this.setCurrentItem(1);
this.endDrag();
}
break;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private int determineTargetPage(float pageOffset, int velocity, int deltaX) {
int targetPage = this.mCurItem;
if(Math.abs(deltaX) > this.mFlingDistance && Math.abs(velocity) > this.mMinimumVelocity) {
if(velocity > 0 && deltaX > 0) {
--targetPage;
} else if(velocity < 0 && deltaX < 0) {
++targetPage;
}
} else {
targetPage = Math.round((float)this.mCurItem + pageOffset);
}
return targetPage;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int velocity) {
if(!always && this.mCurItem == item) {
this.setScrollingCacheEnabled(false);
} else {
item = this.mViewBehind.getMenuPage(item);
boolean dispatchSelected = this.mCurItem != item;
this.mCurItem = item;
int destX = this.getDestScrollX(this.mCurItem);
if(dispatchSelected && this.mOnPageChangeListener != null) {
this.mOnPageChangeListener.onPageSelected(item);
}
if(dispatchSelected && this.mInternalPageChangeListener != null) {
this.mInternalPageChangeListener.onPageSelected(item);
}
if(smoothScroll) {
this.smoothScrollTo(destX, 0, velocity);
} else {
this.completeScroll();
this.scrollTo(destX, 0);
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
void smoothScrollTo(int x, int y, int velocity) {
if(this.getChildCount() == 0) {
this.setScrollingCacheEnabled(false);
} else {
int sx = this.getScrollX();
int sy = this.getScrollY();
int dx = x - sx;
int dy = y - sy;
if(dx == 0 && dy == 0) {
this.completeScroll();
if(this.isMenuOpen()) {
if(this.mOpenedListener != null) {
this.mOpenedListener.onOpened();
}
} else if(this.mClosedListener != null) {
this.mClosedListener.onClosed();
}
} else {
this.setScrollingCacheEnabled(true);
this.mScrolling = true;
int width = this.getBehindWidth();
int halfWidth = width / 2;
float distanceRatio = Math.min(1.0F, 1.0F * (float)Math.abs(dx) / (float)width);
float distance = (float)halfWidth + (float)halfWidth * this.distanceInfluenceForSnapDuration(distanceRatio);
int duration = false;
velocity = Math.abs(velocity);
int duration;
if(velocity > 0) {
duration = 4 * Math.round(1000.0F * Math.abs(distance / (float)velocity));
} else {
float pageDelta = (float)Math.abs(dx) / (float)width;
duration = (int)((pageDelta + 1.0F) * 100.0F);
duration = 600;
}
duration = Math.min(duration, 600);
this.mScroller.startScroll(sx, sy, dx, dy, duration);
this.invalidate();
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public boolean onInterceptTouchEvent(MotionEvent ev) {
if(!this.mEnabled) {
return false;
} else {
int action = ev.getAction() & 255;
if(action != 3 && action != 1 && (action == 0 || !this.mIsUnableToDrag)) {
switch(action) {
case 0:
int index = MotionEventCompat.getActionIndex(ev);
this.mActivePointerId = MotionEventCompat.getPointerId(ev, index);
if(this.mActivePointerId != -1) {
this.mLastMotionX = this.mInitialMotionX = MotionEventCompat.getX(ev, index);
this.mLastMotionY = MotionEventCompat.getY(ev, index);
if(this.thisTouchAllowed(ev)) {
this.mIsBeingDragged = false;
this.mIsUnableToDrag = false;
if(this.isMenuOpen() && this.mViewBehind.menuTouchInQuickReturn(this.mContent, this.mCurItem, ev.getX() + this.mScrollX)) {
this.mQuickReturn = true;
}
} else {
this.mIsUnableToDrag = true;
}
}
break;
case 2:
this.determineDrag(ev);
break;
case 6:
this.onSecondaryPointerUp(ev);
}
if(!this.mIsBeingDragged) {
if(this.mVelocityTracker == null) {
this.mVelocityTracker = VelocityTracker.obtain();
}
this.mVelocityTracker.addMovement(ev);
}
return this.mIsBeingDragged || this.mQuickReturn;
} else {
this.endDrag();
return false;
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
 @Override
public void onBackPressed() {
if (slidingMenu.isMenuShowing() || slidingMenu.isSecondaryMenuShowing()) {
slidingMenu.showContent();
} else {
if (System.currentTimeMillis() - mLastClickTime <= 2000L) {
super.onBackPressed();
} else {
mLastClickTime = System.currentTimeMillis();
Toast.makeText(this, "再按一次退出", Toast.LENGTH_SHORT).show();
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public void scrollBehindTo(View content, int x, int y) {
int vis = 0;
if(this.mMode == 0) {
if(x >= content.getLeft()) {
vis = 4;
}
this.scrollTo((int)((float)(x + this.getBehindWidth()) * this.mScrollScale), y);
} else if(this.mMode == 1) {
if(x <= content.getLeft()) {
vis = 4;
}
this.scrollTo((int)((float)(this.getBehindWidth() - this.getWidth()) + (float)(x - this.getBehindWidth()) * this.mScrollScale), y);
} else if(this.mMode == 2) {
this.mContent.setVisibility(x >= content.getLeft()?4:0);
this.mSecondaryContent.setVisibility(x <= content.getLeft()?4:0);
vis = x == 0?4:0;
if(x <= content.getLeft()) {
this.scrollTo((int)((float)(x + this.getBehindWidth()) * this.mScrollScale), y);
} else {
this.scrollTo((int)((float)(this.getBehindWidth() - this.getWidth()) + (float)(x - this.getBehindWidth()) * this.mScrollScale), y);
}
}
if(vis == 4) {
Log.v("CustomViewBehind", "behind INVISIBLE");
}
this.setVisibility(vis);
}

1
2
3
if(x >= content.getLeft()) {
vis = 4;
}

1
2
3
4
5
6
protected void dispatchDraw(Canvas canvas) {
super.dispatchDraw(canvas);
this.mViewBehind.drawShadow(this.mContent, canvas);
this.mViewBehind.drawFade(this.mContent, canvas, this.getPercentOpen());
this.mViewBehind.drawSelector(this.mContent, canvas, this.getPercentOpen());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void drawShadow(View content, Canvas canvas) {
if(this.mShadowDrawable != null && this.mShadowWidth > 0) {
int left = 0;
if(this.mMode == 0) {
left = content.getLeft() - this.mShadowWidth;
} else if(this.mMode == 1) {
left = content.getRight();
} else if(this.mMode == 2) {
if(this.mSecondaryShadowDrawable != null) {
left = content.getRight();
this.mSecondaryShadowDrawable.setBounds(left, 0, left + this.mShadowWidth, this.getHeight());
this.mSecondaryShadowDrawable.draw(canvas);
}
left = content.getLeft() - this.mShadowWidth;
}
this.mShadowDrawable.setBounds(left, 0, left + this.mShadowWidth, this.getHeight());
this.mShadowDrawable.draw(canvas);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public void drawFade(View content, Canvas canvas, float openPercent) {
if(this.mFadeEnabled) {
int alpha = (int)(this.mFadeDegree * 255.0F * Math.abs(1.0F - openPercent));
this.mFadePaint.setColor(Color.argb(alpha, 0, 0, 0));
int left = 0;
int right = 0;
if(this.mMode == 0) {
left = content.getLeft() - this.getBehindWidth();
right = content.getLeft();
} else if(this.mMode == 1) {
left = content.getRight();
right = content.getRight() + this.getBehindWidth();
} else if(this.mMode == 2) {
left = content.getLeft() - this.getBehindWidth();
right = content.getLeft();
canvas.drawRect((float)left, 0.0F, (float)right, (float)this.getHeight(), this.mFadePaint);
left = content.getRight();
right = content.getRight() + this.getBehindWidth();
}
canvas.drawRect((float)left, 0.0F, (float)right, (float)this.getHeight(), this.mFadePaint);
}
}