Android电子书翻书效果(一)

最新推荐文章于 2022-04-27 13:41:08 发布
最新推荐文章于 2022-04-27 13:41:08 发布
阅读量649 收藏
点赞数
分类专栏： android 文章标签： android float path constructor null matrix
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jianchibuxie5/article/details/6801095
版权
   我之前在CSDN上已发过 Android电子书翻书效果源码，那个虽实现了翻书效果，但翻书过程中未使用贝塞尔曲线，效果有些生硬(如左图)，而且只能在四个页脚触发翻书，灵敏度和实用性较差。现如今引入了贝塞尔曲线，设置了翻页区域，灵敏度更佳，翻书效果非常明显（如右图）。

  
关键代码如下:

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.ColorMatrix;
import android.graphics.ColorMatrixColorFilter;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PointF;
import android.graphics.Region;
import android.graphics.drawable.GradientDrawable;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;

public class PageWidget extends View {

 private static final String TAG = "PageWidget";
 private int mWidth = 480;
 private int mHeight = 800;
 private int mCornerX = 0; //拖拽点对应的页脚
 private int mCornerY = 0;
 private Path mPath0;
 private Path mPath1;
 Bitmap mCurPageBitmap = null; //当前页
 Bitmap mCurPageBackBitmap = null;
 Bitmap mNextPageBitmap = null;

 PointF mTouch = new PointF(); // 拖拽点
 PointF mBezierStart1 = new PointF(); //贝塞尔曲线起始点
 PointF mBezierControl1 = new PointF(); //贝塞尔曲线控制点
 PointF mBeziervertex1 = new PointF(); //贝塞尔曲线顶点
 PointF mBezierEnd1 = new PointF(); //贝塞尔曲线结束点

 PointF mBezierStart2 = new PointF(); //另一条贝塞尔曲线
 PointF mBezierControl2 = new PointF();
 PointF mBeziervertex2 = new PointF();
 PointF mBezierEnd2 = new PointF();

 float mMiddleX;
 float mMiddleY;
 float mDegrees;
 float mTouchToCornerDis;
 ColorMatrixColorFilter mColorMatrixFilter;
 Matrix mMatrix;
 float[] mMatrixArray = { 0, 0, 0, 0, 0, 0, 0, 0, 1.0f };

 boolean mIsRTandLB; //是否属于右上左下
 float mMaxLength = (float) Math.hypot(480, 800);
 int[] mBackShadowColors;
 int[] mFrontShadowColors;
 GradientDrawable mBackShadowDrawableLR;
 GradientDrawable mBackShadowDrawableRL;
 GradientDrawable mFolderShadowDrawableLR;
 GradientDrawable mFolderShadowDrawableRL;

 GradientDrawable mFrontShadowDrawableHBT;
 GradientDrawable mFrontShadowDrawableHTB;
 GradientDrawable mFrontShadowDrawableVLR;
 GradientDrawable mFrontShadowDrawableVRL;

 private Bitmap mBitmap;
 private Canvas mCanvas;
 private Paint mBitmapPaint;
 Paint paint;

 Paint mPaint;

 public PageWidget(Context context) {
  super(context);
  // TODO Auto-generated constructor stub
  mPath0 = new Path();
  mPath1 = new Path();
  createDrawable();

  mBitmap = Bitmap.createBitmap(480, 800, Bitmap.Config.ARGB_8888);

  mCanvas = new Canvas(mBitmap);
  mBitmapPaint = new Paint(Paint.DITHER_FLAG);

  paint = new Paint();
  mPaint = new Paint();
  mPaint.setStyle(Paint.Style.FILL);

  mCurPageBitmap = BitmapFactory.decodeResource(this.getResources(),
    R.drawable.page1);
  mNextPageBitmap = BitmapFactory.decodeResource(this.getResources(),
    R.drawable.page2);

  ColorMatrix cm = new ColorMatrix();
  float array[] = { 0.55f, 0, 0, 0, 80.0f, 0, 0.55f, 0, 0, 80.0f, 0, 0,
    0.55f, 0, 80.0f, 0, 0, 0, 0.2f, 0 };
  cm.set(array);
  mColorMatrixFilter = new ColorMatrixColorFilter(cm);

  mMatrix = new Matrix();
 }

