Android 画图板实例

package com.lee.demo.view; import java.util.ArrayList; import android.content.Context; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Paint; import android.graphics.Rect; import android.graphics.RectF; import android.util.AttributeSet; import android.view.MotionEvent; import android.view.View; import com.lee.demo.interfaces.ISketchPadCallback; import com.lee.demo.interfaces.ISketchPadTool; import com.lee.demo.interfaces.IUndoCommand; import com.lee.demo.utils.BitmapUtil; import com.lee.demo.utils.CommonDef; import com.lee.demo.utils.SketchPadEraser; import com.lee.demo.utils.SketchPadPen; /** * The SketchPadView class provides method to draw strokes on it like as a canvas or sketch pad. * We use touch event to draw strokes, when user touch down and touch move, we will remember these * point of touch move and set them to a Path object, then draw the Path object, so that user can see the * strokes are drawing real time. When touch up event is occurring, we draw the path to a bitmap which * is hold by a canvas, and then draw the bitmap to canvas to display these strokes to user. * * @author Li Hong * * @date 2010/07/30 * */ public class SketchPadView extends View implements IUndoCommand { public static final int STROKE_NONE = 0; public static final int STROKE_PEN = 1; public static final int STROKE_ERASER = 2; public static final int UNDO_SIZE = 20; private boolean m_isEnableDraw = true; private boolean m_isDirty = false; private boolean m_isTouchUp = false; private boolean m_isSetForeBmp = false; private int m_bkColor = Color.WHITE; private int m_strokeType = STROKE_PEN; private int m_strokeColor = Color.BLACK; private int m_penSize = CommonDef.MIDDLE_PEN_WIDTH; private int m_eraserSize = CommonDef.MIDDLE_ERASER_WIDTH; private int m_canvasWidth = 100; private int m_canvasHeight = 100; private boolean m_canClear = true; private Paint m_bitmapPaint = null; private Bitmap m_foreBitmap = null; private SketchPadUndoStack m_undoStack = null; private Bitmap m_tempForeBitmap = null; private Bitmap m_bkBitmap = null; private Canvas m_canvas = null; private ISketchPadTool m_curTool = null; private ISketchPadCallback m_callback = null; public SketchPadView(Context context) { this(context, null); } public SketchPadView(Context context, AttributeSet attrs) { super(context, attrs); initialize(); } public SketchPadView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); initialize(); } public boolean isDirty() { return m_isDirty; } public void setDrawStrokeEnable(boolean isEnable) { m_isEnableDraw = isEnable; } public void setBkColor(int color) { if (m_bkColor != color) { m_bkColor = color; invalidate(); } } public void setForeBitmap(Bitmap foreBitmap) { if (foreBitmap != m_foreBitmap && null != foreBitmap) { // Recycle the bitmap. if (null != m_foreBitmap) { m_foreBitmap.recycle(); } m_isSetForeBmp = true; // Remember the temporary fore bitmap. m_tempForeBitmap = BitmapUtil.duplicateBitmap(foreBitmap); // Here create a new fore bitmap to avoid crashing when set bitmap to canvas. m_foreBitmap = BitmapUtil.duplicateBitmap(foreBitmap); if (null != m_foreBitmap && null != m_canvas) { m_canvas.setBitmap(m_foreBitmap); } m_canClear = true; invalidate(); } } public Bitmap getForeBitmap() { return m_foreBitmap; } public void setBkBitmap(Bitmap bmp) { if (m_bkBitmap != bmp) { m_bkBitmap = bmp; invalidate(); } } public Bitmap getBkBitmap() { return m_bkBitmap; } public void setStrokeType(int type) { switch(type) { case STROKE_PEN: m_curTool = new SketchPadPen(m_penSize, m_strokeColor); break; case STROKE_ERASER: m_curTool = new SketchPadEraser(m_eraserSize); break; } m_strokeType = type; } public void setStrokeSize(int size, int type) { switch(type) { case STROKE_PEN: m_penSize = size; break; case STROKE_ERASER: m_eraserSize = size; break; } } public void setStrokeColor(int color) { m_strokeColor = color; } public int getStrokeSize() { return m_penSize; } public int getStrokeColor() { return m_strokeColor; } public void clearAllStrokes() { if (m_canClear) { // Clear the undo stack. m_undoStack.clearAll(); // Recycle the temporary fore bitmap if (null != m_tempForeBitmap) { m_tempForeBitmap.recycle(); m_tempForeBitmap = null; } // Create a new fore bitmap and set to canvas. createStrokeBitmap(m_canvasWidth, m_canvasHeight); invalidate(); m_isDirty = true; m_canClear = false; } } public Bitmap getCanvasSnapshot() { setDrawingCacheEnabled(true); buildDrawingCache(true); Bitmap bmp = getDrawingCache(true); if (null == bmp) { android.util.Log.d("leehong2", "getCanvasSnapshot getDrawingCache == null"); } return BitmapUtil.duplicateBitmap(bmp); } public void setCallback(ISketchPadCallback callback) { m_callback = callback; } public ISketchPadCallback getCallback() { return m_callback; } @Override public void onDeleteFromRedoStack() { // Do nothing currently. } @Override public void onDeleteFromUndoStack() { // Do nothing currently. } @Override public void redo() { if (null != m_undoStack) { m_undoStack.redo(); } } @Override public void undo() { if (null != m_undoStack) { m_undoStack.undo(); } } @Override public boolean canUndo() { if (null != m_undoStack) { return m_undoStack.canUndo(); } return false; } @Override public boolean canRedo() { if (null != m_undoStack) { return m_undoStack.canRedo(); } return false; } @Override public boolean onTouchEvent(MotionEvent event) { if (null != m_callback) { int action = event.getAction(); if (MotionEvent.ACTION_DOWN == action) { m_callback.onTouchDown(this, event); } else if (MotionEvent.ACTION_UP == action) { m_callback.onTouchUp(this, event); } } if (m_isEnableDraw) { m_isTouchUp = false; switch(event.getAction()) { case Motio