Android 图形用户界面 之 绘图（一）

最新推荐文章于 2022-01-15 15:02:05 发布
最新推荐文章于 2022-01-15 15:02:05 发布
阅读量5.6k 收藏
点赞数
分类专栏： android

转载至：http://emmet1988.iteye.com/blog/1058517


BasicViewDraw.java

 

Java代码   收藏代码
  1. package com.view;  
  2.   
  3. import com.test.R;  
  4. import android.view.View;  
  5. import android.content.Context;  
  6. import android.graphics.Canvas;  
  7. import android.graphics.Color;  
  8. import android.graphics.Paint;  
  9. import android.graphics.RectF;  
  10. import android.graphics.Path;  
  11. import android.graphics.Shader;  
  12. import android.graphics.LinearGradient;  
  13.   
  14. /* 自定义继承View 的MyView*/  
  15. public class BasicViewDraw extends View {  
  16.     public BasicViewDraw(Context context) {  
  17.         super(context);  
  18.     }  
  19.   
  20.     /* 重写onDraw（） */  
  21.     @Override  
  22.     protected void onDraw(Canvas canvas) {  
  23.         super.onDraw(canvas);  
  24.         /* 设置背景为白色 */                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
  25.         canvas.drawColor(Color.WHITE);  
  26.         Paint paint = new Paint();  
  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.         RectF re = new RectF(10, 220, 70, 250);  
  43.         canvas.drawOval(re, paint);  
  44.         /* 画一个空心三角形 */  
  45.         Path path = new Path();  
  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.         Path path1 = new Path();  
  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);  
  59.   
  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.         RectF re2 = new RectF(90, 220, 150, 250);  
  72.         canvas.drawOval(re2, paint);  
  73.         /* 画一个实心三角形 */  
  74.         Path path2 = new Path();  
  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.         Path path3 = new Path();  
  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.         Shader mShader = new LinearGradient(0, 0, 100, 100, new int[] {  
  90.                 Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW }, null,  
  91.                 Shader.TileMode.REPEAT);  
  92.         paint.setShader(mShader);  
  93.   
  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.         RectF re3 = new RectF(170, 220, 230, 250);  
  102.         canvas.drawOval(re3, paint);  
  103.         /* 画一个渐变色三角形 */  
  104.         Path path4 = new Path();  
  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.         Path path5 = new Path();  
  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);  
  118.   
  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. class BasicView2Draw extends View{  
  2.           
  3.         Paint paint;  
  4.         Bitmap bitmap;  
  5.           
  6.         public BasicView2Draw(Context context) {  
  7.             super(context);  
  8.             paint = new Paint(Paint.ANTI_ALIAS_FLAG);  
  9.             bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.icon);  
  10.         }  
  11.           
  12.         private Bitmap createBitmap1(){  
  13.             Bitmap bitmap1 = Bitmap.createBitmap(100, 100, Config.ARGB_8888);  
  14.             Canvas canvas = new Canvas(bitmap1);  
  15.             canvas.drawColor(Color.BLUE);  
  16. //          canvas.drawARGB(0, 0, 0, 0);// 透明色  
  17.             canvas.drawBitmap(bitmap, 0, 0, paint);  
  18.             canvas.drawText("Hello Android", 25, 55, paint);  
  19.             return bitmap1;  
  20.         }  
  21.           
  22.         @Override  
  23.         protected void onDraw(Canvas canvas) {  
  24.             super.onDraw(canvas);  
  25.               
  26.             // 绘制位图  
  27.             // 1.绘制位图在（10，10）位置上  
  28.             canvas.drawBitmap(createBitmap1(), 10, 10, paint);  
  29.             // 2.   canvas.drawBitmap(Bitmap bitmap,Rect src,Rect dest,Paint paint);  
  30.             //      canvas.drawBitmap(Bitmap bitmap,Rect src,RectF dest,Paint paint);  
  31.             //  绘制位图到一个指定的矩形dest中，位图会自动进行平移和缩放等操作，如果src的参数不为null  
  32.             // 则会裁剪位图的部分区域来进行绘制  
  33.             Rect rect = new Rect(10, 10, 50, 60);  
  34.             RectF rectF1 = new RectF(180.0f, 20.0f, 240.0f, 80.0f);  
  35.             RectF rectF2 = new RectF(180.0f, 100.0f, 240.0f, 160.0f);  
  36.             canvas.drawBitmap(createBitmap1(), null, rectF1, paint);  
  37.             canvas.drawBitmap(createBitmap1(), rect, rectF2, paint);  
  38.               
  39.             // 点  
  40.             paint.setStyle(Paint.Style.FILL_AND_STROKE);  
  41.             paint.setStrokeWidth(5.0f);  
  42.             paint.setColor(Color.YELLOW);  
  43.             canvas.drawPoints(new float[]{120,120,140,140,160,160,180,180}, paint);  
  44.               
  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(new float[]{  40,40,140,40  ,50,50,90,90  }, paint);  
  52.               
  53.             // 矩形  
  54.             paint.setColor(Color.CYAN);  
  55.             canvas.drawRect(10, 150, 150, 250, paint);  
  56.             paint.setColor(Color.GRAY);  
  57.             canvas.drawRect(new Rect(10, 260, 150, 280), paint);  
  58.             paint.setColor(Color.DKGRAY);  
  59.             canvas.drawRect(new RectF(20.2f, 290.9f, 120.2f, 300.3f), paint);  
  60.               
  61.             // 绘制文本  
  62. //          paint.setTextSize(20);  
  63. //          paint.setColor(0x40ffffff);// 半透明白色  
  64. //          paint.setTextAlign(Paint.Align.RIGHT);// 对齐方向  
  65. //          canvas.drawText("Cool Android", 250, 180, paint);// 这里注意，坐标(180,180)是文本的左下点坐标  
  66.               
  67.             // 画布平移：  
  68.             // 平移的单位是像素，分别是在x,y轴上平移的像素点  
  69.             // 正数代表的正方向，x轴为平面的右侧，y轴为平面的下方，相应的，负数则向反方向平移  
  70. //          canvas.translate(30.0f, 30.0f);  
  71.               
  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(float sx, float sy, float px, float py){ 
  80.                     translate(px,py); 
  81.                     scale(sx,sy); 
  82.                     translate(-px,-py); 
  83.                 } 
  84.             */  
  85.               
  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(float degrees, float px, float py){ 
  95.                     translate(px,py); 
  96.                     rotate(degrees); 
  97.                     translate(-px,-py); 
  98.                 } 
  99.             */  
  100.               
  101.             // 画布倾斜  
  102.             // skew(float sx,float xy);将画布在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. package com.view;  
  2.   
  3. import android.content.Context;  
  4. import android.graphics.Canvas;  
  5. import android.graphics.Color;  
  6. import android.graphics.Paint;  
  7. import android.graphics.Path;  
  8. import android.graphics.Region;  
  9. import android.util.AttributeSet;  
  10. import android.view.View;  
  11.   
  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补集，就是全集的减去交集剩余部分显示 
  22.      
  23.  * @author emmet1988.iteye.com 
  24.  * 
  25.  */  
  26. public class ClipRectDraw extends View {  
  27.       
  28.     Context context;  
  29.     Paint paint;  
  30.     Path path;  
  31.       
  32.     public ClipRectDraw(Context context) {  
  33.         super(context);  
  34.         init();  
  35.     }  
  36.       
  37.     public ClipRectDraw(Context context, AttributeSet attrs) {  
  38.         super(context, attrs);  
  39.         init();  
  40.     }  
  41.       
  42.     public ClipRectDraw(Context context, AttributeSet attrs, int defStyle) {  
  43.         super(context, attrs, defStyle);  
  44.         init();  
  45.     }  
  46.       
  47.     private void init(){  
  48.         paint = new Paint();  
  49.         paint.setAntiAlias(true);  
  50.         paint.setStrokeWidth(5);  
  51.         paint.setTextSize(15);  
  52.         paint.setTextAlign(Paint.Align.RIGHT);  
  53.         path = new Path();  
  54.     }  
  55.       
  56.     @Override  
  57.     protected void onDraw(Canvas canvas) {  
  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.     }  
  103.       
  104.     private void drawScene(Canvas canvas){  
  105.         canvas.clipRect(0, 0, 100, 100);  
  106.         canvas.drawColor(Color.WHITE);  
  107.           
  108.         paint.setColor(Color.RED);  
  109.         canvas.drawLine(0, 0, 100, 100, paint);  
  110.           
  111.         paint.setColor(Color.GREEN);  
  112.         canvas.drawCircle(30, 70, 30, paint);  
  113.           
  114.         paint.setColor(Color.BLUE);  
  115.         canvas.drawText("ChenJianLi", 100, 30, paint);  
  116.     }  
  117.   
  118. }  

 

 

MatrixDraw.java

 

Java代码   收藏代码
  1. package com.view;  
  2.   
  3. import com.test.R;  
  4.   
  5. import android.content.Context;  
  6. import android.graphics.Bitmap;  
  7. import android.graphics.Canvas;  
  8. import android.graphics.Matrix;  
  9. import android.graphics.Paint;  
  10. import android.graphics.drawable.BitmapDrawable;  
  11. import android.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.      * @author emmet1988.iteye.com 
  21.      * 
  22.      */  
  23. public class MatrixDraw extends View implements Runnable{  
  24.   
  25.     Bitmap bitmap;  
  26.     Matrix matrix = new Matrix();  
  27.     Paint paint;  
  28.       
  29.     public MatrixDraw(Context context) {  
  30.         super(context);  
  31.         bitmap = ((BitmapDrawable)getResources().getDrawable(R.drawable.rotate_surfaceview)).getBitmap();  
  32.         paint = new Paint();  
  33.         paint.setAntiAlias(true);  
  34.         new Thread(this).start();  
  35.     }  
  36.       
  37.     float m;  
  38.     float n;  
  39.     @Override  
  40.     protected void onDraw(Canvas canvas) {  
  41.           
  42.         /* 
  43.         float cosValue = (float)Math.cos(-Math.PI/m); 
  44.         float sinValue = (float)Math.sin(-Math.PI/m); 
  45.          
  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)); 
  50.          
  51.         matrix.setValues(new float[]{ 
  52.                 cosValue,-sinValue,100, 
  53.                 sinValue,cosValue,100, 
  54.                 0, 0, 2 
  55.         });//举例，若缩放值为0.9，代表放大原图的十分之一 
  56. //          super.onDraw(canvas);//当然，如果界面上还有其他元素需要绘制，只需要将这句话写上就行了。  
  57.          
  58. //      Matrix matrix2 = new Matrix(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.     }  
  71.   
  72.     @Override  
  73.     public void run() {  
  74.         while(!Thread.currentThread().isInterrupted()){  
  75.             try {  
  76.                 Thread.sleep(100);  
  77.                 postInvalidate();  
  78.             } catch (InterruptedException e) {  
  79.                 Thread.currentThread().interrupt();  
  80.             }  
  81.         }  
  82.     }  
  83.   
  84.     /** 
  85.      *  以左上角为顶点，缩放一半，逆时针旋转30度， 
  86.      *  然后沿x轴和y轴分别平移50个像素， 
  87.      *  代码 里面写的是100，为什么是平移50呢， 
  88.      *  因为缩放了一半。  
  89.      *  大家可以自己设置一下Matrix的值，或者尝试一下两个 
  90.      *  Matrix相乘，得到的值设置进去， 
  91.      *  这样才能对Matrix更加熟练。 
  92.      */  
  93.       
  94. }  

 

 

Matrix2Draw.java

 

Java代码   收藏代码
  1. public class Matrix2Draw extends View {  
  2.           
  3.         private Bitmap mBitmap;  
  4.         private Matrix mMatrix = new Matrix();  
  5.           
  6.         public Matrix2Draw(Context context) {  
  7.             super(context);  
  8.             initialize();  
  9.         }  
  10.   
  11.         private void initialize() {  
  12.               
  13.             Bitmap bmp = ((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.         }  
  30.           
  31.         @Override protected void onDraw(Canvas canvas) {  
  32. //          super.onDraw(canvas);  //如果界面上还有其他元素需要绘制，只需要将这句话写上就行了。  
  33.             Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);  
  34.             canvas.drawBitmap(mBitmap, mMatrix, paint);  
  35.         }  
  36.     }  
  37.       
  38.     /** 
  39.         Matrix的操作: 
  40.       
  41.         总共分为translate（平移），rotate（旋转），scale（缩放）和skew（倾斜）四种，每一种变换在 
  42.  
  43.         Android的API里都提供了set, post和pre三种操作方式,除了translate，其他三种操作都可以指定中心点。  
  44.  
  45.         set是直接设置Matrix的值，每次set一次，整个Matrix的数组都会变掉。  
  46.  
  47.         post是后乘，当前的矩阵乘以参数给出的矩阵。可以连续多次使用post，来完成所需的整个变换。 
  48.  
  49.         pre是前乘，参数给出的矩阵乘以当前的矩阵。所以操作是在当前矩阵的最前面发生的。 
  50.          
  51.         旋转、缩放和倾斜都可以围绕一个中心点来进行，如果不指定，默认情况下，是围绕(0,0)点来进行。 
  52.      */  

 

SimpleDraw.java

 

Java代码   收藏代码
  1. package com.view;  
  2.   
  3. import android.content.Context;  
  4. import android.graphics.Canvas;  
  5. import android.graphics.Color;  
  6. import android.graphics.Paint;  
  7. import android.graphics.Rect;  
  8. import android.view.View;  
  9.   
  10. public class SimpleDraw extends View implements Runnable {  
  11.   
  12.     /* 
  13.      * 我们继续来介绍Android平台底层绘图类的相关内容，在Android UI开发专题(一) 
  14.      * 之界面设计中我们介绍了有关Android平台资源使用以及Bitmap相关类的操作 
  15.      * ，接下来将会以实例的方式给大家演示各种类的用处以及注意点。今天我们继续 
  16.      * 了解android.graphics包中比较重要的绘图类。 
  17.      *  
  18.      * 一、 android.graphics.Matrix有关图形的变换、缩放等相关操作常用的方法有: 
  19.      * Java代码： void reset() // 重置一个matrix对象。 
  20.      * void set(Matrix src) //复制一个源矩阵，和本类的构造方法 Matrix(Matrix src) 一样 
  21.      * boolean isIdentity() //返回这个矩阵是否定义(已经有意义) 
  22.      * void setRotate(float degrees) //指定一个角度以0,0为坐标进行旋转 
  23.      * void setRotate(float degrees, float px, float py) //指定一个角度以px,py为坐标进行旋转 
  24.      *  void setScale(float sx, float sy) // 缩放 
  25.      * void setScale(float sx, float sy, float px, float py) //以坐标px,py进行缩放 
  26.      * void setTranslate(float dx, float dy) //平移 
  27.      * void setSkew (float kx, float ky, float px, float py) //以坐标px,py进行倾斜 
  28.      * void setSkew (float kx, float ky) //倾斜 复制代码 二、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代码： void reset() //重置 
  43.      * void setARGB(int a, int r, int g, int b) 或 void setColor(int color) 
  44.      * //均为设置Paint对象的颜色 
  45.      * void setAntiAlias(boolean aa) 
  46.      *  
  47.      * //是否抗锯齿，需要配合void setFlags (Paint.ANTI_ALIAS_FLAG) 来帮助消除锯齿 
  48.      * 使其边缘更平滑。 
  49.      * Shader setShader(Shader shader) 
  50.      *  
  51.      * //设置阴影，Shader类是一个矩阵对象，如果为NULL将清除阴影。 
  52.      * void setStyle(Paint.Style style) //设置样式，一般为 FILL 填充，或者STROKE凹陷 
  53.      * 效果。 
  54.      * void setTextSize(float textSize) //设置字体大小 
  55.      * void setTextAlign(Paint.Align align) //文本对齐方式 
  56.      * Typeface setTypeface(Typeface typeface) 
  57.      * //设置字体，通过Typeface可以加载Android内部的字体，一般为宋体对于中文， 
  58.      * 部分ROM可以自己添加比如雅黑等等 
  59.      * void setUnderlineText(boolean underlineText) 
  60.      *  
  61.      * //是否设置下划线，需要撇和void setFlags (Paint.UNDERLINE_TEXT_FLAG) 方法。 复制代码 
  62.      * 四、android.graphics.Rect 
  63.      *  
  64.      * Rect我们可以理解为矩形区域，类似的还有Point一个点，Rect类除了表示一个矩 
  65.      * 形区域位置描述外， 
  66.      * eoeandroid提示主要可以帮助我们计算图形之间是否碰撞 
  67.      * (包含)关系，对于Android游戏开发比较有用，其主要的成员contains包含了三种 
  68.      * 重载方法，来判断包含关系. 
  69.      *  
  70.      * Java代码：  
  71.      * boolean contains(int left, int top, int right, int bottom) 
  72.      * boolean contains(int x, int y) 
  73.      *  
  74.      * boolean contains(Rect r) 复制代码 五、android.graphics.Region 
  75.      * Region在Android平台中表示一个区域和Rect不同的是 
  76.      * ，它表示的是一个不规则的样子，可以是椭圆、多边形等等，而Rect仅仅是矩形。 
  77.      * 同样Region的boolean contains(int x, 
  78.      * int y) 成员可以判断一个点是否在该区域内。 
  79.      *  
  80.      * 六、android.graphics.Typeface 
  81.      * Typeface类是帮助描述一个字体对象，在TextView中通过使用setTypeface方法来 
  82.      * 制定一个输出文本的字体 
  83.      * ，其直接构造调用成员create方法可以直接指定一个字体名称和样式，比如 
  84.      * Java代码： static Typeface create(Typeface family, int style) 
  85.      *  
  86.      * static Typeface create(String familyName, int style) 复制代码 
  87.      * 同时使用isBold和isItalic方法可以判断出是否包含粗体或斜体的字型。 
  88.      *  
  89.      * Java代码： final boolean isBold() 
  90.      * final boolean isItalic() 复制代码 该类的创建方法还有从apk的资源或从一个具体的 
  91.      * 文件路径，其具体方法为 
  92.      * Java代码： static Typeface createFromAsset(AssetManager mgr, String path) 
  93.      * static Typeface createFromFile(File path) 
  94.      * static Typeface createFromFile(String path) 复制代码 
  95.      */  
  96.   
  97.     private Paint paint;  
  98.   
  99.     public SimpleDraw(Context context) {  
  100.         super(context);  
  101.         paint = new Paint();  
  102.         new Thread(this).start();  
  103.     }  
  104.   
  105.     @Override  
  106.     protected void onDraw(Canvas canvas) {  
  107.         super.onDraw(canvas);  
  108.   
  109.         canvas.drawColor(Color.GRAY);//  
  110.         paint.setAntiAlias(true);//  
  111.   
  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(new Rect(50, 50, 70, 70), paint);  
  123.         canvas.restore();  
  124.   
  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(new Rect(10, 10, 50, 50), paint);  
  132.         canvas.restore();  
  133.         //  
  134.         canvas.save();  
  135.         canvas.translate(120, 120);  
  136.         canvas.clipRect(new Rect(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(new Rect(10, 10, 50, 50), paint);  
  150.         canvas.restore();  
  151.     }  
  152.   
  153.     float m = 0.0f;  
  154.   
  155.     public void run() {  
  156.         while (!Thread.currentThread().isInterrupted()) {  
  157.             try {  
  158.                 Thread.sleep(500);// 每半秒执行一次  
  159.             } catch (InterruptedException e) {  
  160.                 Thread.currentThread().interrupt();  
  161.             }  
  162.             postInvalidate();  
  163.         }  
  164.     }  
  165. }  

 

 

TextDraw.java

 

Java代码   收藏代码
  1. package com.view;  
  2.   
  3. import android.content.Context;  
  4. import android.graphics.Canvas;  
  5. import android.graphics.Color;  
  6. import android.graphics.Paint;  
  7. import android.graphics.Paint.FontMetrics;  
  8. import android.util.Log;  
  9. import android.view.View;  
  10.   
  11. public class TextDraw extends View {  
  12.   
  13.     public TextDraw(Context context) {  
  14.         super(context);  
  15.     }  
  16.   
  17.     @Override  
  18.     protected void onDraw(Canvas canvas) {  
  19.         super.onDraw(canvas);  
  20.         Paint textPaint = new Paint( Paint.ANTI_ALIAS_FLAG);  
  21.         textPaint.setTextSize( 35);  
  22.         textPaint.setColor( Color.WHITE);  
  23.   
  24.         // FontMetrics  
  25.         FontMetrics fontMetrics = textPaint.getFontMetrics();  
  26.   
  27.         String text = "abcdefghijklm";  
  28.   
  29.         //   
  30.         float baseX = 0;  
  31.         float baseY = 100;  
  32.         Log.d("textDraw", "top = "+fontMetrics.top+  
  33.                                         "ascent = "+fontMetrics.ascent+  
  34.                                         "descent = "+fontMetrics.descent+  
  35.                                         "bottom = "+fontMetrics.bottom+"\n");  
  36.         float topY = baseY + fontMetrics.top;  
  37.         float ascentY = baseY + fontMetrics.ascent;  
  38.         float descentY = baseY + fontMetrics.descent;  
  39.         float bottomY = 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);  
  46.   
  47.         // BaseLine  
  48.         Paint baseLinePaint = new Paint( Paint.ANTI_ALIAS_FLAG);  
  49.         baseLinePaint.setColor( Color.RED);  
  50.         canvas.drawLine(0, baseY, getWidth(), baseY, baseLinePaint);  
  51.   
  52.         // Base  
  53.         canvas.drawCircle( baseX, baseY, 5, baseLinePaint);  
  54.   
  55.         // TopLine  
  56.         Paint topLinePaint = new Paint( Paint.ANTI_ALIAS_FLAG);  
  57.         topLinePaint.setColor( Color.LTGRAY);  
  58.         canvas.drawLine(0, topY, getWidth(), topY, topLinePaint);  
  59.   
  60.         // AscentLine  
  61.         Paint ascentLinePaint = new Paint( Paint.ANTI_ALIAS_FLAG);  
  62.         ascentLinePaint.setColor( Color.GREEN);  
  63.         canvas.drawLine(0, ascentY, getWidth(), ascentY, ascentLinePaint);  
  64.   
  65.         // DescentLine  
  66.         Paint descentLinePaint = new Paint( Paint.ANTI_ALIAS_FLAG);  
  67.         descentLinePaint.setColor( Color.YELLOW);  
  68.         canvas.drawLine(0, descentY, getWidth(), descentY, descentLinePaint);  
  69.   
  70.         // ButtomLine  
  71.         Paint bottomLinePaint = new Paint( Paint.ANTI_ALIAS_FLAG);  
  72.         bottomLinePaint.setColor( Color.MAGENTA);  
  73.         canvas.drawLine(0, bottomY, getWidth(), bottomY, bottomLinePaint);  
  74.     }  
  75. }  

 

RoundAndReflectionDraw.java

 

Java代码   收藏代码
  1. class RoundImageView extends View {  
  2.   
  3.         private Bitmap bitmap;  
  4.         int bitmapWidth;  
  5.         int bitmapHeight;  
  6.   
  7.         public RoundImageView(Context context) {  
  8.             super(context);  
  9.             bitmap = BitmapFactory.decodeResource(getResources(),R.drawable.rotate_surfaceview);  
  10.             bitmapWidth = bitmap.getWidth();  
  11.             bitmapHeight = bitmap.getHeight();  
  12.         }  
  13.   
  14.         @Override  
  15.         protected void onDraw(Canvas canvas) {  
  16.             super.onDraw(canvas);  
  17.             // 第一种方法：  
  18.             /*Bitmap roundBitmap = Bitmap.createBitmap(bitmapWidth, bitmapHeight,Bitmap.Config.ARGB_8888); 
  19.             canvas = new Canvas(roundBitmap); 
  20.             Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG); 
  21.             paint.setColor(Color.BLUE); 
  22.             canvas.drawRoundRect(new RectF(0, 0, bitmapWidth, bitmapHeight),20.0f, 20.0f, paint); 
  23.             paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN)); 
  24.             canvas.drawBitmap(bitmap, 0, 0, null); 
  25.             canvas.drawBitmap(roundBitmap, 0, 0, paint);*/  
  26.             // 第二种方法：  
  27.             Paint paint = new Paint(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);  
  32.               
  33.             canvas.drawText("生成带倒影的图片", 170, 160, paint);  
  34.             canvas.drawBitmap(createReflectionImageWithOrigin(bitmap), 170, 165, paint);  
  35.               
  36.         }  
  37.           
  38.         public Bitmap getRoundedCornerBitmap(Bitmap bitmap) {   
  39.             // 创建一个指定宽度和高度的空位图对象  
  40.             Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),bitmap.getHeight(), Config.ARGB_8888);   
  41.             // 用该位图创建画布  
  42.             Canvas canvas = new Canvas(output);  
  43.             // 画笔对象  
  44.             final Paint paint = new Paint();   
  45.             // 画笔的颜色  
  46.             final int color = 0xff424242;   
  47.             // 矩形区域对象  
  48.             final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());   
  49.             // 未知  
  50.             final RectF rectF = new RectF(rect);   
  51.             // 拐角的半径  
  52.             final float roundPx = 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(new PorterDuffXfermode(Mode.SRC_IN));  
  63.             // 把该图片绘制在该圆角矩形区域中  
  64.             canvas.drawBitmap(bitmap, rect, rect, paint);  
  65.             // 最终在画布上呈现的就是该圆角矩形图片，然后我们返回该Bitmap对象  
  66.             return output;   
  67.         }  
  68.           
  69.         //获得带倒影的图片方法   
  70.         public Bitmap createReflectionImageWithOrigin(Bitmap bitmap){   
  71.             // 图片与倒影之间的距离间隔  
  72.             final int reflectionGap = 2;  
  73.             // 原图的宽度  
  74.             int width = bitmap.getWidth();   
  75.             // 原图的高度  
  76.             int height = bitmap.getHeight();   
  77.             // 图片旋转，缩放等控制对象  
  78.             Matrix matrix = new Matrix();   
  79.             // 缩放（这里pre,set,post三种效果是不一样的，注意区别）  
  80.             matrix.preScale(1, -1);   
  81.             /** 
  82.                 set是直接设置Matrix的值，每次set一次，整个Matrix的数组都会变掉。  
  83.                 post是后乘，当前的矩阵乘以参数给出的矩阵。可以连续多次使用post， 
  84.                 来完成所需的整个变换。例如，要将一个图片旋 
  85.                 转30度，然后平移到(100,100)的地方，那么可以这样做:  
  86.                 Matrix m = new Matrix(); 
  87.                 m.postRotate(30); 
  88.                 m.postTranslate(100, 100);   
  89.                 这样就达到了想要的效果。  
  90.                 pre是前乘，参数给出的矩阵乘以当前的矩阵。所以操作是在当前矩阵的最前面发生的。 
  91.                 例如上面的例子，如果用pre的话，就要这样: 
  92.                 Matrix m = new Matrix(); 
  93.                 m.setTranslate(100, 100); 
  94.                 m.preRotate(30); 
  95.                 旋转、缩放和倾斜都可以围绕一个中心点来进行，如果不指定，默认情况下， 
  96.                 是围绕(0,0)点来进行。  
  97.                  
  98.                 关于缩放： 
  99.                 scale的参数是比例。例如，我们缩放为100%，则有一点要注意，如果直接用 
  100.                 100/bmp.getWidth()的话，会得到0，因为是整型相除，所以必须其中有一个是 
  101.                 float型的，直接用100f就好 。 
  102.                 如：matrix.setScale(100f/bmp.getWidth(), 100f/bmp.getHeight());    
  103.              */  
  104.             // 创建一个初始的倒影位图  
  105.             Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, height/2, width, height/2, matrix, false);   
  106.             // 新建一个宽度为原图宽度，高度为原图高度的3/2的位图，用于绘制新的位图，即整体的效果图位图对象  
  107.             Bitmap bitmapWithReflection = Bitmap.createBitmap(width, (height + height/2), Config.ARGB_8888);   
  108.             // 由该位图对象创建初始画布(规定了画布的宽高)  
  109.             Canvas canvas = new Canvas(bitmapWithReflection);   
  110.             // 在该画布上绘制原图  
  111.             canvas.drawBitmap(bitmap, 0, 0, null);   
  112.             // 创建一个画笔  
  113.             Paint deafalutPaint = new Paint();   
  114.             // 绘制一个矩形区域，该矩形区域便是原图和倒影图之间的间隔图  
  115.             canvas.drawRect(0, height,width,height + reflectionGap,deafalutPaint);   
  116.             // 绘制该倒影图于间隔图的下方  
  117.             canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);   
  118.             // 创建一个画笔  
  119.             Paint paint = new Paint();  
  120.             // 创建一个线性渐变对象  
  121.             LinearGradient shader = new LinearGradient(  
  122.                                                             0, bitmap.getHeight(),   
  123.                                                             0, bitmapWithReflection.getHeight() + reflectionGap,   
  124.                                                             0x70ffffff, 0x00ffffff,   
  125.                                                             TileMode.CLAMP  
  126.                                                       );   
  127.             // 把渐变效果应用在画笔上  
  128.             paint.setShader(shader);   
  129.             // Set the Transfer mode to be porter duff and destination in   
  130.             // 未知  
  131.             paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));   
  132.             // Draw a rectangle using the paint with our linear gradient   
  133.             // 绘制出该渐变效果，也就是最终的倒影效果图  
  134.             canvas.drawRect(0, height, width, bitmapWithReflection.getHeight() + reflectionGap, paint);   
  135.             // 返回  
  136.             return bitmapWithReflection;   
  137.         }   
  138.   
  139.     }  
  140.   
  141.     /** 
  142.      * 绘制圆角背景以及图片圆角的处理 
  143.        .配置文件实现  
  144.        <?xml version="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.      * <?xml version="1.0" encoding="utf-8"?>  
  152.      * <shape 
  153.      *      xmlns:android="http://schemas.android.com/apk/res/android"> <solid 
  154.      *      android:color="#60000000"/>  
  155.      *      <stroke android:width="3dp" 
  156.      *          color="#ff000000"/>  
  157.      *      <corners android:radius="10dp" />  
  158.      * </shape> 
  159.      * 或者直接使用一种效果 
  160.      * <?xml version="1.0" encoding="UTF-8"?>  
  161.      * <shape 
  162.      *      xmlns:android="http://schemas.android.com/apk/res/android">  
  163.      *      <solid 
  164.      *              android:color="#99FFFFFF"/>  
  165.      *      <corners android: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.图片本身加上圆角 Bitmap myCoolBitmap = ... ; // <-- Your bitmap you want rounded  
  175.      *  
  176.      *      int w = myCoolBitmap.getWidth(), h = myCoolBitmap.getHeight(); 
  177.      *      Bitmap rounder = Bitmap.createBitmap(w,h,Bitmap.Config.ARGB_8888); Canvas 
  178.      *      canvas = new Canvas(rounder); 
  179.      *  
  180.      *      Paint xferPaint = new Paint(Paint.ANTI_ALIAS_FLAG); 
  181.      *      xferPaint.setColor(Color.RED); 
  182.      *  
  183.      *      canvas.drawRoundRect(new RectF(0,0,w,h), 20.0f, 20.0f, xferPaint); 
  184.      *  
  185.      *      xferPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN)); 
  186.      *      canvas.drawBitmap(myCoolBitmap, 0,0, null);  
  187.      *      canvas.drawBitmap(rounder, 0,0, xferPaint);  
  188.      * 或者  
  189.      * public static Bitmap getRoundedCornerBitmap(Bitmap bitmap) {  
  190.      *      Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), 
  191.      *      bitmap.getHeight(), Config.ARGB_8888);  
  192.      *      Canvas canvas = newCanvas(output); 
  193.      *  
  194.      *      final int color = 0xff424242; final Paint paint = new Paint(); final Rect 
  195.      *      rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight()); final RectF 
  196.      *      rectF = new RectF(rect); final float roundPx = 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(new PorterDuffXfermode(Mode.SRC_IN)); 
  202.      *      canvas.drawBitmap(bitmap, rect, rect, paint); 
  203.      *  
  204.      *      return output;  
  205.      * } 
  206.      */  

 