 /**
  * 计算拖拽点对应的拖拽脚
  */
 private void calcCornerXY(float x, float y) {
  if (x <= mWidth / 2)
   mCornerX = 0;
  else
   mCornerX = mWidth;
  if (y <= mHeight / 2)
   mCornerY = 0;
  else
   mCornerY = mHeight;
  if ((mCornerX == 0 && mCornerY == mHeight)
    || (mCornerX == mWidth && mCornerY == 0))
   mIsRTandLB = true;
  else
   mIsRTandLB = false;
 }

 @Override
 public boolean onTouchEvent(MotionEvent event) {
  // TODO Auto-generated method stub
  if (event.getAction() == MotionEvent.ACTION_MOVE) {//手指移动
   mCanvas.drawColor(0xFFAAAAAA);
   mTouch.x = event.getX();
   mTouch.y = event.getY();
   this.postInvalidate();//更新视图
  }
  if (event.getAction() == MotionEvent.ACTION_DOWN) {//手指按下
   mCanvas.drawColor(0xFFAAAAAA);
   mTouch.x = event.getX();
   mTouch.y = event.getY();
   calcCornerXY(mTouch.x, mTouch.y);
   this.postInvalidate();
  }
  if (event.getAction() == MotionEvent.ACTION_UP) {//手指松开
   mCanvas.drawColor(0xFFAAAAAA);
   mTouch.x = mCornerX;
   mTouch.y = mCornerY;
   this.postInvalidate();
  }
  return true;
 }

 /**
  * 求解直线P1P2和直线P3P4的交点坐标
  */
 public PointF getCross(PointF P1, PointF P2, PointF P3, PointF P4) {
  PointF CrossP = new PointF();
  // 二元函数通式： y=ax+b
  float a1 = (P2.y - P1.y) / (P2.x - P1.x);
  float b1 = ((P1.x * P2.y) - (P2.x * P1.y)) / (P1.x - P2.x);

  float a2 = (P4.y - P3.y) / (P4.x - P3.x);
  float b2 = ((P3.x * P4.y) - (P4.x * P3.y)) / (P3.x - P4.x);
  CrossP.x = (b2 - b1) / (a1 - a2);
  CrossP.y = a1 * CrossP.x + b1;
  return CrossP;
 }

