android酷炫翻页效果+图形分析

最新推荐文章于 2024-03-25 21:56:34 发布
最新推荐文章于 2024-03-25 21:56:34 发布
阅读量1.9k 收藏 1
点赞数 1
分类专栏： Android 文章标签： android 图形 float path null matrix 
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.Path.Direction;
import android.graphics.PointF;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Region.Op;
import android.graphics.drawable.GradientDrawable;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Scroller;

public class PageWidget extends View{
	private static final String TAG = "hmg";
	 private int mWidth = 1024;
	 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; // 是否属于右上左下
	 // for test
	 float mMaxLength = (float) Math.hypot(1024, 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(1024, 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.decodeFile("/mnt/sdcard/media/cn6456724.jpg"); 
	  mNextPageBitmap =BitmapFactory.decodeFile("/mnt/sdcard/media/cn6249784.jpg"); 

	  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 super.onTouchEvent(event);
	  return true;
	 }

	 
	 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;
	  
	  System.out.println(mTouch.x+"----------------x");
	  System.out.println(mTouch.y+"----------------y");
	  System.out.println(mCornerX+"----------------cornerX");
	  System.out.println(mCornerY+"----------------cornerY");
	  //贝塞尔曲线的控制点的横坐标
	  mBezierControl1.x = mMiddleX - (mCornerY - mMiddleY)
	    * (mCornerY - mMiddleY) / (mCornerX - mMiddleX);
	  
	  mBezierControl1.y = mCornerY;
	  
	  System.out.println(mBezierControl1.x+"----------------mBezierControl1X");
	  System.out.println(mBezierControl1.y+"----------------mBezierControl1Y");
	  mBezierControl2.x = mCornerX;
	  mBezierControl2.y = mMiddleY - (mCornerX - mMiddleX)
	    * (mCornerX - mMiddleX) / (mCornerY - mMiddleY);

	  System.out.println("mTouchX  " + mTouch.x + "  mTouchY  " + mTouch.y);
	  System.out.println("mBezierControl1.x  " + mBezierControl1.x
	    + "  mBezierControl1.y  " + mBezierControl1.y);
	  System.out.println("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 > 1024) {
	   System.out.println("page move");
	   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);
	   System.out.println("mTouchX --> " + mTouch.x + "  mTouchY-->  "
	     + mTouch.y);
	   System.out.println("mBezierControl1.x--  " + mBezierControl1.x
	     + "  mBezierControl1.y -- " + mBezierControl1.y);
	   System.out.println("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);

	  System.out.println("mBezierEnd1.x  " + mBezierEnd1.x + "  mBezierEnd1.y  "
	    + mBezierEnd1.y);
	  System.out.println("mBezierEnd2.x  " + mBezierEnd2.x + "  mBezierEnd2.y  "
	    + mBezierEnd2.y);

	  
	  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, 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, 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) {
	  System.out.println("onDraw");
	  canvas.drawColor(0xFFAAAAAA);
	  calcPoints();
	  drawCurrentPageArea(mCanvas, mCurPageBitmap, mPath0);
	  drawNextPageAreaAndShadow(mCanvas, mNextPageBitmap);
	  drawCurrentPageShadow(mCanvas);
	  drawCurrentBackArea(mCanvas, mCurPageBitmap);
	  canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);
	 }

	 
	 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, Op.XOR);
	  canvas.clipPath(mPath1, 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, Op.XOR);
	  canvas.clipPath(mPath1, 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);

	  System.out.println("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, 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);
	  // canvas.drawBitmap(bitmap, mMatrix, null);
	  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();
	 }

    
    
}
//Activity
public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState); 
 requestWindowFeature(Window.FEATURE_NO_TITLE);
 getWindow().setFlags(
  WindowManager.LayoutParams.FLAG_FULLSCREEN,
  WindowManager.LayoutParams.FLAG_FULLSCREEN);
     setContentView(new PageWidget(this));
     
    }


