下文来自：

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. }

更多相关文章

  1. Android(安卓)Canvas学习笔记（1）
  2. Android(安卓)本地文件管理类
  3. Android将HTML文本显示在webView控件中
  4. 【Android】高德地图2DMap，隐藏“高德地图”logo样式（不同版本或有
  5. Android绘制波浪曲线，效果很赞的。
  6. android缩放大图片加载
  7. android浏览器和iPhone浏览器
  8. Android(安卓)Canvas类介绍和Android(安卓)Draw Rect 坐标图示
  9. Android中关于矩阵（Matrix）前乘后乘的一些认识

随机推荐

  1. android百问（更新中）
  2. Android特殊字体引入，以及描边和投影
  3. Android 编译环境配置搭建(Ubuntu 12.04)
  4. ShareSDK for Android(安卓)只有新浪微博
  5. 适用于Android的Google Fit：读取传感器数
  6. Android -Recovery
  7. Android SDK需要安装的包
  8. 【Flutter开发】------修改图标、应用名
  9. android笔试题
  10. Android核心模块内容概述