 private void calcPoints() {
  mMiddleX = (mTouch.x + mCornerX) / 2;
  mMiddleY = (mTouch.y + mCornerY) / 2;
  mBezierControl1.x = mMiddleX - (mCornerY - mMiddleY)
    * (mCornerY - mMiddleY) / (mCornerX - mMiddleX);
  mBezierControl1.y = mCornerY;
  mBezierControl2.x = mCornerX;
  mBezierControl2.y = mMiddleY - (mCornerX - mMiddleX)
    * (mCornerX - mMiddleX) / (mCornerY - mMiddleY);

  Log.i(TAG, "mTouchX  " + mTouch.x + "  mTouchY  " + mTouch.y);
  Log.i(TAG, "mBezierControl1.x  " + mBezierControl1.x
    + "  mBezierControl1.y  " + mBezierControl1.y);
  Log.i(TAG, "mBezierControl2.x  " + mBezierControl2.x
    + "  mBezierControl2.y  " + mBezierControl2.y);

  mBezierStart1.x = mBezierControl1.x - (mCornerX - mBezierControl1.x)
    / 2;
  mBezierStart1.y = mCornerY;

  // 当mBezierStart1.x < 0或者mBezierStart1.x > 480时
  // 如果继续翻页，会出现BUG故在此限制
  if (mBezierStart1.x < 0 || mBezierStart1.x > 480) {  
   if (mBezierStart1.x < 0)        
    mBezierStart1.x = mWidth - mBezierStart1.x;

   float f1 = Math.abs(mCornerX - mTouch.x);
   float f2 = mWidth * f1 / mBezierStart1.x;
   mTouch.x = Math.abs(mCornerX - f2);

   float f3 = Math.abs(mCornerX - mTouch.x)
     * Math.abs(mCornerY - mTouch.y) / f1;
   mTouch.y = Math.abs(mCornerY - f3);
   mMiddleX = (mTouch.x + mCornerX) / 2;
   mMiddleY = (mTouch.y + mCornerY) / 2;

   mBezierControl1.x = mMiddleX - (mCornerY - mMiddleY)
     * (mCornerY - mMiddleY) / (mCornerX - mMiddleX);
   mBezierControl1.y = mCornerY;

   mBezierControl2.x = mCornerX;
   mBezierControl2.y = mMiddleY - (mCornerX - mMiddleX)
     * (mCornerX - mMiddleX) / (mCornerY - mMiddleY);
   Log.i(TAG, "mTouchX --> " + mTouch.x + "  mTouchY-->  "
     + mTouch.y);
   Log.i(TAG, "mBezierControl1.x--  " + mBezierControl1.x
     + "  mBezierControl1.y -- " + mBezierControl1.y);
   Log.i(TAG, "mBezierControl2.x -- " + mBezierControl2.x
     + "  mBezierControl2.y -- " + mBezierControl2.y);
   mBezierStart1.x = mBezierControl1.x
     - (mCornerX - mBezierControl1.x) / 2;
  }

  mBezierStart2.x = mCornerX;
  mBezierStart2.y = mBezierControl2.y - (mCornerY - mBezierControl2.y)
    / 2;

  mTouchToCornerDis = (float) Math.hypot((mTouch.x - mCornerX),
    (mTouch.y - mCornerY));

  mBezierEnd1 = getCross(mTouch, mBezierControl1, mBezierStart1,
    mBezierStart2);
  mBezierEnd2 = getCross(mTouch, mBezierControl2, mBezierStart1,
    mBezierStart2);

  Log.i(TAG, "mBezierEnd1.x  " + mBezierEnd1.x + "  mBezierEnd1.y  "
    + mBezierEnd1.y);
  Log.i(TAG, "mBezierEnd2.x  " + mBezierEnd2.x + "  mBezierEnd2.y  "
    + mBezierEnd2.y);

  /*
   * mBeziervertex1.x 推导
   * ((mBezierStart1.x+mBezierEnd1.x)/2+mBezierControl1.x)/2 化简等价于
   * (mBezierStart1.x+ 2*mBezierControl1.x+mBezierEnd1.x) / 4
   */
  mBeziervertex1.x = (mBezierStart1.x + 2 * mBezierControl1.x + mBezierEnd1.x) / 4;
  mBeziervertex1.y = (2 * mBezierControl1.y + mBezierStart1.y + mBezierEnd1.y) / 4;
  mBeziervertex2.x = (mBezierStart2.x + 2 * mBezierControl2.x + mBezierEnd2.x) / 4;
  mBeziervertex2.y = (2 * mBezierControl2.y + mBezierStart2.y + mBezierEnd2.y) / 4;
 }

 private void drawCurrentPageArea(Canvas canvas, Bitmap bitmap, Path path) {
  mPath0.reset();
  mPath0.moveTo(mBezierStart1.x, mBezierStart1.y);
  mPath0.quadTo(mBezierControl1.x, mBezierControl1.y, mBezierEnd1.x,
    mBezierEnd1.y);
  mPath0.lineTo(mTouch.x, mTouch.y);
  mPath0.lineTo(mBezierEnd2.x, mBezierEnd2.y);
  mPath0.quadTo(mBezierControl2.x, mBezierControl2.y, mBezierStart2.x,
    mBezierStart2.y);
  mPath0.lineTo(mCornerX, mCornerY);
  mPath0.close();

  canvas.save();
  canvas.clipPath(path, Region.Op.XOR);
  canvas.drawBitmap(bitmap, 0, 0, null);
  canvas.restore();
 }

