`
byebyegov5qq
  • 浏览: 1212962 次
文章分类
社区版块
存档分类
最新评论

Android 中如何自己通过代码绘图

 
阅读更多

下文来自：

http://emmet1988.iteye.com/blog/1058517


－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

BasicViewDraw.java

Java代码 收藏代码
  1. packagecom.view;
  3. importcom.test.R;
  4. importandroid.view.View;
  5. importandroid.content.Context;
  6. importandroid.graphics.Canvas;
  7. importandroid.graphics.Color;
  8. importandroid.graphics.Paint;
  9. importandroid.graphics.RectF;
  10. importandroid.graphics.Path;
  11. importandroid.graphics.Shader;
  12. importandroid.graphics.LinearGradient;
  14. /*自定义继承View的MyView*/
  15. publicclassBasicViewDrawextendsView{
  16. publicBasicViewDraw(Contextcontext){
  17. super(context);
  18. }
  20. /*重写onDraw（）*/
  21. @Override
  22. protectedvoidonDraw(Canvascanvas){
  23. super.onDraw(canvas);
  24. /*设置背景为白色*/
  25. canvas.drawColor(Color.WHITE);
  26. Paintpaint=newPaint();
  27. /*去锯齿*/
  28. paint.setAntiAlias(true);
  29. /*设置paint的颜色*/
  30. paint.setColor(Color.RED);
  31. /*设置paint的style为STROKE：空心*/
  32. paint.setStyle(Paint.Style.STROKE);
  33. /*设置paint的外框宽度*/
  34. paint.setStrokeWidth(3);
  35. /*画一个空心圆形*/
  36. canvas.drawCircle(40,40,30,paint);
  37. /*画一个空心正方形*/
  38. canvas.drawRect(10,90,70,150,paint);
  39. /*画一个空心长方形*/
  40. canvas.drawRect(10,170,70,200,paint);
  41. /*画一个空心椭圆形*/
  42. RectFre=newRectF(10,220,70,250);
  43. canvas.drawOval(re,paint);
  44. /*画一个空心三角形*/
  45. Pathpath=newPath();
  46. path.moveTo(10,330);
  47. path.lineTo(70,330);
  48. path.lineTo(40,270);
  49. path.close();//记得要close
  50. canvas.drawPath(path,paint);
  51. /*画一个空心梯形*/
  52. Pathpath1=newPath();
  53. path1.moveTo(10,410);
  54. path1.lineTo(70,410);
  55. path1.lineTo(55,350);
  56. path1.lineTo(25,350);
  57. path1.close();
  58. canvas.drawPath(path1,paint);
  60. /*设置paint的style为FILL：实心*/
  61. paint.setStyle(Paint.Style.FILL);
  62. /*设置paint的颜色*/
  63. paint.setColor(Color.BLUE);
  64. /*画一个实心圆*/
  65. canvas.drawCircle(120,40,30,paint);
  66. /*画一个实心正方形*/
  67. canvas.drawRect(90,90,150,150,paint);
  68. /*画一个实心长方形*/
  69. canvas.drawRect(90,170,150,200,paint);
  70. /*画一个实心椭圆*/
  71. RectFre2=newRectF(90,220,150,250);
  72. canvas.drawOval(re2,paint);
  73. /*画一个实心三角形*/
  74. Pathpath2=newPath();
  75. path2.moveTo(90,330);
  76. path2.lineTo(150,330);
  77. path2.lineTo(120,270);
  78. path2.close();
  79. canvas.drawPath(path2,paint);
  80. /*画一个实心梯形*/
  81. Pathpath3=newPath();
  82. path3.moveTo(90,410);
  83. path3.lineTo(150,410);
  84. path3.lineTo(135,350);
  85. path3.lineTo(105,350);
  86. path3.close();
  87. canvas.drawPath(path3,paint);
  88. /*设置渐变色*/
  89. ShadermShader=newLinearGradient(0,0,100,100,newint[]{
  90. Color.RED,Color.GREEN,Color.BLUE,Color.YELLOW},null,
  91. Shader.TileMode.REPEAT);
  92. paint.setShader(mShader);
  94. /*画一个渐变色圆*/
  95. canvas.drawCircle(200,40,30,paint);
  96. /*画一个渐变色正方形*/
  97. canvas.drawRect(170,90,230,150,paint);
  98. /*画一个渐变色长方形*/
  99. canvas.drawRect(170,170,230,200,paint);
  100. /*画一个渐变色椭圆*/
  101. RectFre3=newRectF(170,220,230,250);
  102. canvas.drawOval(re3,paint);
  103. /*画一个渐变色三角形*/
  104. Pathpath4=newPath();
  105. path4.moveTo(170,330);
  106. path4.lineTo(230,330);
  107. path4.lineTo(200,270);
  108. path4.close();
  109. canvas.drawPath(path4,paint);
  110. /*画一个渐变色梯形*/
  111. Pathpath5=newPath();
  112. path5.moveTo(170,410);
  113. path5.lineTo(230,410);
  114. path5.lineTo(215,350);
  115. path5.lineTo(185,350);
  116. path5.close();
  117. canvas.drawPath(path5,paint);
  119. /*写字*/
  120. paint.setTextSize(24);
  121. canvas.drawText(getResources().getString(R.string.str_text1),240,50,paint);
  122. canvas.drawText(getResources().getString(R.string.str_text2),240,120,paint);
  123. canvas.drawText(getResources().getString(R.string.str_text3),240,190,paint);
  124. canvas.drawText(getResources().getString(R.string.str_text4),240,250,paint);
  125. canvas.drawText(getResources().getString(R.string.str_text5),240,320,paint);
  126. canvas.drawText(getResources().getString(R.string.str_text6),240,390,paint);
  127. }
  128. }

BasicView2Draw.java

Java代码 收藏代码
  1. classBasicView2DrawextendsView{
  3. Paintpaint;
  4. Bitmapbitmap;
  6. publicBasicView2Draw(Contextcontext){
  7. super(context);
  8. paint=newPaint(Paint.ANTI_ALIAS_FLAG);
  9. bitmap=BitmapFactory.decodeResource(getResources(),R.drawable.icon);
  10. }
  12. privateBitmapcreateBitmap1(){
  13. Bitmapbitmap1=Bitmap.createBitmap(100,100,Config.ARGB_8888);
  14. Canvascanvas=newCanvas(bitmap1);
  15. canvas.drawColor(Color.BLUE);
  16. //canvas.drawARGB(0,0,0,0);//透明色
  17. canvas.drawBitmap(bitmap,0,0,paint);
  18. canvas.drawText("HelloAndroid",25,55,paint);
  19. returnbitmap1;
  20. }
  22. @Override
  23. protectedvoidonDraw(Canvascanvas){
  24. super.onDraw(canvas);
  26. //绘制位图
  27. //1.绘制位图在（10，10）位置上
  28. canvas.drawBitmap(createBitmap1(),10,10,paint);
  29. //2.canvas.drawBitmap(Bitmapbitmap,Rectsrc,Rectdest,Paintpaint);
  30. //canvas.drawBitmap(Bitmapbitmap,Rectsrc,RectFdest,Paintpaint);
  31. //绘制位图到一个指定的矩形dest中，位图会自动进行平移和缩放等操作，如果src的参数不为null
  32. //则会裁剪位图的部分区域来进行绘制
  33. Rectrect=newRect(10,10,50,60);
  34. RectFrectF1=newRectF(180.0f,20.0f,240.0f,80.0f);
  35. RectFrectF2=newRectF(180.0f,100.0f,240.0f,160.0f);
  36. canvas.drawBitmap(createBitmap1(),null,rectF1,paint);
  37. canvas.drawBitmap(createBitmap1(),rect,rectF2,paint);
  39. //点
  40. paint.setStyle(Paint.Style.FILL_AND_STROKE);
  41. paint.setStrokeWidth(5.0f);
  42. paint.setColor(Color.YELLOW);
  43. canvas.drawPoints(newfloat[]{120,120,140,140,160,160,180,180},paint);
  45. //线
  46. paint.reset();//重置画笔
  47. paint.setColor(Color.GREEN);
  48. paint.setAntiAlias(true);
  49. canvas.drawLine(30,30,130,40,paint);
  50. paint.setColor(Color.RED);
  51. canvas.drawLines(newfloat[]{40,40,140,40,50,50,90,90},paint);
  53. //矩形
  54. paint.setColor(Color.CYAN);
  55. canvas.drawRect(10,150,150,250,paint);
  56. paint.setColor(Color.GRAY);
  57. canvas.drawRect(newRect(10,260,150,280),paint);
  58. paint.setColor(Color.DKGRAY);
  59. canvas.drawRect(newRectF(20.2f,290.9f,120.2f,300.3f),paint);
  61. //绘制文本
  62. //paint.setTextSize(20);
  63. //paint.setColor(0x40ffffff);//半透明白色
  64. //paint.setTextAlign(Paint.Align.RIGHT);//对齐方向
  65. //canvas.drawText("CoolAndroid",250,180,paint);//这里注意，坐标(180,180)是文本的左下点坐标
  67. //画布平移：
  68. //平移的单位是像素，分别是在x,y轴上平移的像素点
  69. //正数代表的正方向，x轴为平面的右侧，y轴为平面的下方，相应的，负数则向反方向平移
  70. //canvas.translate(30.0f,30.0f);
  72. //画布缩放：
  73. //参数分别是在想x，y轴上放大或缩小的倍数，大雨1为放大，小于1为缩小，
  74. //缩放的原点默认为画布的原点(0,0)，也可以指定缩放的原点
  75. //canvas.scale(2.0f,1.5f);
  76. //canvas.scale(0.5f,0.5f,100.0f,100.0f);//指定坐标(100.0f,100.0f)为缩放原点
  77. //这里剖析一下第二个缩放方法，其实系统为我们做的事情是这样的
  78. /*
  79. scale(floatsx,floatsy,floatpx,floatpy){
  80. translate(px,py);
  81. scale(sx,sy);
  82. translate(-px,-py);
  83. }
  84. */
  86. //画布旋转
  87. //1.以画布为原点，顺时针旋转40.0f度
  88. //canvas.rotate(40.0f);
  89. //2.以(100.11f,100.22f)为原点，顺时针旋转50.0f度
  90. //canvas.rotate(50.0f,100.11f,100.22f);
  91. //相应的，为了加深理解，我们再剖析一下第二个旋转方法
  92. //，其实系统为我们做的事情是这样的
  93. /*
  94. rotate(floatdegrees,floatpx,floatpy){
  95. translate(px,py);
  96. rotate(degrees);
  97. translate(-px,-py);
  98. }
  99. */
  101. //画布倾斜
  102. //skew(floatsx,floatxy);将画布在x及y轴方向上倾斜相应的角度，sx或sy为倾斜角度的tan值，
  103. //如canvas.skew(1,0);为在x方向上倾斜45度>>tan(45)=1
  104. //canvas.skew(1,0);
  105. }
  106. }

ClipRectDraw.java

Java代码 收藏代码
  1. packagecom.view;
  3. importandroid.content.Context;
  4. importandroid.graphics.Canvas;
  5. importandroid.graphics.Color;
  6. importandroid.graphics.Paint;
  7. importandroid.graphics.Path;
  8. importandroid.graphics.Region;
  9. importandroid.util.AttributeSet;
  10. importandroid.view.View;
  12. /**
  13. *---------------------------------------------------矩形区域-------------------------------------------------
  14. *canvas.clipRect(左上角x轴坐标,左上角y轴坐标,右下角x轴坐标,右下角y轴坐标,Region.Op.XOR);
  15. *最后一个参数有多个选择分别是：
  16. *//DIFFERENCE是第一次不同于第二次的部分显示出来
  17. //REPLACE是显示第二次的
  18. //REVERSE_DIFFERENCE是第二次不同于第一次的部分显示
  19. //INTERSECT：交集显示
  20. //UNION：全部显示
  21. //XOR补集，就是全集的减去交集剩余部分显示
  23. *@authoremmet1988.iteye.com
  24. *
  25. */
  26. publicclassClipRectDrawextendsView{
  28. Contextcontext;
  29. Paintpaint;
  30. Pathpath;
  32. publicClipRectDraw(Contextcontext){
  33. super(context);
  34. init();
  35. }
  37. publicClipRectDraw(Contextcontext,AttributeSetattrs){
  38. super(context,attrs);
  39. init();
  40. }
  42. publicClipRectDraw(Contextcontext,AttributeSetattrs,intdefStyle){
  43. super(context,attrs,defStyle);
  44. init();
  45. }
  47. privatevoidinit(){
  48. paint=newPaint();
  49. paint.setAntiAlias(true);
  50. paint.setStrokeWidth(5);
  51. paint.setTextSize(15);
  52. paint.setTextAlign(Paint.Align.RIGHT);
  53. path=newPath();
  54. }
  56. @Override
  57. protectedvoidonDraw(Canvascanvas){
  58. super.onDraw(canvas);
  59. canvas.drawColor(Color.GRAY);
  60. //左上图
  61. canvas.save();
  62. canvas.translate(10,10);
  63. drawScene(canvas);
  64. canvas.restore();
  65. //右上图
  66. canvas.save();
  67. canvas.translate(160,10);
  68. canvas.clipRect(10,10,90,90);
  69. canvas.clipRect(30,30,70,70,Region.Op.XOR);
  70. drawScene(canvas);
  71. canvas.restore();
  72. //左中图
  73. canvas.save();
  74. canvas.translate(10,130);
  75. path.reset();
  76. /*抛物曲线*/
  77. path.cubicTo(0,0,100,0,100,100);
  78. path.cubicTo(100,100,0,100,0,0);
  79. canvas.clipPath(path,Region.Op.REPLACE);
  80. drawScene(canvas);
  81. canvas.restore();
  82. //右中图
  83. canvas.save();
  84. canvas.translate(160,130);
  85. canvas.clipRect(0,0,60,60);
  86. canvas.clipRect(40,40,100,100,Region.Op.UNION);
  87. drawScene(canvas);
  88. canvas.restore();
  89. //左下图
  90. canvas.save();
  91. canvas.translate(10,250);
  92. canvas.clipRect(0,0,60,60);
  93. canvas.clipRect(40,40,100,100,Region.Op.XOR);
  94. drawScene(canvas);
  95. canvas.restore();
  96. //右下图
  97. canvas.translate(160,250);
  98. canvas.clipRect(0,0,60,60);
  99. canvas.clipRect(40,40,100,100,Region.Op.REVERSE_DIFFERENCE);
  100. drawScene(canvas);
  101. canvas.restore();
  102. }
  104. privatevoiddrawScene(Canvascanvas){
  105. canvas.clipRect(0,0,100,100);
  106. canvas.drawColor(Color.WHITE);
  108. paint.setColor(Color.RED);
  109. canvas.drawLine(0,0,100,100,paint);
  111. paint.setColor(Color.GREEN);
  112. canvas.drawCircle(30,70,30,paint);
  114. paint.setColor(Color.BLUE);
  115. canvas.drawText("ChenJianLi",100,30,paint);
  116. }
  118. }

MatrixDraw.java

Java代码 收藏代码
  1. packagecom.view;
  3. importcom.test.R;
  5. importandroid.content.Context;
  6. importandroid.graphics.Bitmap;
  7. importandroid.graphics.Canvas;
  8. importandroid.graphics.Matrix;
  9. importandroid.graphics.Paint;
  10. importandroid.graphics.drawable.BitmapDrawable;
  11. importandroid.view.View;
  12. /**
  13. *在Android里面，Matrix由9个float值构成，是一个3*3的矩阵。
  14. *cosX,-sinX,translateX
  15. *sinX,cosX,translateY
  16. *0,0,scale
  17. *解释一下，上面的sinX和cosX，表示旋转角度的cos值和sin值，注意，
  18. *旋转角度是按顺时针方向计算的。translateX和translateY表示x和y的平移量。
  19. *scale是缩放的比例，1是不变，2是表示缩放1/2，
  20. *@authoremmet1988.iteye.com
  21. *
  22. */
  23. publicclassMatrixDrawextendsViewimplementsRunnable{
  25. Bitmapbitmap;
  26. Matrixmatrix=newMatrix();
  27. Paintpaint;
  29. publicMatrixDraw(Contextcontext){
  30. super(context);
  31. bitmap=((BitmapDrawable)getResources().getDrawable(R.drawable.rotate_surfaceview)).getBitmap();
  32. paint=newPaint();
  33. paint.setAntiAlias(true);
  34. newThread(this).start();
  35. }
  37. floatm;
  38. floatn;
  39. @Override
  40. protectedvoidonDraw(Canvascanvas){
  42. /*
  43. floatcosValue=(float)Math.cos(-Math.PI/m);
  44. floatsinValue=(float)Math.sin(-Math.PI/m);
  46. Log.d("matrixdraw","Math.PI="+Math.PI);
  47. Log.d("matrixdraw","Math.PI/m="+Math.PI/m);
  48. Log.d("matrixdraw","Math.cos(-Math.PI/m)="+(float)Math.cos(-Math.PI/m));
  49. Log.d("matrixdraw","Math.sin(-Math.PI/m)="+(float)Math.sin(-Math.PI/m));
  51. matrix.setValues(newfloat[]{
  52. cosValue,-sinValue,100,
  53. sinValue,cosValue,100,
  54. 0,0,2
  55. });//举例，若缩放值为0.9，代表放大原图的十分之一
  56. //super.onDraw(canvas);//当然，如果界面上还有其他元素需要绘制，只需要将这句话写上就行了。
  58. //Matrixmatrix2=newMatrix(matrix);
  59. canvas.drawBitmap(bitmap,matrix,paint);
  60. //canvas.drawBitmap(bitmap,matrix2,paint);
  61. */
  62. n++;
  63. if(n==60){
  64. n=0;
  65. }
  66. matrix.postRotate(n);
  67. matrix.postTranslate(n,n);
  68. matrix.postScale(1,1,n,n);
  69. canvas.drawBitmap(bitmap,matrix,paint);
  70. }
  72. @Override
  73. publicvoidrun(){
  74. while(!Thread.currentThread().isInterrupted()){
  75. try{
  76. Thread.sleep(100);
  77. postInvalidate();
  78. }catch(InterruptedExceptione){
  79. Thread.currentThread().interrupt();
  80. }
  81. }
  82. }
  84. /**
  85. *以左上角为顶点，缩放一半，逆时针旋转30度，
  86. *然后沿x轴和y轴分别平移50个像素，
  87. *代码里面写的是100，为什么是平移50呢，
  88. *因为缩放了一半。
  89. *大家可以自己设置一下Matrix的值，或者尝试一下两个
  90. *Matrix相乘，得到的值设置进去，
  91. *这样才能对Matrix更加熟练。
  92. */
  94. }

Matrix2Draw.java

Java代码 收藏代码
  1. publicclassMatrix2DrawextendsView{
  3. privateBitmapmBitmap;
  4. privateMatrixmMatrix=newMatrix();
  6. publicMatrix2Draw(Contextcontext){
  7. super(context);
  8. initialize();
  9. }
  11. privatevoidinitialize(){
  13. Bitmapbmp=((BitmapDrawable)getResources().getDrawable(R.drawable.rotate_surfaceview)).getBitmap();
  14. mBitmap=bmp;
  15. /*首先，将缩放为100*100。这里scale的参数是比例。有一点要注意，如果直接用100/
  16. bmp.getWidth()的话，会得到0，因为是整型相除，所以必须其中有一个是float型的，
  17. 直接用100f就好。*/
  18. mMatrix.setScale(100f/bmp.getWidth(),100f/bmp.getHeight());
  19. /*//post方式：后乘>>当前的矩阵乘以参数给出的矩阵。可以连续多次使用post，来完成所需的整个变换。
  20. //平移到（100，100）处
  21. mMatrix.postTranslate(100,100);
  22. //倾斜x和y轴，以（100，100）为中心。
  23. mMatrix.postSkew(0.2f,0.2f,100,100);*/
  24. //pre方式：前乘>>参数给出的矩阵乘以当前的矩阵。所以操作是在当前矩阵的最前面发生的。
  25. //平移到（100，100）处
  26. mMatrix.preTranslate(100,100);
  27. //倾斜x和y轴，以（100，100）为中心。
  28. mMatrix.preSkew(0.2f,0.2f,100,100);
  29. }
  31. @OverrideprotectedvoidonDraw(Canvascanvas){
  32. //super.onDraw(canvas);//如果界面上还有其他元素需要绘制，只需要将这句话写上就行了。
  33. Paintpaint=newPaint(Paint.ANTI_ALIAS_FLAG);
  34. canvas.drawBitmap(mBitmap,mMatrix,paint);
  35. }
  36. }
  38. /**
  39. Matrix的操作:
  41. 总共分为translate（平移），rotate（旋转），scale（缩放）和skew（倾斜）四种，每一种变换在
  43. Android的API里都提供了set,post和pre三种操作方式,除了translate，其他三种操作都可以指定中心点。
  45. set是直接设置Matrix的值，每次set一次，整个Matrix的数组都会变掉。
  47. post是后乘，当前的矩阵乘以参数给出的矩阵。可以连续多次使用post，来完成所需的整个变换。
  49. pre是前乘，参数给出的矩阵乘以当前的矩阵。所以操作是在当前矩阵的最前面发生的。
  51. 旋转、缩放和倾斜都可以围绕一个中心点来进行，如果不指定，默认情况下，是围绕(0,0)点来进行。
  52. */

SimpleDraw.java

Java代码 收藏代码
  1. packagecom.view;
  3. importandroid.content.Context;
  4. importandroid.graphics.Canvas;
  5. importandroid.graphics.Color;
  6. importandroid.graphics.Paint;
  7. importandroid.graphics.Rect;
  8. importandroid.view.View;
  10. publicclassSimpleDrawextendsViewimplementsRunnable{
  12. /*
  13. *我们继续来介绍Android平台底层绘图类的相关内容，在AndroidUI开发专题(一)
  14. *之界面设计中我们介绍了有关Android平台资源使用以及Bitmap相关类的操作
  15. *，接下来将会以实例的方式给大家演示各种类的用处以及注意点。今天我们继续
  16. *了解android.graphics包中比较重要的绘图类。
  17. *
  18. *一、android.graphics.Matrix有关图形的变换、缩放等相关操作常用的方法有:
  19. *Java代码：voidreset()//重置一个matrix对象。
  20. *voidset(Matrixsrc)//复制一个源矩阵，和本类的构造方法Matrix(Matrixsrc)一样
  21. *booleanisIdentity()//返回这个矩阵是否定义(已经有意义)
  22. *voidsetRotate(floatdegrees)//指定一个角度以0,0为坐标进行旋转
  23. *voidsetRotate(floatdegrees,floatpx,floatpy)//指定一个角度以px,py为坐标进行旋转
  24. *voidsetScale(floatsx,floatsy)//缩放
  25. *voidsetScale(floatsx,floatsy,floatpx,floatpy)//以坐标px,py进行缩放
  26. *voidsetTranslate(floatdx,floatdy)//平移
  27. *voidsetSkew(floatkx,floatky,floatpx,floatpy)//以坐标px,py进行倾斜
  28. *voidsetSkew(floatkx,floatky)//倾斜复制代码二、android.graphics.NinePatch
  29. *
  30. *NinePatch是Android平台特有的一种非矢量图形自然拉伸处理方法，可以帮助常规的
  31. *图形在拉伸时不会缩放，
  32. *实例中Android开发网提示大家对于Toast的显示就是该原理，同时SDK中提供了一
  33. *个工具名为Draw
  34. *9-Patch，有关该工具的使用方法可以参考我们经发布的Draw
  35. *9-Patch使用方法介绍一文。由于该类提供了高质量支持透明的缩放方式，所以图形
  36. *格式为PNG，文件命名方式为.9.png
  37. *的后缀比如eoeandroid。
  38. *
  39. *三、android.graphics.Paint。Paint类我们可以理解为画笔、画刷的属性定义，本类
  40. *常用的方法如下:
  41. *
  42. *Java代码：voidreset()//重置
  43. *voidsetARGB(inta,intr,intg,intb)或voidsetColor(intcolor)
  44. *//均为设置Paint对象的颜色
  45. *voidsetAntiAlias(booleanaa)
  46. *
  47. *//是否抗锯齿，需要配合voidsetFlags(Paint.ANTI_ALIAS_FLAG)来帮助消除锯齿
  48. *使其边缘更平滑。
  49. *ShadersetShader(Shadershader)
  50. *
  51. *//设置阴影，Shader类是一个矩阵对象，如果为NULL将清除阴影。
  52. *voidsetStyle(Paint.Stylestyle)//设置样式，一般为FILL填充，或者STROKE凹陷
  53. *效果。
  54. *voidsetTextSize(floattextSize)//设置字体大小
  55. *voidsetTextAlign(Paint.Alignalign)//文本对齐方式
  56. *TypefacesetTypeface(Typefacetypeface)
  57. *//设置字体，通过Typeface可以加载Android内部的字体，一般为宋体对于中文，
  58. *部分ROM可以自己添加比如雅黑等等
  59. *voidsetUnderlineText(booleanunderlineText)
  60. *
  61. *//是否设置下划线，需要撇和voidsetFlags(Paint.UNDERLINE_TEXT_FLAG)方法。复制代码
  62. *四、android.graphics.Rect
  63. *
  64. *Rect我们可以理解为矩形区域，类似的还有Point一个点，Rect类除了表示一个矩
  65. *形区域位置描述外，
  66. *eoeandroid提示主要可以帮助我们计算图形之间是否碰撞
  67. *(包含)关系，对于Android游戏开发比较有用，其主要的成员contains包含了三种
  68. *重载方法，来判断包含关系.
  69. *
  70. *Java代码：
  71. *booleancontains(intleft,inttop,intright,intbottom)
  72. *booleancontains(intx,inty)
  73. *
  74. *booleancontains(Rectr)复制代码五、android.graphics.Region
  75. *Region在Android平台中表示一个区域和Rect不同的是
  76. *，它表示的是一个不规则的样子，可以是椭圆、多边形等等，而Rect仅仅是矩形。
  77. *同样Region的booleancontains(intx,
  78. *inty)成员可以判断一个点是否在该区域内。
  79. *
  80. *六、android.graphics.Typeface
  81. *Typeface类是帮助描述一个字体对象，在TextView中通过使用setTypeface方法来
  82. *制定一个输出文本的字体
  83. *，其直接构造调用成员create方法可以直接指定一个字体名称和样式，比如
  84. *Java代码：staticTypefacecreate(Typefacefamily,intstyle)
  85. *
  86. *staticTypefacecreate(StringfamilyName,intstyle)复制代码
  87. *同时使用isBold和isItalic方法可以判断出是否包含粗体或斜体的字型。
  88. *
  89. *Java代码：finalbooleanisBold()
  90. *finalbooleanisItalic()复制代码该类的创建方法还有从apk的资源或从一个具体的
  91. *文件路径，其具体方法为
  92. *Java代码：staticTypefacecreateFromAsset(AssetManagermgr,Stringpath)
  93. *staticTypefacecreateFromFile(Filepath)
  94. *staticTypefacecreateFromFile(Stringpath)复制代码
  95. */
  97. privatePaintpaint;
  99. publicSimpleDraw(Contextcontext){
  100. super(context);
  101. paint=newPaint();
  102. newThread(this).start();
  103. }
  105. @Override
  106. protectedvoidonDraw(Canvascanvas){
  107. super.onDraw(canvas);
  109. canvas.drawColor(Color.GRAY);//
  110. paint.setAntiAlias(true);//
  112. canvas.save();//
  113. canvas.clipRect(10,10,110,110);//
  114. canvas.drawColor(Color.WHITE);//
  115. //canvas.rotate(m);//以屏幕左上角为坐标原点旋转
  116. m+=45.0f;
  117. if(m==360.0f){
  118. m=0.0f;
  119. }
  120. canvas.rotate(m,60,60);//以(60,60)为原点旋转
  121. paint.setColor(Color.GREEN);
  122. canvas.drawRect(newRect(50,50,70,70),paint);
  123. canvas.restore();
  125. canvas.save();
  126. canvas.translate(140,10);
  127. canvas.clipRect(0,0,100,100);//一定要先剪辑出矩形区域再设画布背景，
  128. //否则会覆盖整张画布
  129. canvas.drawColor(Color.BLACK);
  130. paint.setColor(Color.BLUE);
  131. canvas.drawRect(newRect(10,10,50,50),paint);
  132. canvas.restore();
  133. //
  134. canvas.save();
  135. canvas.translate(120,120);
  136. canvas.clipRect(newRect(0,0,100,100));
  137. canvas.drawColor(Color.GREEN);
  138. //paint.setColor(Color.BLUE);
  139. paint.setStrokeWidth(4);
  140. paint.setColor(Color.BLACK);
  141. canvas.drawLine(0,60,100,60,paint);
  142. paint.setARGB(255,51,51,51);
  143. paint.setTextSize(20);
  144. paint.setFlags(Paint.ANTI_ALIAS_FLAG);
  145. paint.setUnderlineText(true);
  146. //paint.setFlags(Paint.UNDERLINE_TEXT_FLAG);
  147. canvas.drawText("陈建立",25,80,paint);
  148. paint.setColor(Color.WHITE);
  149. canvas.drawRect(newRect(10,10,50,50),paint);
  150. canvas.restore();
  151. }
  153. floatm=0.0f;
  155. publicvoidrun(){
  156. while(!Thread.currentThread().isInterrupted()){
  157. try{
  158. Thread.sleep(500);//每半秒执行一次
  159. }catch(InterruptedExceptione){
  160. Thread.currentThread().interrupt();
  161. }
  162. postInvalidate();
  163. }
  164. }
  165. }

TextDraw.java

Java代码 收藏代码
  1. packagecom.view;
  3. importandroid.content.Context;
  4. importandroid.graphics.Canvas;
  5. importandroid.graphics.Color;
  6. importandroid.graphics.Paint;
  7. importandroid.graphics.Paint.FontMetrics;
  8. importandroid.util.Log;
  9. importandroid.view.View;
  11. publicclassTextDrawextendsView{
  13. publicTextDraw(Contextcontext){
  14. super(context);
  15. }
  17. @Override
  18. protectedvoidonDraw(Canvascanvas){
  19. super.onDraw(canvas);
  20. PainttextPaint=newPaint(Paint.ANTI_ALIAS_FLAG);
  21. textPaint.setTextSize(35);
  22. textPaint.setColor(Color.WHITE);
  24. //FontMetrics
  25. FontMetricsfontMetrics=textPaint.getFontMetrics();
  27. Stringtext="abcdefghijklm";
  29. //
  30. floatbaseX=0;
  31. floatbaseY=100;
  32. Log.d("textDraw","top="+fontMetrics.top+
  33. "ascent="+fontMetrics.ascent+
  34. "descent="+fontMetrics.descent+
  35. "bottom="+fontMetrics.bottom+"\n");
  36. floattopY=baseY+fontMetrics.top;
  37. floatascentY=baseY+fontMetrics.ascent;
  38. floatdescentY=baseY+fontMetrics.descent;
  39. floatbottomY=baseY+fontMetrics.bottom;
  40. Log.d("textDraw","topY="+topY+
  41. "ascentY="+ascentY+
  42. "descentY="+descentY+
  43. "bottomY="+bottomY);
  44. //
  45. canvas.drawText(text,baseX,baseY,textPaint);
  47. //BaseLine
  48. PaintbaseLinePaint=newPaint(Paint.ANTI_ALIAS_FLAG);
  49. baseLinePaint.setColor(Color.RED);
  50. canvas.drawLine(0,baseY,getWidth(),baseY,baseLinePaint);
  52. //Base
  53. canvas.drawCircle(baseX,baseY,5,baseLinePaint);
  55. //TopLine
  56. PainttopLinePaint=newPaint(Paint.ANTI_ALIAS_FLAG);
  57. topLinePaint.setColor(Color.LTGRAY);
  58. canvas.drawLine(0,topY,getWidth(),topY,topLinePaint);
  60. //AscentLine
  61. PaintascentLinePaint=newPaint(Paint.ANTI_ALIAS_FLAG);
  62. ascentLinePaint.setColor(Color.GREEN);
  63. canvas.drawLine(0,ascentY,getWidth(),ascentY,ascentLinePaint);
  65. //DescentLine
  66. PaintdescentLinePaint=newPaint(Paint.ANTI_ALIAS_FLAG);
  67. descentLinePaint.setColor(Color.YELLOW);
  68. canvas.drawLine(0,descentY,getWidth(),descentY,descentLinePaint);
  70. //ButtomLine
  71. PaintbottomLinePaint=newPaint(Paint.ANTI_ALIAS_FLAG);
  72. bottomLinePaint.setColor(Color.MAGENTA);
  73. canvas.drawLine(0,bottomY,getWidth(),bottomY,bottomLinePaint);
  74. }
  75. }

RoundAndReflectionDraw.java

Java代码 收藏代码
  1. classRoundImageViewextendsView{
  3. privateBitmapbitmap;
  4. intbitmapWidth;
  5. intbitmapHeight;
  7. publicRoundImageView(Contextcontext){
  8. super(context);
  9. bitmap=BitmapFactory.decodeResource(getResources(),R.drawable.rotate_surfaceview);
  10. bitmapWidth=bitmap.getWidth();
  11. bitmapHeight=bitmap.getHeight();
  12. }
  14. @Override
  15. protectedvoidonDraw(Canvascanvas){
  16. super.onDraw(canvas);
  17. //第一种方法：
  18. /*BitmaproundBitmap=Bitmap.createBitmap(bitmapWidth,bitmapHeight,Bitmap.Config.ARGB_8888);
  19. canvas=newCanvas(roundBitmap);
  20. Paintpaint=newPaint(Paint.ANTI_ALIAS_FLAG);
  21. paint.setColor(Color.BLUE);
  22. canvas.drawRoundRect(newRectF(0,0,bitmapWidth,bitmapHeight),20.0f,20.0f,paint);
  23. paint.setXfermode(newPorterDuffXfermode(PorterDuff.Mode.DST_IN));
  24. canvas.drawBitmap(bitmap,0,0,null);
  25. canvas.drawBitmap(roundBitmap,0,0,paint);*/
  26. //第二种方法：
  27. Paintpaint=newPaint(Paint.ANTI_ALIAS_FLAG);
  28. paint.setColor(0xffffffff);
  29. paint.setTextSize(15);
  30. canvas.drawText("生成带圆角的图片",10,25,paint);
  31. canvas.drawBitmap(getRoundedCornerBitmap(bitmap),10,30,paint);
  33. canvas.drawText("生成带倒影的图片",170,160,paint);
  34. canvas.drawBitmap(createReflectionImageWithOrigin(bitmap),170,165,paint);
  36. }
  38. publicBitmapgetRoundedCornerBitmap(Bitmapbitmap){
  39. //创建一个指定宽度和高度的空位图对象
  40. Bitmapoutput=Bitmap.createBitmap(bitmap.getWidth(),bitmap.getHeight(),Config.ARGB_8888);
  41. //用该位图创建画布
  42. Canvascanvas=newCanvas(output);
  43. //画笔对象
  44. finalPaintpaint=newPaint();
  45. //画笔的颜色
  46. finalintcolor=0xff424242;
  47. //矩形区域对象
  48. finalRectrect=newRect(0,0,bitmap.getWidth(),bitmap.getHeight());
  49. //未知
  50. finalRectFrectF=newRectF(rect);
  51. //拐角的半径
  52. finalfloatroundPx=12;
  53. //消除锯齿
  54. paint.setAntiAlias(true);
  55. //画布背景色
  56. canvas.drawARGB(0,0,0,0);
  57. //设置画笔颜色
  58. paint.setColor(color);
  59. //绘制圆角矩形
  60. canvas.drawRoundRect(rectF,roundPx,roundPx,paint);
  61. //未知
  62. paint.setXfermode(newPorterDuffXfermode(Mode.SRC_IN));
  63. //把该图片绘制在该圆角矩形区域中
  64. canvas.drawBitmap(bitmap,rect,rect,paint);
  65. //最终在画布上呈现的就是该圆角矩形图片，然后我们返回该Bitmap对象
  66. returnoutput;
  67. }
  69. //获得带倒影的图片方法
  70. publicBitmapcreateReflectionImageWithOrigin(Bitmapbitmap){
  71. //图片与倒影之间的距离间隔
  72. finalintreflectionGap=2;
  73. //原图的宽度
  74. intwidth=bitmap.getWidth();
  75. //原图的高度
  76. intheight=bitmap.getHeight();
  77. //图片旋转，缩放等控制对象
  78. Matrixmatrix=newMatrix();
  79. //缩放（这里pre,set,post三种效果是不一样的，注意区别）
  80. matrix.preScale(1,-1);
  81. /**
  82. set是直接设置Matrix的值，每次set一次，整个Matrix的数组都会变掉。
  83. post是后乘，当前的矩阵乘以参数给出的矩阵。可以连续多次使用post，
  84. 来完成所需的整个变换。例如，要将一个图片旋
  85. 转30度，然后平移到(100,100)的地方，那么可以这样做:
  86. Matrixm=newMatrix();
  87. m.postRotate(30);
  88. m.postTranslate(100,100);
  89. 这样就达到了想要的效果。
  90. pre是前乘，参数给出的矩阵乘以当前的矩阵。所以操作是在当前矩阵的最前面发生的。
  91. 例如上面的例子，如果用pre的话，就要这样:
  92. Matrixm=newMatrix();
  93. m.setTranslate(100,100);
  94. m.preRotate(30);
  95. 旋转、缩放和倾斜都可以围绕一个中心点来进行，如果不指定，默认情况下，
  96. 是围绕(0,0)点来进行。
  98. 关于缩放：
  99. scale的参数是比例。例如，我们缩放为100%，则有一点要注意，如果直接用
  100. 100/bmp.getWidth()的话，会得到0，因为是整型相除，所以必须其中有一个是
  101. float型的，直接用100f就好。
  102. 如：matrix.setScale(100f/bmp.getWidth(),100f/bmp.getHeight());
  103. */
  104. //创建一个初始的倒影位图
  105. BitmapreflectionImage=Bitmap.createBitmap(bitmap,0,height/2,width,height/2,matrix,false);
  106. //新建一个宽度为原图宽度，高度为原图高度的3/2的位图，用于绘制新的位图，即整体的效果图位图对象
  107. BitmapbitmapWithReflection=Bitmap.createBitmap(width,(height+height/2),Config.ARGB_8888);
  108. //由该位图对象创建初始画布(规定了画布的宽高)
  109. Canvascanvas=newCanvas(bitmapWithReflection);
  110. //在该画布上绘制原图
  111. canvas.drawBitmap(bitmap,0,0,null);
  112. //创建一个画笔
  113. PaintdeafalutPaint=newPaint();
  114. //绘制一个矩形区域，该矩形区域便是原图和倒影图之间的间隔图
  115. canvas.drawRect(0,height,width,height+reflectionGap,deafalutPaint);
  116. //绘制该倒影图于间隔图的下方
  117. canvas.drawBitmap(reflectionImage,0,height+reflectionGap,null);
  118. //创建一个画笔
  119. Paintpaint=newPaint();
  120. //创建一个线性渐变对象
  121. LinearGradientshader=newLinearGradient(
  122. 0,bitmap.getHeight(),
  123. 0,bitmapWithReflection.getHeight()+reflectionGap,
  124. 0x70ffffff,0x00ffffff,
  125. TileMode.CLAMP
  126. );
  127. //把渐变效果应用在画笔上
  128. paint.setShader(shader);
  129. //SettheTransfermodetobeporterduffanddestinationin
  130. //未知
  131. paint.setXfermode(newPorterDuffXfermode(Mode.DST_IN));
  132. //Drawarectangleusingthepaintwithourlineargradient
  133. //绘制出该渐变效果，也就是最终的倒影效果图
  134. canvas.drawRect(0,height,width,bitmapWithReflection.getHeight()+reflectionGap,paint);
  135. //返回
  136. returnbitmapWithReflection;
  137. }
  139. }
  141. /**
  142. *绘制圆角背景以及图片圆角的处理
  143. .配置文件实现
  144. <?xmlversion="1.0"encoding="utf-8"?>
  145. <layer-list
  146. *xmlns:android="http://schemas.android.com/apk/res/android"><item
  147. *android:drawable="@drawable/icon_home_button_img"/><item
  148. *android:drawable="@drawable/icon_home_shape_overlay"/>
  149. *</layer-list>
  150. *icon_home_shape_overlay如下
  151. *<?xmlversion="1.0"encoding="utf-8"?>
  152. *<shape
  153. *xmlns:android="http://schemas.android.com/apk/res/android"><solid
  154. *android:color="#60000000"/>
  155. *<strokeandroid:width="3dp"
  156. *color="#ff000000"/>
  157. *<cornersandroid:radius="10dp"/>
  158. *</shape>
  159. *或者直接使用一种效果
  160. *<?xmlversion="1.0"encoding="UTF-8"?>
  161. *<shape
  162. *xmlns:android="http://schemas.android.com/apk/res/android">
  163. *<solid
  164. *android:color="#99FFFFFF"/>
  165. *<cornersandroid:radius="30px"/>
  166. *<padding
  167. *android:left="0dp"android:top="0dp"android:right="0dp"
  168. *android:bottom="0dp"/>
  169. *</shape>
  170. *然后
  171. *android:background="@drawable/my_shape_file"
  172. *
  173. *
  174. *2.图片本身加上圆角BitmapmyCoolBitmap=...;//<--Yourbitmapyouwantrounded
  175. *
  176. *intw=myCoolBitmap.getWidth(),h=myCoolBitmap.getHeight();
  177. *Bitmaprounder=Bitmap.createBitmap(w,h,Bitmap.Config.ARGB_8888);Canvas
  178. *canvas=newCanvas(rounder);
  179. *
  180. *PaintxferPaint=newPaint(Paint.ANTI_ALIAS_FLAG);
  181. *xferPaint.setColor(Color.RED);
  182. *
  183. *canvas.drawRoundRect(newRectF(0,0,w,h),20.0f,20.0f,xferPaint);
  184. *
  185. *xferPaint.setXfermode(newPorterDuffXfermode(PorterDuff.Mode.DST_IN));
  186. *canvas.drawBitmap(myCoolBitmap,0,0,null);
  187. *canvas.drawBitmap(rounder,0,0,xferPaint);
  188. *或者
  189. *publicstaticBitmapgetRoundedCornerBitmap(Bitmapbitmap){
  190. *Bitmapoutput=Bitmap.createBitmap(bitmap.getWidth(),
  191. *bitmap.getHeight(),Config.ARGB_8888);
  192. *Canvascanvas=newCanvas(output);
  193. *
  194. *finalintcolor=0xff424242;finalPaintpaint=newPaint();finalRect
  195. *rect=newRect(0,0,bitmap.getWidth(),bitmap.getHeight());finalRectF
  196. *rectF=newRectF(rect);finalfloatroundPx=12;
  197. *
  198. *paint.setAntiAlias(true);canvas.drawARGB(0,0,0,0);
  199. *paint.setColor(color);canvas.drawRoundRect(rectF,roundPx,roundPx,paint);
  200. *
  201. *paint.setXfermode(newPorterDuffXfermode(Mode.SRC_IN));
  202. *canvas.drawBitmap(bitmap,rect,rect,paint);
  203. *
  204. *returnoutput;
  205. *}
  206. */

SurfaceViewDraw.java

Java代码 收藏代码
  1. packagecom.view;
  3. importcom.test.R;
  5. importandroid.content.Context;
  6. importandroid.graphics.Bitmap;
  7. importandroid.graphics.BitmapFactory;
  8. importandroid.graphics.Canvas;
  9. importandroid.graphics.Matrix;
  10. importandroid.graphics.Paint;
  11. importandroid.graphics.Rect;
  12. importandroid.util.Log;
  13. importandroid.view.SurfaceHolder;
  14. importandroid.view.SurfaceView;
  15. /**
  16. *http://wallage.blog.163.com/blog/static/173896242010101232220959/
  17. *@authoremmet1988.iteye.com
  18. *
  19. */
  20. publicclassSurfaceViewDrawextendsSurfaceViewimplementsRunnable,SurfaceHolder.Callback{
  22. privateBitmapbackgroundBitmap;
  23. privateBitmaprotateBitmap;
  24. SurfaceHoldersurfaceHolder;
  26. publicSurfaceViewDraw(Contextcontext){
  27. super(context);
  28. backgroundBitmap=BitmapFactory.decodeResource(getResources(),R.drawable.background_surfaceview);
  29. rotateBitmap=BitmapFactory.decodeResource(getResources(),R.drawable.rotate_surfaceview);
  30. surfaceHolder=this.getHolder();
  31. surfaceHolder.addCallback(this);
  32. }
  34. publicvoidsurfaceCreated(SurfaceHolderholder){
  35. newThread(this).start();
  36. Log.d("surfaceview","surfaceCreated");
  37. }
  39. publicvoidsurfaceChanged(SurfaceHolderholder,intformat,intwidth,
  40. intheight){
  41. Log.d("surfaceview","surfaceChanged");
  42. }
  44. publicvoidsurfaceDestroyed(SurfaceHolderholder){
  45. Log.d("surfaceview","surfaceDestroyed");
  46. }
  48. @Override
  49. publicvoidrun(){
  50. Log.d("surfaceview","run");
  51. Canvascanvas=null;
  52. introtateValue=0;//旋转角度
  53. intframeCount=0;//帧计数器
  54. while(!Thread.currentThread().isInterrupted()){
  55. try{
  56. //canvas=surfaceHolder.lockCanvas();//获取画布对象(获取整个屏幕的画布)
  57. canvas=surfaceHolder.lockCanvas(newRect(10,10,240,250));//获取某个区域的画布
  58. Paintpaint=newPaint();
  59. Log.d("surfaceview","rotateValue"+rotateValue+"|frameCount"+frameCount);
  60. if(frameCount++<2){//仅在第一次绘制时绘制背景
  61. /*
  62. *这里为什么设置成＜2，而不是1，是由于SurfaceView本身的双缓冲技术。
  63. 覆盖刷新其实就是将每次的新的图形绘制到上一帧去，
  64. 所以如果图像是半透明的，就要考虑重复叠加导致的问题了，
  65. 而如果是完全不透明的图形则不会有任何问题。
  66. 背景会在背景图和黑色背景之间来回闪。
  67. 这个问题其实是源于SurfaceView的双缓冲机制，我理解就是它会缓冲
  68. 前两帧的图像交替传递给后面的帧用作覆盖，这样由于我们仅在第一帧
  69. 绘制了背景，第二帧就是无背景状态了，且通过双缓冲机制一直保持下
  70. 来，解决办法就是改为在前两帧都进行背景绘制。
  71. */
  72. canvas.drawBitmap(backgroundBitmap,0,0,paint);//绘制背景
  73. }
  74. //创建矩阵以控制图片的旋转和平移
  75. Matrixmatrix=newMatrix();
  76. rotateValue+=40;
  77. matrix.setRotate(rotateValue,rotateBitmap.getWidth()/2,rotateBitmap.getHeight()/2);
  78. //matrix.postRotate(rotateValue,rotateBitmap.getWidth()/2,rotateBitmap.getHeight()/2);
  79. //matrix.setTranslate(100,rotateValue);
  80. if(rotateValue==360){
  81. rotateValue=0;
  82. }
  83. matrix.setTranslate(80,50);//设置左边距和上边距
  84. //绘制问号
  85. Log.d("surfaceview","canvas"+canvas);
  86. Log.d("surfaceview","rotateBitmap"+rotateBitmap);
  87. Log.d("surfaceview","matrix"+matrix);
  88. Log.d("surfaceview","paint"+paint);
  89. if(canvas!=null){
  90. canvas.drawBitmap(rotateBitmap,matrix,paint);
  91. //解锁画布，提交画好的图像
  92. surfaceHolder.unlockCanvasAndPost(canvas);
  93. }
  94. Thread.sleep(30);
  95. }catch(InterruptedExceptione){
  96. Thread.currentThread().interrupt();
  97. Log.d("surfaceview","InterruptedException");
  98. }finally{
  99. Log.d("surfaceview","finally");
  100. }
  101. }
  102. }
  104. }

分享到：
| Android 自己画View设置画笔的颜色
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Android高级编程--源代码

    在每章的讲解中，它会让你通过一系列示例项目逐步掌握Android中的各种新功能和技术，助你取得最圆满的学习效果。本书所介绍的各个应用实例简明扼要且极具实用价值，它们覆盖了Android 1．0的所有基本功能和高级功能...

    Android Canvas绘图Demo

    Android Canvas绘图演示代码

    Android绘图板源代码

    Android2.2以上，只在480*848的屏幕上测试过，其他屏幕的不保证。实现的功能包括： 绘制效果 1.水彩笔：50种颜色选择 2.蜡笔：68种颜色选择 3.颜料笔：52种颜色选择 绘制图形 1.可绘制11种图形（实心或空心） 2.提供...

    Android中Canvas绘图基础详解

    该代码是一个完整的Android工程，详细演示如了如何使用Android中的各种drawXXX方法，以及画笔Paint如何影响绘制的效果。 具体参见博文： http://blog.csdn.net/iispring/article/details/49770651

    AndroidStudio蓝牙接收数据绘图

    修改大佬的代码用于AndroidStudio，可以连接蓝牙和接收温度数据并绘制温度曲线

    android简单的画图板实现代码

    这是一款android的画图板实现代码，基本功能齐全，适合初学者开发的例子程序。

    Android 2D绘图小例子

    主要介绍了Android 2D绘图相关API使用。

    Android实例代码

    7.2、绘图：Canvas; Paint; Path; 7.3、图形特效处理：使用Matrix控制变换; 使用drawBitmapMesh扭曲图像; 使用Shader填充图形; 7.4、逐帧(Frame)动画：AnimationDrawable; 7.5、补间(Tween)动画：Interpolator; ...

    Android群英传(套装共2册)pdf及配套源代码

    《Android群英传》共分为13章，讲解了Android体系与系统架构、Android开发工具新接触、Android控件架构与自定义控件详解、ListView使用技巧、Android Scroll分析、Android绘图机制与处理技巧、Android动画机制与使用...

    android多媒体学习代码

    学习android多媒体的开发案例代码，包括绘图，动画，视频，照相机

    Android 画图代码和文档

    关于AChartEngine AChartEngine是为android应用而设计的绘图工具库。目前该库的最新稳定版本是0.7，支持绘制以下类型的图表:

    android绘图程序源代码

    代码片段：   public DrawView(Context context) { super(context); mPaints = new Paint[4]; mUseCenters = new boolean[4]; mOvals = new RectF[4]; mPaints[0] = new Paint(); mPaints[0]....

    安卓android画图程序源代码

    android画图程序源代码介绍:这是一个自动画图的程序，会自动改变图形的颜色，效果如下图所示：

    Android Surface画图游戏 示例代码

    完整工程 Android使用Surface绘图的小游戏，非常具有参考意义

    android-drawing-app, 来自 Tuts SDK的源代码.zip

    android-drawing-app, 来自 Tuts SDK的源代码 这个包含了以下 Tuts Android教程系列的演示代码。 Android SDK: 创建绘图应用程序http://code.tutsplus.com/tutorials/android-sdk-create-a-drawing

    Android安卓应用源码-涂鸦绘图&图片处理类源代码（8例）.zip

    Android安卓应用源码-涂鸦绘图&图片处理类源代码（8例），可供学习及设计参考。

    Android应用源码基于android系统的画图板.zip

    Android应用源码基于android系统的画图板是一款基于android系统的画图板，主要功能是实现线条颜色...代码量相对较少感兴趣的可以看看，可以直接运用到自己的代码中。代码有清晰的注释可以方便阅读。（源码采用GBK编码）

    Android炫酷带动画效果的饼图统计绘图源代码

    本项目是一个带动画的饼图。项目代码注释比较详细,但是用的是property animation 动画效果，源码和相关包均一起打包上传了，希望能够帮到你们。

    Android经典代码例子

    Android经典代码例子，下载，视频，绘图，网络连接，图标，显示图片，listview，菜单，事件，消息，进程，解析xml，上传，短信，触摸，主题等

Magicbox
Global site tag (gtag.js) - Google Analytics