danier_sky
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android利用贝塞尔曲线实现翻书效果（适配AndroidX）
02-08
解决androidP以上Android利用贝塞尔曲线实现翻书效果XOR方法无法使用的难题
iOS开发 十六进制颜色值转UIColor
月若无涯的专栏
04-15 6644
在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酷炫动画效果之3D星体旋转效果
01-20
3D星体旋转效果就是其中一种能吸引用户注意力的酷炫动画。本文主要介绍如何在Android中实现这样的效果，以及涉及到的关键技术和概念。 首先，对于3D动画的实现，Android提供了两种主要的方法：Open GL ES和Camera。...
Android3D翻页效果的倒计时控件
04-22
在Android应用开发中，创建吸引用户的交互体验是至关重要的，其中一种独特且引人注目的效果就是3D翻页效果。本知识点将详细介绍如何在Android中实现一个具有3D翻页效果的倒计时控件。这个控件不仅能够显示倒计时，还...
Android 酷炫水滴效果的下拉刷新 源码
10-18
本资源提供的是一个名为"Android酷炫水滴效果的下拉刷新源码"，它为Android开发者提供了实现独特视觉效果的下拉刷新控件。这个控件在用户下拉时，会呈现出如同水波纹扩散般的动态效果，既酷炫又引人注目。 一、...
Android酷炫登录动画效果
08-01
"Android酷炫登录动画效果"这个主题，聚焦于如何通过动画技术提升登录页面的视觉吸引力和交互体验。 在Android中，实现登录页的动画效果主要依赖于以下技术： 1. **帧动画（Frame Animation）**：这是最基础的动画...
J2ME–canvas下作出书籍杂志华丽的翻页效果
jacky choise
11-10 1808
<br /> 其实这个效果要做出来，也很简单。说白了，就是setclip方法的使用。我们知道，setclip方法可以让我们只画一张大图的某一部分内容。      具体是：<br />      1.准备几张图片，分别是翻页效果的每一帧的图片。就是翻页的时候所显示的慢慢翻页的那几个效果图片。（稍后放出图片解释）<br />      2.实现通过图片处理软件，例如Photoshop，获知你的每一张翻页动画图片画的时候所在手机屏幕上的坐标位置。此处位置我们去两个。分别是图片右上顶点和右下角点的坐标。这个坐
Android自定义View——从零开始实现书籍翻页效果
m0_70082703的博客
04-27 864
简单总结一下，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 4588
这两天模仿着做了一个apk电子书的应用，有翻页效果，本来是想学一下自己写的，无奈，最后偷懒使用了别人写的 翻页类 PageWidget.java 下面是工程文件的结构 这个是写的类的包结构，PageView.java 类本类是打算自己写的，然后学习安卓动画效果，但是由于时间加上懒，再加上看晕了，就使用了别人写的PageWidger.java类。来源我忘了，当时搜索到的，本来是打
Android实现书籍翻页效果--扩展版(转)
iteye_11914的博客
12-20 504
转载自:http://blog.csdn.net/xu_fu/article/details/7769740   最近由于需要实现Android上的书籍翻页效果，于是就在CSDN上找到了何明桂（http://blog.csdn.net/hmg25）的一个系列文章，在此感谢大神的无私奉献。具体原理何大神已经将的很清楚了，具体请看 Android 实现书籍翻页效果----原理篇 Androi...
Android 自定义View贝塞尔曲线实现书籍翻页的效果（包含原理解释）
zz51233273的博客
08-05 2046
先看效果图： 我先来解释一下该翻页的实现原理，大家来看下面这张图： 我们可以把翻页时的图案分为三部分，分别是第一页的图案，第一页的背面图案，以及第二页的图案。 我们将图形进一步数学化： 其中，c、d、b是以e为控制点的贝塞尔曲线上的点。同样，j、i、k是以h为控制点的贝塞尔曲线上的点。 a为翻角的顶点，线段eh为线段af的中垂线。 根据上图，我们可以对线段af左侧做出假设(另一边也同理)： ce=ef/2 p是线段cb的中点 d是线段pe的中点 b是ae和cj的交点 由
Android自定义View——从零开始实现书籍翻页效果，简单聊聊2024年Android开发的现状和思考
最新发布
m0_59117112的博客
03-25 1021
现在新技术层出不穷，如果每次出新的技术，我们都深入的研究的话，很容易分散精力。新的技术可能很久之后我们才会在工作中用得上，当学的新技术无法学以致用，很容易被我们遗忘，到最后真的需要使用的时候，又要从头来过（虽然上手会更快）。我觉得身为技术人，针对新技术应该是持拥抱态度的，入了这一行你就应该知道这是一个活到老学到老的行业，所以面对新技术，不要抵触，拥抱变化就好了。Flutter 明显是一种全新的技术，而对于这个新技术在发布之初，花一个月的时间学习它，成本确实过高。
Android双页翻书,Android翻书效果-双页模式
weixin_33427833的博客
05-28 579
然后根据自己的理解实现了一下双页模式，但是在加贝塞尔曲线的时候，效果不是很理象，这里把自己的思路记录一下。 这里来讲述一下以右下角开始翻页(参见上图)当我们开始翻动的时候，与X轴有交战P，与Y轴有交战Q当X轴上的值(Px)小于View的一半的时候，我们需要重新计算这个点所带来的其他值，我们要将P点移动到M这里已知T点，M点，O点三点坐标 线段MO=MS ，做垂线TB交PO于B，垂线SA交PO于...
Android自定义View——从零开始实现书籍翻页效果，从入门到精通
m0_64382743的博客
11-28 774
x4 = lineTwo_My_pointTwo.x; y4 = lineTwo_My_pointTwo.y; float pointX =((x1 - x2) * (x3 * y4 - x4 * y3) - (x3 - x4) * (x1 * y2 - x2 * y1)) / ((x3 - x4) * (y1 - y2) - (x1 - x2) * (y3 - y4)); float pointY =((y1 - y2) * (x3 * y4 - x4 * y3) - (x1 * y2 - x2 * y1
android+动态翻页,android酷炫翻页效果+图形分析
weixin_29686935的博客
05-27 345
public class PageWidget extends View {private static final String TAG = "hmg";private int mWidth = 480;private int mHeight = 800;private int mCornerX = 0; // 拖拽点对应的页脚private int mCornerY = 0;private P...
"Android实现酷炫3D星体旋转动画效果
在Android中，想要实现酷炫的3D动画效果，一般有两种选择：Open GL ES和Camera。Open GL ES虽然能够实现高级的3D特效或游戏，但使用起来过于复杂，而且并不开源，因此在实现简单的3D效果时，使用Camera就已经足够了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值