Android翻页效果原理实现之曲线的实现

炮兵镇楼

上一节我们通过引入折线实现了页面的折叠翻转效果，有了前面两节的基础呢其实曲线的实现可以变得非常简单，为什么这么说呢？因为曲线无非就是在折线的基础上对Path加入了曲线的实现，进而只是影响了我们的Region区域，而其他的什么事件啊、滑动计算啊之类的几乎都是不变的对吧，说白了就是对现有的折线View进行update改造，虽然是改造，但是我们该如何下手呢？首先我们来看看现实中翻页的效果应该是怎样的呢？如果大家身边有书或本子甚至一张纸也行，尝试以不同的方式去翻动它，你会发现除了我们前面两节曾提到过的一些限制外，还有一些special的现象：

一、翻起来的区域从侧面来看是一个有弧度的区域，如图所示侧面图：

而我们将按照第一节中的约定忽略这部分弧度的表现，因为从正俯视的角度我们压根看不到弧度的效果，So~我们强制让其与页面平行：

二、根据拖拽点距离页面高度的不同，我们可以得到不同的卷曲度：

而其在我们正俯视点的表现则是曲线的弧度不同：

同样的，我们按照第一节的约定，为了简化问题，我们将拖拽点距离页面的高度视为一个定值使在我们正俯视点表现的曲线起点从距离控件交点1/4处开始：

三、如上一节末所说，在弯曲的区域图像也会有相似的扭曲效果

OK，大致的一个分析就是这样，我们根据分析结果可以得出下面的一个分析图：

由上图配合我们上面的分析我们可知：DB = 1/4OB，FA = 1/4OA，而点F和点D分别为两条曲线（如无特殊声明，我们所说的曲线均为贝赛尔曲线，下同）的起点（当然你也可以说是终点无所谓），这时，我们以点A、B为曲线的控制点并以其为端点分别沿着x轴和y轴方向作线段AG、BC，另AG = AF、BC = BD，并令点G、C分别为曲线的终点，这样，我们的这两条二阶贝塞尔曲线就非常非常的特殊，例如上图中的曲线DC，它是由起始点D、C和控制点B构成，而BD = BC，也就是说三角形BDC是的等腰三角形，进一步地说就是曲线DC的两条控制杆力臂相等，进一步地我们可以推断出曲线DC的顶点J必定在直线DC的中垂线上，更进一步地我们可以根据《自定义控件其实很简单5/12》所说的二阶贝塞尔曲线公式得出当且仅当t = 0.5时曲线的端点刚好会在顶点J上，由此我们可以非常非常简单地得到曲线的顶点坐标。好了，YY归YY我们还是要回归到具体的操作中来，首先，我们要计算出点G、F、D、C的坐标值，这四点坐标也相当easy，就拿F点坐标来说，我们过点F分别作OM、AM的垂线：

因为FA = 1/4OA，那么我们可以得到F点的x坐标Fx = a + 3/4MA，y坐标Fy = b + 3/4OM，而G点的x坐标Gx = a + MA - 1/4x；其他两点D、C就不多扯了，那么在代码中如何体现呢？首先，为了便于观察效果，我们先注释掉图片的绘制：

[java]  view plain copy print ?

1. /* 
2.  * 如果坐标点在原点（即还没发生触碰时）则绘制第一页 
3.  */  
4. if (mPointX == 0 && mPointY == 0) {  
5.     // canvas.drawBitmap(mBitmaps.get(mBitmaps.size() - 1), 0, 0, null);  
6.     return;  
7. }  
8.   
9. // 省略大量代码  
10.   
11. //drawBitmaps(canvas);  

并绘制线条：

[java]  view plain copy print ?

1. canvas.drawPath(mPath, mPaint);  

在上一节中我们在生成Path时将情况分为了两种：

[java]  view plain copy print ?

1. if (sizeLong > mViewHeight) {  
2.     //…………………………  
3. } else {  
4.     //…………………………  
5. }  