 private void drawNextPageAreaAndShadow(Canvas canvas, Bitmap bitmap) {
  mPath1.reset();
  mPath1.moveTo(mBezierStart1.x, mBezierStart1.y);
  mPath1.lineTo(mBeziervertex1.x, mBeziervertex1.y);
  mPath1.lineTo(mBeziervertex2.x, mBeziervertex2.y);
  mPath1.lineTo(mBezierStart2.x, mBezierStart2.y);
  mPath1.lineTo(mCornerX, mCornerY);
  mPath1.close();

  mDegrees = (float) Math.toDegrees(Math.atan2(mBezierControl1.x
    - mCornerX, mBezierControl2.y - mCornerY));
  int leftx;
  int rightx;
  GradientDrawable mBackShadowDrawable;
  if (mIsRTandLB) {
   leftx = (int) (mBezierStart1.x);
   rightx = (int) (mBezierStart1.x + mTouchToCornerDis / 4);
   mBackShadowDrawable = mBackShadowDrawableLR;
  } else {
   leftx = (int) (mBezierStart1.x - mTouchToCornerDis / 4);
   rightx = (int) mBezierStart1.x;
   mBackShadowDrawable = mBackShadowDrawableRL;
  }
  canvas.save();
  canvas.clipPath(mPath0);
  canvas.clipPath(mPath1, Region.Op.INTERSECT);
  canvas.drawBitmap(bitmap, 0, 0, null);
  canvas.rotate(mDegrees, mBezierStart1.x, mBezierStart1.y);
  mBackShadowDrawable.setBounds(leftx, (int) mBezierStart1.y, rightx,
    (int) (mMaxLength + mBezierStart1.y));
  mBackShadowDrawable.draw(canvas);
  canvas.restore();
 }

 public void setBitmaps(Bitmap bm1, Bitmap bm2, Bitmap bm3) {
  mCurPageBitmap = bm1;
  mCurPageBackBitmap = bm2;
  mNextPageBitmap = bm3;
 }

