6 import java.io.OutputStream;

    13 import android.graphics.Bitmap;

    14 import android.graphics.Canvas;

    16 import android.graphics.Paint;

    17 import android.graphics.Path;

    18 import android.graphics.RectF;

    21 import android.util.AttributeSet;

   223  

   224     public static class SignatureWidget extends View

   225     {

   226         private static final float STROKE_WIDTH = 5f;

   227         private static final float HALF_STROKE_WIDTH = STROKE_WIDTH / 2;

   228         private Paint paint = new Paint();

   229         private Path path = new Path();

   230  

   231         private float lastTouchX;

   232         private float lastTouchY;

   233         private final RectF dirtyRect = new RectF();

   234  

   235         public SignatureWidget(Context context, AttributeSet attrs)

   236         {

   237             super(context, attrs);

   238             paint.setAntiAlias(true);

   239             paint.setColor(Color.BLACK);

   240             paint.setStyle(Paint.Style.STROKE);

   241             paint.setStrokeJoin(Paint.Join.ROUND);

   242             paint.setStrokeWidth(STROKE_WIDTH);

   243         }

   244  

   245         public void save(View parent, OutputStream os)

   246         {

   247             Log.v("log_tag", "Width: " + parent.getWidth());

   248             Log.v("log_tag", "Height: " + parent.getHeight());

   249             Bitmap bm =  Bitmap.createBitmap(parent.getWidth(), parent.getHeight(), Bitmap.Config.RGB_565);;

   250             Canvas canvas = new Canvas(bm);

   251             parent.draw(canvas);

   252             bm.compress(Bitmap.CompressFormat.PNG, 90, os);

   253         }

   254  

   255         public void clear()

   256         {

   257             path.reset();

   258             invalidate();

   259         }

   260  

   261         @Override

   262         protected void onDraw(Canvas canvas)

   263         {

   264             canvas.drawPath(path, paint);

   265         }

   266  

   267         @Override

   268         public boolean onTouchEvent(MotionEvent event)

   269         {

   270             float eventX = event.getX();

   271             float eventY = event.getY();

   272  

   273             switch (event.getAction())

   274             {

   275             case MotionEvent.ACTION_DOWN:

   276                 path.moveTo(eventX, eventY);

   277                 lastTouchX = eventX;

   278                 lastTouchY = eventY;

   279                 return true;

   280  

   281             case MotionEvent.ACTION_MOVE:

   282  

   283             case MotionEvent.ACTION_UP:

   284  

   285                 resetDirtyRect(eventX, eventY);

   286                 int historySize = event.getHistorySize();

   287                 for (int i = 0; i < historySize; i++)

   288                 {

   289                     float historicalX = event.getHistoricalX(i);

   290                     float historicalY = event.getHistoricalY(i);

   291                     expandDirtyRect(historicalX, historicalY);

   292                     path.lineTo(historicalX, historicalY);

   293                 }

   294                 path.lineTo(eventX, eventY);

   295                 break;

   296  

   297             default:

   298                 debug("Ignored touch event: " + event.toString());

   299                 return false;

   300             }

   301  

   302             invalidate((int) (dirtyRect.left - HALF_STROKE_WIDTH),

   303                     (int) (dirtyRect.top - HALF_STROKE_WIDTH),

   304                     (int) (dirtyRect.right + HALF_STROKE_WIDTH),

   305                     (int) (dirtyRect.bottom + HALF_STROKE_WIDTH));

   306  

   307             lastTouchX = eventX;

   308             lastTouchY = eventY;

   309  

   310             return true;

   311         }

   312  

   313         private void debug(String string){

   314         }

   315  

   316         private void expandDirtyRect(float historicalX, float historicalY)

   317         {

   318             if (historicalX < dirtyRect.left)

   319             {

   320                 dirtyRect.left = historicalX;

   321             }

   322             else if (historicalX > dirtyRect.right)

   323             {

   324                 dirtyRect.right = historicalX;

   325             }

   326  

   327             if (historicalY < dirtyRect.top)

   328             {

   329                 dirtyRect.top = historicalY;

   330             }

   331             else if (historicalY > dirtyRect.bottom)

   332             {

   333                 dirtyRect.bottom = historicalY;

   334             }

   335         }

   336  

   337         private void resetDirtyRect(float eventX, float eventY)

   338         {

   339             dirtyRect.left = Math.min(lastTouchX, eventX);

   340             dirtyRect.right = Math.max(lastTouchX, eventX);

   341             dirtyRect.top = Math.min(lastTouchY, eventY);

   342             dirtyRect.bottom = Math.max(lastTouchY, eventY);

   343         }

   344     }