同样，我们也分开处理两种情况，那么针对sizeLong > mViewHeight的时候此时控件顶部的曲线效果已经是看不到了，我们只需考虑底部的曲线效果：

[java]  view plain copy print ?

1. // 计算曲线起点  
2. float startXBtm = btmX2 - CURVATURE * sizeShort;  
3. float startYBtm = mViewHeight;  
4.   
5. // 计算曲线终点  
6. float endXBtm = mPointX + (1 - CURVATURE) * (tempAM);  
7. float endYBtm = mPointY + (1 - CURVATURE) * mL;  
8.   
9. // 计算曲线控制点  
10. float controlXBtm = btmX2;  
11. float controlYBtm = mViewHeight;  
12.   
13. // 计算曲线顶点  
14. float bezierPeakXBtm = 0.25F * startXBtm + 0.5F * controlXBtm + 0.25F * endXBtm;  
15. float bezierPeakYBtm = 0.25F * startYBtm + 0.5F * controlYBtm + 0.25F * endYBtm;  
16.   
17. /* 
18.  * 生成带曲线的四边形路径 
19.  */  
20. mPath.moveTo(startXBtm, startYBtm);  
21. mPath.quadTo(controlXBtm, controlYBtm, endXBtm, endYBtm);  
22. mPath.lineTo(mPointX, mPointY);  
23. mPath.lineTo(topX1, 0);  
24. mPath.lineTo(topX2, 0);  
25. mPath.lineTo(bezierPeakXBtm, bezierPeakYBtm);  

该部分的实际效果如下：

PS：为了便于大家对参数的理解，我对每一个点的坐标都重新给予了一个引用其命名也浅显易懂，实际过程可以省略这一步简化代码

而当sizeLong <= mViewHeight时这时候不但底部有曲线效果，右侧也有：

[java]  view plain copy print ?

1. /* 
2.  * 计算参数 
3.  */  
4. float leftY = mViewHeight - sizeLong;  
5. float btmX = mViewWidth - sizeShort;  
6.   
7. // 计算曲线起点  
8. float startXBtm = btmX - CURVATURE * sizeShort;  
9. float startYBtm = mViewHeight;  
10. float startXLeft = mViewWidth;  
11. float startYLeft = leftY - CURVATURE * sizeLong;  
12.   
13. /* 
14.  * 限制左侧曲线起点 
15.  */  
16. if (startYLeft <= 0) {  
17.     startYLeft = 0;  
18. }  
19.   
20. /* 
21.  * 限制右侧曲线起点 
22.  */  
23. if (startXBtm <= 0) {  
24.     startXBtm = 0;  
25. }  
26.   
27. // 计算曲线终点  
28. float endXBtm = mPointX + (1 - CURVATURE) * (tempAM);  
29. float endYBtm = mPointY + (1 - CURVATURE) * mL;  
30. float endXLeft = mPointX + (1 - CURVATURE) * mK;  
31. float endYLeft = mPointY - (1 - CURVATURE) * (sizeLong - mL);  
32.   
33. // 计算曲线控制点  
34. float controlXBtm = btmX;  
35. float controlYBtm = mViewHeight;  
36. float controlXLeft = mViewWidth;  
37. float controlYLeft = leftY;  
38.   
39. // 计算曲线顶点  
40. float bezierPeakXBtm = 0.25F * startXBtm + 0.5F * controlXBtm + 0.25F * endXBtm;  
41. float bezierPeakYBtm = 0.25F * startYBtm + 0.5F * controlYBtm + 0.25F * endYBtm;  
42. float bezierPeakXLeft = 0.25F * startXLeft + 0.5F * controlXLeft + 0.25F * endXLeft;  
43. float bezierPeakYLeft = 0.25F * startYLeft + 0.5F * controlYLeft + 0.25F * endYLeft;  
44.   
45. /* 
46.  * 生成带曲线的三角形路径 
47.  */  
48. mPath.moveTo(startXBtm, startYBtm);  
49. mPath.quadTo(controlXBtm, controlYBtm, endXBtm, endYBtm);  
50. mPath.lineTo(mPointX, mPointY);  
51. mPath.lineTo(endXLeft, endYLeft);  
52. mPath.quadTo(controlXLeft, controlYLeft, startXLeft, startYLeft);  