 @Override
 protected void onDraw(Canvas canvas) {
  canvas.drawColor(0xFFAAAAAA);
  calcPoints();
  drawCurrentPageArea(mCanvas, mCurPageBitmap, mPath0);
  drawNextPageAreaAndShadow(mCanvas, mNextPageBitmap);
  drawCurrentPageShadow(mCanvas);
  drawCurrentBackArea(mCanvas, mCurPageBitmap);
  canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);
 }

 /**
  *创建阴影的GradientDrawable
  */
 private void createDrawable() {
  int[] color = { 0x333333, 0xb0333333 };
  mFolderShadowDrawableRL = new GradientDrawable(
    GradientDrawable.Orientation.RIGHT_LEFT, color);
  mFolderShadowDrawableRL
    .setGradientType(GradientDrawable.LINEAR_GRADIENT);

  mFolderShadowDrawableLR = new GradientDrawable(
    GradientDrawable.Orientation.LEFT_RIGHT, color);
  mFolderShadowDrawableLR
    .setGradientType(GradientDrawable.LINEAR_GRADIENT);

  mBackShadowColors = new int[] { 0xff111111, 0x111111 };
  mBackShadowDrawableRL = new GradientDrawable(
    GradientDrawable.Orientation.RIGHT_LEFT, mBackShadowColors);
  mBackShadowDrawableRL.setGradientType(GradientDrawable.LINEAR_GRADIENT);

  mBackShadowDrawableLR = new GradientDrawable(
    GradientDrawable.Orientation.LEFT_RIGHT, mBackShadowColors);
  mBackShadowDrawableLR.setGradientType(GradientDrawable.LINEAR_GRADIENT);

  mFrontShadowColors = new int[] { 0x80111111, 0x111111 };
  mFrontShadowDrawableVLR = new GradientDrawable(
    GradientDrawable.Orientation.LEFT_RIGHT, mFrontShadowColors);
  mFrontShadowDrawableVLR
    .setGradientType(GradientDrawable.LINEAR_GRADIENT);
  mFrontShadowDrawableVRL = new GradientDrawable(
    GradientDrawable.Orientation.RIGHT_LEFT, mFrontShadowColors);
  mFrontShadowDrawableVRL
    .setGradientType(GradientDrawable.LINEAR_GRADIENT);

  mFrontShadowDrawableHTB = new GradientDrawable(
    GradientDrawable.Orientation.TOP_BOTTOM, mFrontShadowColors);
  mFrontShadowDrawableHTB
    .setGradientType(GradientDrawable.LINEAR_GRADIENT);

  mFrontShadowDrawableHBT = new GradientDrawable(
    GradientDrawable.Orientation.BOTTOM_TOP, mFrontShadowColors);
  mFrontShadowDrawableHBT
    .setGradientType(GradientDrawable.LINEAR_GRADIENT);
 }

 /**
  * 绘制翻起页的阴影
  */
 public void drawCurrentPageShadow(Canvas canvas) {
  double degree;
  if (mIsRTandLB) {
   degree = Math.PI
     / 4
     - Math.atan2(mBezierControl1.y - mTouch.y, mTouch.x
       - mBezierControl1.x);
  } else {
   degree = Math.PI
     / 4
     - Math.atan2(mTouch.y - mBezierControl1.y, mTouch.x
       - mBezierControl1.x);
  }
  //翻起页阴影顶点与touch点的距离
  double d1 = (float) 25 * 1.414 * Math.cos(degree);
  double d2 = (float) 25 * 1.414 * Math.sin(degree);
  float x = (float) (mTouch.x + d1);
  float y;
  if (mIsRTandLB) {
   y = (float) (mTouch.y + d2);  
  } else {
   y = (float) (mTouch.y - d2);
  }
  mPath1.reset();
  mPath1.moveTo(x, y);
  mPath1.lineTo(mTouch.x, mTouch.y);
  mPath1.lineTo(mBezierControl1.x, mBezierControl1.y);
  mPath1.lineTo(mBezierStart1.x, mBezierStart1.y);
  mPath1.close();
  float rotateDegrees;
  canvas.save();

  canvas.clipPath(mPath0, Region.Op.XOR);
  canvas.clipPath(mPath1, Region.Op.INTERSECT);
  int leftx;
  int rightx;
  GradientDrawable mCurrentPageShadow;
  if (mIsRTandLB) {
   leftx = (int) (mBezierControl1.x);
   rightx = (int) mBezierControl1.x + 25;
   mCurrentPageShadow = mFrontShadowDrawableVLR;
  } else {
   leftx = (int) (mBezierControl1.x - 25);
   rightx = (int) mBezierControl1.x + 1;
   mCurrentPageShadow = mFrontShadowDrawableVRL;
  }

  rotateDegrees = (float) Math.toDegrees(Math.atan2(mTouch.x
    - mBezierControl1.x, mBezierControl1.y - mTouch.y));
  canvas.rotate(rotateDegrees, mBezierControl1.x, mBezierControl1.y);
  mCurrentPageShadow.setBounds(leftx,
    (int) (mBezierControl1.y - mMaxLength), rightx,
    (int) (mBezierControl1.y));
  mCurrentPageShadow.draw(canvas);
  canvas.restore();

  mPath1.reset();
  mPath1.moveTo(x, y);
  mPath1.lineTo(mTouch.x, mTouch.y);
  mPath1.lineTo(mBezierControl2.x, mBezierControl2.y);
  mPath1.lineTo(mBezierStart2.x, mBezierStart2.y);
  mPath1.close();
  canvas.save();
  canvas.clipPath(mPath0, Region.Op.XOR);
  canvas.clipPath(mPath1, Region.Op.INTERSECT);
  if (mIsRTandLB) {
   leftx = (int) (mBezierControl2.y);
   rightx = (int) (mBezierControl2.y + 25);
   mCurrentPageShadow = mFrontShadowDrawableHTB;
  } else {
   leftx = (int) (mBezierControl2.y - 25);
   rightx = (int) (mBezierControl2.y + 1);
   mCurrentPageShadow = mFrontShadowDrawableHBT;
  }
  rotateDegrees = (float) Math.toDegrees(Math.atan2(mBezierControl2.y
    - mTouch.y, mBezierControl2.x - mTouch.x));
  canvas.rotate(rotateDegrees, mBezierControl2.x, mBezierControl2.y);
  float temp;
  if (mBezierControl2.y < 0)
   temp = mBezierControl2.y - 800;
  else
   temp = mBezierControl2.y;

  int hmg = (int) Math.hypot(mBezierControl2.x, temp);
  if (hmg > mMaxLength)
   mCurrentPageShadow
     .setBounds((int) (mBezierControl2.x - 25) - hmg, leftx,
       (int) (mBezierControl2.x + mMaxLength) - hmg,
       rightx);
  else
   mCurrentPageShadow.setBounds(
     (int) (mBezierControl2.x - mMaxLength), leftx,
     (int) (mBezierControl2.x), rightx);

  Log.i(TAG, "mBezierControl2.x   " + mBezierControl2.x
    + "  mBezierControl2.y  " + mBezierControl2.y);
  mCurrentPageShadow.draw(canvas);
  canvas.restore();
 }

 /**
  *  绘制翻起页背面
  */
 private void drawCurrentBackArea(Canvas canvas, Bitmap bitmap) {
  int i = (int) (mBezierStart1.x + mBezierControl1.x) / 2;
  float f1 = Math.abs(i - mBezierControl1.x);
  int i1 = (int) (mBezierStart2.y + mBezierControl2.y) / 2;
  float f2 = Math.abs(i1 - mBezierControl2.y);
  float f3 = Math.min(f1, f2);
  mPath1.reset();
  mPath1.moveTo(mBeziervertex2.x, mBeziervertex2.y);
  mPath1.lineTo(mBeziervertex1.x, mBeziervertex1.y);
  mPath1.lineTo(mBezierEnd1.x, mBezierEnd1.y);
  mPath1.lineTo(mTouch.x, mTouch.y);
  mPath1.lineTo(mBezierEnd2.x, mBezierEnd2.y);
  mPath1.close();
  GradientDrawable mFolderShadowDrawable;
  int left;
  int right;
  if (mIsRTandLB) {
   left = (int) (mBezierStart1.x - 1);
   right = (int) (mBezierStart1.x + f3 + 1);
   mFolderShadowDrawable = mFolderShadowDrawableLR;
  } else {
   left= (int) (mBezierStart1.x - f3 - 1);
   right= (int) (mBezierStart1.x + 1);
   mFolderShadowDrawable = mFolderShadowDrawableRL;
  }
  canvas.save();
  canvas.clipPath(mPath0);
  canvas.clipPath(mPath1, Region.Op.INTERSECT);

  mPaint.setColorFilter(mColorMatrixFilter);

  float dis = (float) Math.hypot(mCornerX - mBezierControl1.x,
    mBezierControl2.y - mCornerY);
  float f8 = (mCornerX - mBezierControl1.x) / dis;
  float f9 = (mBezierControl2.y - mCornerY) / dis;
  mMatrixArray[0] = 1 - 2 * f9 * f9;
  mMatrixArray[1] = 2 * f8 * f9;
  mMatrixArray[3] = mMatrixArray[1];
  mMatrixArray[4] = 1 - 2 * f8 * f8;
  mMatrix.reset();
  mMatrix.setValues(mMatrixArray);
  mMatrix.preTranslate(-mBezierControl1.x, -mBezierControl1.y);
  mMatrix.postTranslate(mBezierControl1.x, mBezierControl1.y);
  canvas.drawBitmap(bitmap, mMatrix, mPaint);
  mPaint.setColorFilter(null);
  canvas.rotate(mDegrees, mBezierStart1.x, mBezierStart1.y);
  mFolderShadowDrawable.setBounds(left, (int) mBezierStart1.y, right,
    (int) (mBezierStart1.y + mMaxLength));
  mFolderShadowDrawable.draw(canvas);
  canvas.restore();
 }
}
  