SurfaceViewDraw.java

 

Java代码   收藏代码
  1. package com.view;  
  2.   
  3. import com.test.R;  
  4.   
  5. import android.content.Context;  
  6. import android.graphics.Bitmap;  
  7. import android.graphics.BitmapFactory;  
  8. import android.graphics.Canvas;  
  9. import android.graphics.Matrix;  
  10. import android.graphics.Paint;  
  11. import android.graphics.Rect;  
  12. import android.util.Log;  
  13. import android.view.SurfaceHolder;  
  14. import android.view.SurfaceView;  
  15.     /** 
  16.      * http://wallage.blog.163.com/blog/static/173896242010101232220959/ 
  17.      * @author emmet1988.iteye.com 
  18.      * 
  19.      */  
  20. public class SurfaceViewDraw extends SurfaceView implements Runnable,SurfaceHolder.Callback {  
  21.       
  22.     private Bitmap backgroundBitmap;  
  23.     private Bitmap rotateBitmap;  
  24.     SurfaceHolder surfaceHolder;  
  25.       
  26.     public SurfaceViewDraw(Context context) {  
  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.     }  
  33.   
  34.     public void surfaceCreated(SurfaceHolder holder) {  
  35.         new Thread(this).start();  
  36.         Log.d("surfaceview", "surfaceCreated");  
  37.     }  
  38.   
  39.     public void surfaceChanged(SurfaceHolder holder, int format, int width,  
  40.             int height) {  
  41.         Log.d("surfaceview", "surfaceChanged");  
  42.     }  
  43.   
  44.     public void surfaceDestroyed(SurfaceHolder holder) {  
  45.         Log.d("surfaceview", "surfaceDestroyed");  
  46.     }  
  47.   
  48.     @Override  
  49.     public void run() {  
  50.         Log.d("surfaceview", "run");  
  51.         Canvas canvas = null;  
  52.         int rotateValue = 0;//旋转角度  
  53.         int frameCount = 0;//帧计数器  
  54.         while (!Thread.currentThread().isInterrupted()) {  
  55.             try {      
  56. //              canvas = surfaceHolder.lockCanvas();//获取画布对象(获取整个屏幕的画布)  
  57.                 canvas = surfaceHolder.lockCanvas(new Rect(10, 10, 240, 250));//获取某个区域的画布  
  58.                 Paint paint = new Paint();  
  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.                 Matrix matrix = new Matrix();  
  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 (InterruptedException e) {  
  96.                 Thread.currentThread().interrupt();  
  97.                 Log.d("surfaceview", "InterruptedException");  
  98.             } finally {  
  99.                 Log.d("surfaceview", "finally");  
  100.             }  
  101.         }  
  102.     }  
  103.   
  104. }  
lgb861127
关注
专栏目录
ZYNQMP_XAZU3EG_VxWorks7 添加EEPROM
u014689277的博客
07-20 329
修改设备树 xlnx-zcu102-rev-1.1.dts &i2c1 { status = "okay"; eeprom: eeprom@52 { compatible = "at24, at24c32"; reg = <0x52>; data-scl-frequency = <400000>; }; }; zynqmp-iomux.dtsi ...
android 图形开发实例
xiezhenxiang的专栏
03-09 2610
class BasicView2Draw extends View{ Paint paint; Bitmap bitmap; public BasicView2Draw(Context context) { super(context); paint = new Paint(Paint.ANTI_ALIAS_FLAG); bitmap =
android 关于屏幕截屏的几种办法
热门推荐
mmsx
02-02 1万+
年末较闲，就上个星期查找各方面的资料关于android截图事情，自已也测试一些代码，已改改进或者优化。接下来进行总结一下。其实，如果真正android系统截屏是需要root权限的。但要用户使用都root，似乎不可能，体验性太差了。这期间我稍微观察了QQ的截图。QQ的截图是摇一摇截图当前屏幕，这个是不需要root权限的。然而，如果你要截图页面不是当前页面，就需要root权限。可以使用360超级roo
android中图形图像处理之drawable用法分析
09-03
总之，Android中的Drawable提供了一种灵活的方式来处理和显示图形图像，结合`Resources`、`Paint`、`Typeface`和`Canvas`等类，开发者可以创建出丰富多样的用户界面。在实际开发中，熟练掌握这些工具能帮助你构建更...
Android编程开发之在Canvas中利用Path绘制基本图形(圆形,矩形,椭圆,三角形等)
09-02
在Android编程中，Canvas是用于在屏幕上绘制图形的重要类，而Path则是用来描述复杂路径的工具，能够绘制出各种形状，如圆形、矩形、椭圆以及不...熟练掌握这两者，将有助于提升Android应用的用户界面设计和用户体验。
Android绘图介绍-复杂图形描画
最新发布
05-02
在Android开发中，图形描画是一项重要的技能，它允许开发者创造出独特且丰富的用户界面，以及动态的动画效果。本文将深入探讨如何在Android平台上进行复杂图形的绘制，以实现自定义视图和交互式UI。 首先，我们从...
Android绘图介绍-基本图形描画
05-02
总结，Android绘图系统提供了丰富的API来创建和绘制基本图形，开发者可以根据需求自由组合使用，构建出独特且交互性强的用户界面。通过熟练掌握`Canvas`和`Paint`的使用，可以实现从简单的图标到复杂的动画效果，...
Android UI效果之绘图篇（一）
09-02
Android UI效果之绘图篇是Android开发者在设计用户界面时不可或缺的一部分，主要涵盖了XML绘图、Canvas绘图、动画详解以及自定义控件等多个方面。本文将重点介绍XML绘图中的Shape、Layer以及Selector，这些都是...
golang GUI图形界面框架fyne演示例子
08-24
然而，Go语言同样支持GUI（图形用户界面）开发，其中`fyne`框架就是一个优秀的例子。`fyne`为开发者提供了构建跨平台GUI应用的能力，它使用纯Go编写，支持Windows、macOS、Linux、iOS和Android等操作系统。 `fyne`...
Android开发 OpenGL ES绘制3D 图形实例详解
09-01
在Android开发中，使用OpenGL ES可以创建丰富的3D图形界面，为用户带来更生动的视觉体验。OpenGL ES 1.0是基于OpenGL 1.3规范，而1.1版则是基于1.5规范，提供了更多功能。 在Android中使用OpenGL ES进行3D图形绘制...
Android 图形解锁源码.rar
07-04
4. 用户界面交互：分析图形解锁界面的UI设计和动画效果，学习如何提升用户体验。 通过对这个源码的深入研究，你不仅可以掌握Android图形解锁的实现原理，还能提升你在Android应用开发中的安全意识和定制能力。同时...
Android图形系统分析-surfaceFlinger流程
03-10
在Android系统中，图形用户界面（GUI）的输出是通过图形设备接口（GDI）来实现的。GDI负责管理图形图像的输出，并处理显示缓冲区的操作和管理。GDI可以被视为管理物理屏幕使用的设备管理器，它负责将应用程序的输出...
Android 系列 6 图形用户界面 （GUI）
曹浩洋的专栏
01-11 4426
6 图形用户界面 （GUI） 当Android被发明时，它的设计师面临许多选择，其结果将决定他们的项目的成功或失败。一旦他们拒绝了所有其他智能手机操作系统，包括关闭和开源，并决定在Linux内核上构建自己的操作系统，他们面临着一些空白的画布。一个重要的选择是使用哪种编程语言;他们明智地选择了Java。但是一旦做出了选择，就可以选择部署用户界面技术：Java ME，Swing，SWT或上述任何一种
Android绘图(一)基础篇
mChenys的博客
01-15 8048
目录一、绘图入门二、绘制位图三、绘制点四、绘制直线五、绘制矩形六、绘制圆七、绘制路径7.1 往 Path 中添加线条7.2 往 Path 中添加矩形、椭圆、弧7.3 往 Path 中添加曲线和贝塞尔曲线7.4 将 Path 中的图形进行运算7.5 绘制文字7.5.1 在指定位置绘制文本八、Paint的FontMetrics使用8.1 行距8.2 计算fontPadding8.3文本在控件水平方向居中显示8.4 文本在控件垂直方向居中显示8.5 Paint的setTextAlign使用九、绘制验证码 一、绘图
Android实验——实验1 用户界面：线性布局
Yimi-依米 的博客
02-28 8726
实验1 用户界面：线性布局 一、实验目的 1、理解Android布局管理器及其属性，掌握线性布局用户界面（UI）的设计方法。 2、掌握在XML文件和Java代码中访问字符串、数组、颜色和尺寸等资源的方法。 3、掌握在Java代码中获取UI控件对象及事件处理的方法。 二、实验要求 设计并实现一个电子邮件APP的模拟程序，完成用户登录和发送邮件的功能，具体要求如下： 1. 定义字...
Android图片的交集或补集
qq_16421847的专栏
04-28 870
Android图片的交集或补集
Android用户界面开发入门指南
本书详细介绍了如何为Android应用程序设计和开发吸引人的用户界面，有助于提升开发者在Android UI方面的技能，同时也可增强英文阅读能力。" 在Android应用开发中，用户界面（UI）设计是至关重要的，因为它直接影响...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值