效果如下：

Path有了，我们就该考虑如何将其转换为Region，在这个过程中呢又一个问题，曲线路径不像上一节的直线路径我们可以轻易获得其范围区域，因为我们的折叠区域其实应该是这样的：

如图所示红色路径区域，这部分区域则是我们折叠的区域，而事实上我们为了计算方便将整条二阶贝赛尔曲线都绘制了出来，也就是说我们的Path除了红色线条部分还包含了蓝色线条部分对吧，那么问题来了，如何将这两部分“做掉”呢？其实方法很多，我们可以在计算的时候就只生成半条曲线，这是方法一我们利用纯计算的方式，记得我在该系列文章开头曾说过翻页效果的实现可以有两种方式，一种是纯计算而另一种则是利用图形的组合思想，如何组合呢？这里对于区域的计算我们就不用纯计算的方式了，我们尝试用图形组合来试试。首先我们将Path转为Region看看是什么样的：

[java]  view plain copy print ?

1. Region region = computeRegion(mPath);  
2. canvas.clipRegion(region);  
3. canvas.drawColor(Color.RED);  
4. // canvas.drawPath(mPath, mPaint);  

效果如下：

可以看到我们没有封闭的Path形成的Region效果，事实呢跟我们需要的区域差距有点大，首先上下两个月半圆是多余的，其次目测少了一块对吧：

如上图蓝色的那块，那么我们该如何把这块“补”回来呢？利用图形组合的思想，我们设法为该Region补一块矩形：

然后差集掉两个月半圆不就成了？这部分代码改动较大，我先贴代码再说吧：

[java]  view plain copy print ?