jianchibuxie5
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android利用贝塞尔曲线实现翻书效果（适配AndroidX）
02-08
解决androidP以上Android利用贝塞尔曲线实现翻书效果XOR方法无法使用的难题
android酷炫翻页效果+图形分析
jianchibuxie5的专栏
09-20 481
public class PageWidget extends View {  private static final String TAG = "hmg";  private int mWidth = 480;  private int mHeight = 800;
iOS开发 十六进制颜色值转UIColor
月若无涯的专栏
04-15 6638
在iOS开发中，经常有设计给到的颜色值是类似0xffaabb，或者#FFFFFF这种格式的，对于iOS内置的颜色处理UIColor来说，是无法直接处理使用的，因此需要做一个转换，转换方式如下： +(UIColor *)colorWithHexColorString:(NSString *)hexColorString{ if ([hexColorString length] <6){//
Android电子书翻页效果实现
随手记两笔
04-22 1万+
Android电子书翻页效果实现
Android 实现书籍翻页效果----完结篇
热门推荐
何明桂的小窝
04-22 7万+
                                               By 何明桂（http://blog.csdn.net/hmg25） 转载请注明出处      之前由于种种琐事，暂停了这个翻页效果的实现，终于在这周末完成了大部分功能，但是这里只是给出了一个基本的雏形，没有添加翻页的动画效果，由于下个周末开始，需要转向去研究framework层（短暂的酱油期就这样结束啦 o(︶︿︶)o唉），将会暂停翻页的开发，所以想要进一步提高功能的童鞋需要自己动手~~~稍后发布的将是本人提供的
android实现电子书翻书效果
12-08
android实现电子书翻书效果 实现大部分阅读器提供的实体书翻页效果
Android-eBook翻书效果源码
10-08
翻页效果，导入源码即可运行。 package sf.hmg.turntest; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas; import ...
安卓翻页效果相关-android用opengl实现电子书翻书效果代码.rar
07-30
android用opengl实现电子书翻书效果代码.rar,太多无法一一验证是否可用，程序如果跑不起来需要自调，部分代码功能进行参考学习。
Android电子书阅读器
06-30
我之前在CSDN上已发过Android电子书翻书效果源码，那个虽实现了翻书效果，但翻书过程中未使用贝塞尔曲线，效果有些生硬而且只能在四个页脚触发翻书，灵敏度和实用性较差。现如今引入了贝塞尔曲线，设置了翻页区域，...
Android仿真翻页效果
04-03
Android仿真翻页效果源码，该效果模仿了我们在生活中翻页的效果的，并且源码还是比较简单，容易上手的，希望大家可以借助这个源码来学习一下吧。
Android 逼真翻页效果-IT计算机-毕业设计.zip
04-01
前几年的Android应用源码Demo，主要面向的是学生毕业设计学习。
Android类似翻书效果
06-03
Android的图片翻页动画效果，类似我们翻书的效果，兼容Android10和Android11
android 仿书籍翻页效果(bug修复版本)
11-12
这个版本修复了之前第一页和第二页显示空白的bug，其他方面都很好，如果觉得不合适可以下载我另外的仿书籍，有全源码，有图片翻页，这个是ui翻页
android_page_curl翻书效果.zip
07-10
android_page_curl翻书效果是一个在 Android 上用opengl实现了电子书翻书效果的代码，做的比较逼真
Android翻页动画效果完整实例代码
03-13
一个非常实用的小例子，主要实现了模拟书本翻页的效果，类似常用的电子书阅读软件中的翻页效果。超赞哦。。。。。 已经封装成组件，xml直接引用即可，开发接入零成本
Android自定义View——从零开始实现书籍翻页效果
m0_70082703的博客
04-27 833
简单总结一下，a是触摸点，f是触摸点相对的边缘角，eh我们设置为af的垂直平分线，则g是af的中点，ab、ak、dj是直线；曲线cdb是起点为c，控制点为e，终点为b的二阶贝塞尔曲线；曲线kij是起点为k，控制点为h，终点为j的二阶贝塞尔曲线，区域A、B、C就由这些点和线划分开来。我们将这些点称为标识点，下一步就是模拟设定a和f点的位置，将这组标识点绘制到屏幕上来验证我们的计算公式是否正确，创建BookPageView public class BookPageView extends View { pri
android 电子书源码，翻页效果
jiangxiaoma111的专栏
02-21 4530
这两天模仿着做了一个apk电子书的应用，有翻页效果，本来是想学一下自己写的，无奈，最后偷懒使用了别人写的 翻页类 PageWidget.java 下面是工程文件的结构 这个是写的类的包结构，PageView.java 类本类是打算自己写的，然后学习安卓动画效果，但是由于时间加上懒，再加上看晕了，就使用了别人写的PageWidger.java类。来源我忘了，当时搜索到的，本来是打
Android实现书籍翻页效果--扩展版(转)
iteye_11914的博客
12-20 487
转载自:http://blog.csdn.net/xu_fu/article/details/7769740   最近由于需要实现Android上的书籍翻页效果，于是就在CSDN上找到了何明桂（http://blog.csdn.net/hmg25）的一个系列文章，在此感谢大神的无私奉献。具体原理何大神已经将的很清楚了，具体请看 Android 实现书籍翻页效果----原理篇 Androi...
android 实现双屏翻书效果
最新发布
09-27
要实现Android双屏翻书效果，可以通过以下步骤来完成： 1. 首先，在XML布局文件中创建两个控件，分别代表左右两个屏幕。可以使用FrameLayout来容纳这两个控件。 2. 接下来，在Java代码中，我们需要创建一个类继承...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值