1. if (sizeLong > mViewHeight) {  
2.     // 计算……额……按图来AN边~  
3.     float an = sizeLong - mViewHeight;  
4.   
5.     // 三角形AMN的MN边  
6.     float largerTrianShortSize = an / (sizeLong - (mViewHeight - mPointY)) * (mViewWidth - mPointX);  
7.   
8.     // 三角形AQN的QN边  
9.     float smallTrianShortSize = an / sizeLong * sizeShort;  
10.   
11.     /* 
12.      * 计算参数 
13.      */  
14.     float topX1 = mViewWidth - largerTrianShortSize;  
15.     float topX2 = mViewWidth - smallTrianShortSize;  
16.     float btmX2 = mViewWidth - sizeShort;  
17.   
18.     // 计算曲线起点  
19.     float startXBtm = btmX2 - CURVATURE * sizeShort;  
20.     float startYBtm = mViewHeight;  
21.   
22.     // 计算曲线终点  
23.     float endXBtm = mPointX + (1 - CURVATURE) * (tempAM);  
24.     float endYBtm = mPointY + (1 - CURVATURE) * mL;  
25.   
26.     // 计算曲线控制点  
27.     float controlXBtm = btmX2;  
28.     float controlYBtm = mViewHeight;  
29.   
30.     // 计算曲线顶点  
31.     float bezierPeakXBtm = 0.25F * startXBtm + 0.5F * controlXBtm + 0.25F * endXBtm;  
32.     float bezierPeakYBtm = 0.25F * startYBtm + 0.5F * controlYBtm + 0.25F * endYBtm;  
33.   
34.     /* 
35.      * 生成带曲线的四边形路径 
36.      */  
37.     mPath.moveTo(startXBtm, startYBtm);  
38.     mPath.quadTo(controlXBtm, controlYBtm, endXBtm, endYBtm);  
39.     mPath.lineTo(mPointX, mPointY);  
40.     mPath.lineTo(topX1, 0);  
41.     mPath.lineTo(topX2, 0);  
42.   
43.     /* 
44.      * 替补区域Path 
45.      */  
46.     mPathTrap.moveTo(startXBtm, startYBtm);  
47.     mPathTrap.lineTo(topX2, 0);  
48.     mPathTrap.lineTo(bezierPeakXBtm, bezierPeakYBtm);  
49.     mPathTrap.close();  
50.   
51.     /* 
52.      * 底部月半圆Path 
53.      */  
54.     mPathSemicircleBtm.moveTo(startXBtm, startYBtm);  
55.     mPathSemicircleBtm.quadTo(controlXBtm, controlYBtm, endXBtm, endYBtm);  
56.     mPathSemicircleBtm.close();  
57.   
58.     /* 
59.      * 生成包含折叠和下一页的路径 
60.      */  
61.     //暂时没用省略掉  
62.   
63.     // 计算月半圆区域  
64.     mRegionSemicircle = computeRegion(mPathSemicircleBtm);  
65. } else {  
66.     /* 
67.      * 计算参数 
68.      */  
69.     float leftY = mViewHeight - sizeLong;  
70.     float btmX = mViewWidth - sizeShort;  
71.   
72.     // 计算曲线起点  
73.     float startXBtm = btmX - CURVATURE * sizeShort;  
74.     float startYBtm = mViewHeight;  
75.     float startXLeft = mViewWidth;  
76.     float startYLeft = leftY - CURVATURE * sizeLong;  
77.   
78.     // 计算曲线终点  
79.     float endXBtm = mPointX + (1 - CURVATURE) * (tempAM);  
80.     float endYBtm = mPointY + (1 - CURVATURE) * mL;  
81.     float endXLeft = mPointX + (1 - CURVATURE) * mK;  
82.     float endYLeft = mPointY - (1 - CURVATURE) * (sizeLong - mL);  
83.   
84.     // 计算曲线控制点  
85.     float controlXBtm = btmX;  
86.     float controlYBtm = mViewHeight;  
87.     float controlXLeft = mViewWidth;  
88.     float controlYLeft = leftY;  
89.   
90.     // 计算曲线顶点  
91.     float bezierPeakXBtm = 0.25F * startXBtm + 0.5F * controlXBtm + 0.25F * endXBtm;  
92.     float bezierPeakYBtm = 0.25F * startYBtm + 0.5F * controlYBtm + 0.25F * endYBtm;  
93.     float bezierPeakXLeft = 0.25F * startXLeft + 0.5F * controlXLeft + 0.25F * endXLeft;  
94.     float bezierPeakYLeft = 0.25F * startYLeft + 0.5F * controlYLeft + 0.25F * endYLeft;  
95.   
96.     /* 
97.      * 限制右侧曲线起点 
98.      */  
99.     if (startYLeft <= 0) {  
100.         startYLeft = 0;  
101.     }  
102.   
103.     /* 
104.      * 限制底部左侧曲线起点 
105.      */  
106.     if (startXBtm <= 0) {  
107.         startXBtm = 0;  
108.     }  
109.   
110.     /* 
111.      * 根据底部左侧限制点重新计算贝塞尔曲线顶点坐标 
112.      */  
113.     float partOfShortLength = CURVATURE * sizeShort;  
114.     if (btmX >= -mValueAdded && btmX <= partOfShortLength - mValueAdded) {  
115.         float f = btmX / partOfShortLength;  
116.         float t = 0.5F * f;  
117.   
118.         float bezierPeakTemp = 1 - t;  
119.         float bezierPeakTemp1 = bezierPeakTemp * bezierPeakTemp;  
120.         float bezierPeakTemp2 = 2 * t * bezierPeakTemp;  
121.         float bezierPeakTemp3 = t * t;  
122.   
123.         bezierPeakXBtm = bezierPeakTemp1 * startXBtm + bezierPeakTemp2 * controlXBtm + bezierPeakTemp3 * endXBtm;  
124.         bezierPeakYBtm = bezierPeakTemp1 * startYBtm + bezierPeakTemp2 * controlYBtm + bezierPeakTemp3 * endYBtm;  
125.     }  
126.   
127.     /* 
128.      * 根据右侧限制点重新计算贝塞尔曲线顶点坐标 
129.      */  
130.     float partOfLongLength = CURVATURE * sizeLong;  
131.     if (leftY >= -mValueAdded && leftY <= partOfLongLength - mValueAdded) {  
132.         float f = leftY / partOfLongLength;  
133.         float t = 0.5F * f;  
134.   
135.         float bezierPeakTemp = 1 - t;  
136.         float bezierPeakTemp1 = bezierPeakTemp * bezierPeakTemp;  
137.         float bezierPeakTemp2 = 2 * t * bezierPeakTemp;  
138.         float bezierPeakTemp3 = t * t;  
139.   
140.         bezierPeakXLeft = bezierPeakTemp1 * startXLeft + bezierPeakTemp2 * controlXLeft + bezierPeakTemp3 * endXLeft;  
141.         bezierPeakYLeft = bezierPeakTemp1 * startYLeft + bezierPeakTemp2 * controlYLeft + bezierPeakTemp3 * endYLeft;  
142.     }  
143.   
144.     /* 
145.      * 替补区域Path 
146.      */  
147.     mPathTrap.moveTo(startXBtm, startYBtm);  
148.     mPathTrap.lineTo(startXLeft, startYLeft);  
149.     mPathTrap.lineTo(bezierPeakXLeft, bezierPeakYLeft);  
150.     mPathTrap.lineTo(bezierPeakXBtm, bezierPeakYBtm);  
151.     mPathTrap.close();  
152.   
153.     /* 
154.      * 生成带曲线的三角形路径 
155.      */  
156.     mPath.moveTo(startXBtm, startYBtm);  
157.     mPath.quadTo(controlXBtm, controlYBtm, endXBtm, endYBtm);  
158.     mPath.lineTo(mPointX, mPointY);  
159.     mPath.lineTo(endXLeft, endYLeft);  
160.     mPath.quadTo(controlXLeft, controlYLeft, startXLeft, startYLeft);  
161.   
162.     /* 
163.      * 生成底部月半圆的Path 
164.      */  
165.     mPathSemicircleBtm.moveTo(startXBtm, startYBtm);  
166.     mPathSemicircleBtm.quadTo(controlXBtm, controlYBtm, endXBtm, endYBtm);  
167.     mPathSemicircleBtm.close();  
168.   
169.     /* 
170.      * 生成右侧月半圆的Path 
171.      */  
172.     mPathSemicircleLeft.moveTo(endXLeft, endYLeft);  
173.     mPathSemicircleLeft.quadTo(controlXLeft, controlYLeft, startXLeft, startYLeft);  
174.     mPathSemicircleLeft.close();  
175.   
176.     /* 
177.      * 生成包含折叠和下一页的路径 
178.      */  
179.     //暂时没用省略掉  
180.   
181.     /* 
182.      * 计算底部和右侧两月半圆区域 
183.      */  
184.     Region regionSemicircleBtm = computeRegion(mPathSemicircleBtm);  
185.     Region regionSemicircleLeft = computeRegion(mPathSemicircleLeft);  
186.   
187.     // 合并两月半圆区域  
188.     mRegionSemicircle.op(regionSemicircleBtm, regionSemicircleLeft, Region.Op.UNION);  
189. }  
190.   
191. // 根据Path生成的折叠区域  
192. Region regioFlod = computeRegion(mPath);  
193.   
194. // 替补区域  
195. Region regionTrap = computeRegion(mPathTrap);  
196.   
197. // 令折叠区域与替补区域相加  
198. regioFlod.op(regionTrap, Region.Op.UNION);  
199.   
200. // 从相加后的区域中剔除掉月半圆的区域获得最终折叠区域  
201. regioFlod.op(mRegionSemicircle, Region.Op.DIFFERENCE);  
202.   
203. /* 
204.  * 根据裁剪区域填充画布 
205.  */  
206. canvas.clipRegion(regioFlod);  
207. canvas.drawColor(Color.RED);  

200行的代码我们就做了一件事就是正确计算Path，同样我们还是按照之前的分了两种情况来计算，第一种情况sizeLong > mViewHeight时，我们先计算替补的这块区域：

如上代码46-49行

[java]  view plain copy print ?

1. /* 
2.  * 替补区域Path 
3.  */  
4. mPathTrap.moveTo(startXBtm, startYBtm);  
5. mPathTrap.lineTo(topX2, 0);  
6. mPathTrap.lineTo(bezierPeakXBtm, bezierPeakYBtm);  
7. mPathTrap.close();  

然后计算底部的月半圆Path：

对应代码54-56行

[java]  view plain copy print ?

1. /* 
2.  * 底部月半圆Path 
3.  */  
4. mPathSemicircleBtm.moveTo(startXBtm, startYBtm);  
5. mPathSemicircleBtm.quadTo(controlXBtm, controlYBtm, endXBtm, endYBtm);  
6. mPathSemicircleBtm.close();  

将当前折叠区域和替补区域相加再减去月半圆Path区域我们就可以得到正确的折叠区域，对应代码64行和192-201行：

[java]  view plain copy print ?

1. // 计算月半圆区域  
2. mRegionSemicircle = computeRegion(mPathSemicircleBtm);  
3.   
4. // ………………中间省略巨量代码………………  
5.   
6. // 根据Path生成的折叠区域  
7. Region regioFlod = computeRegion(mPath);  
8.   
9. // 替补区域  
10. Region regionTrap = computeRegion(mPathTrap);  
11.   
12. // 令折叠区域与替补区域相加  
13. regioFlod.op(regionTrap, Region.Op.UNION);  
14.   
15. // 从相加后的区域中剔除掉月半圆的区域获得最终折叠区域  
16. regioFlod.op(mRegionSemicircle, Region.Op.DIFFERENCE);  

该情况下我们的折叠区域是酱紫的：

两一种情况则稍微复杂些，除了要计算底部，我们还要计算右侧的月半圆Path区域，代码165-174：

[java]  view plain copy print ?

1. /* 
2.  * 生成底部月半圆的Path 
3.  */  
4. mPathSemicircleBtm.moveTo(startXBtm, startYBtm);  
5. mPathSemicircleBtm.quadTo(controlXBtm, controlYBtm, endXBtm, endYBtm);  
6. mPathSemicircleBtm.close();  
7.   
8. /* 
9.  * 生成右侧月半圆的Path 
10.  */  
11. mPathSemicircleLeft.moveTo(endXLeft, endYLeft);  
12. mPathSemicircleLeft.quadTo(controlXLeft, controlYLeft, startXLeft, startYLeft);  
13. mPathSemicircleLeft.close();  
14. 替补区域的计算，147-151：  
15. /* 
16.  * 替补区域Path 
17.  */  
18. mPathTrap.moveTo(startXBtm, startYBtm);  
19. mPathTrap.lineTo(startXLeft, startYLeft);  
20. mPathTrap.lineTo(bezierPeakXLeft, bezierPeakYLeft);  
21. mPathTrap.lineTo(bezierPeakXBtm, bezierPeakYBtm);  
22. mPathTrap.close();  
23. 区域的转换，184-188：  
24. /* 
25.  * 计算底部和右侧两月半圆区域 
26.  */  
27. Region regionSemicircleBtm = computeRegion(mPathSemicircleBtm);  
28. Region regionSemicircleLeft = computeRegion(mPathSemicircleLeft);  
29.   
30. // 合并两月半圆区域  
31. mRegionSemicircle.op(regionSemicircleBtm, regionSemicircleLeft, Region.Op.UNION);  

最终的计算跟上面第一种情况一样，效果如下：

结合两种情况，我们可以得到下面的效果：

然后，我们需要计算“下一页”的区域，同样，根据上一节我们的讲解，我们先获取折叠区域和下一页区域之和再减去折叠区域就可以得到下一页的区域：

[java]  view plain copy print ?

1. mRegionNext = computeRegion(mPathFoldAndNext);  
2. mRegionNext.op(mRegionFold, Region.Op.DIFFERENCE);  

绘制效果如下：

最后，我们结合上两节，注入数据：

[java]  view plain copy print ?

1. /** 
2.  * 绘制位图数据 
3.  *  
4.  * @param canvas 
5.  *            画布对象 
6.  */  
7. private void drawBitmaps(Canvas canvas) {  
8.     // 绘制位图前重置isLastPage为false  
9.     isLastPage = false;  
10.   
11.     // 限制pageIndex的值范围  
12.     mPageIndex = mPageIndex < 0 ? 0 : mPageIndex;  
13.     mPageIndex = mPageIndex > mBitmaps.size() ? mBitmaps.size() : mPageIndex;  
14.   
15.     // 计算数据起始位置  
16.     int start = mBitmaps.size() - 2 - mPageIndex;  
17.     int end = mBitmaps.size() - mPageIndex;  
18.   
19.     /* 
20.      * 如果数据起点位置小于0则表示当前已经到了最后一张图片 
21.      */  
22.     if (start < 0) {  
23.         // 此时设置isLastPage为true  
24.         isLastPage = true;  
25.   
26.         // 并显示提示信息  
27.         showToast("This is fucking lastest page");  
28.   
29.         // 强制重置起始位置  
30.         start = 0;  
31.         end = 1;  
32.     }  
33.   
34.     /* 
35.      * 计算当前页的区域 
36.      */  
37.     canvas.save();  
38.     canvas.clipRegion(mRegionCurrent);  
39.     canvas.drawBitmap(mBitmaps.get(end - 1), 0, 0, null);  
40.     canvas.restore();  
41.   
42.     /* 
43.      * 计算折叠页的区域 
44.      */  
45.     canvas.save();  
46.     canvas.clipRegion(mRegionFold);  
47.   
48.     canvas.translate(mPointX, mPointY);  
49.   
50.     /* 
51.      * 根据长短边标识计算折叠区域图像 
52.      */  
53.     if (mRatio == Ratio.SHORT) {  
54.         canvas.rotate(90 - mDegrees);  
55.         canvas.translate(0, -mViewHeight);  
56.         canvas.scale(-1, 1);  
57.         canvas.translate(-mViewWidth, 0);  
58.     } else {  
59.         canvas.rotate(-(90 - mDegrees));  
60.         canvas.translate(-mViewWidth, 0);  
61.         canvas.scale(1, -1);  
62.         canvas.translate(0, -mViewHeight);  
63.     }  
64.   
65.     canvas.drawBitmap(mBitmaps.get(end - 1), 0, 0, null);  
66.     canvas.restore();  
67.   
68.     /* 
69.      * 计算下一页的区域 
70.      */  
71.     canvas.save();  
72.     canvas.clipRegion(mRegionNext);  
73.     canvas.drawBitmap(mBitmaps.get(start), 0, 0, null);  
74.     canvas.restore();  
75. }  

最终效果如下：

该部分的代码就不贴出了，大部分跟上一节相同，因为过两天要去旅游时间略紧这节略讲得粗糙，不过也没什么太大的改动，如果大家有不懂的地方可以留言或群里@哥，下一节我们将尝试实现翻页时图像扭曲的效果。

本文转自 http://blog.csdn.net/aigestudio/article/details/42712269