Java Android绘图、擦除和撤消操作

这是用于绘制和撤消的代码，但无法与擦除合并

它可以是“绘图+擦除”或“绘图+撤消”，但不能是其中三种

public class Drawing extends View {
private Paint mPaint, mBitmapPaint;
private Bitmap mBitmap;
private Canvas mCanvas;
private Path mPath;

private float mX, mY;
private static final float TOUCH_TOLERANCE = 4;

private int color, size, state;

private ArrayList<Path> paths = new ArrayList<Path>();
private ArrayList<Path> undonePaths = new ArrayList<Path>();
private ArrayList<Integer> colors = new ArrayList<Integer>();
private ArrayList<Integer> sizes = new ArrayList<Integer>();

public Drawing(Context c) {
    super(c);
}

public Drawing(Context c,int width, int height, int size, int color, int state) {
    super(c);

    mBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
    mCanvas = new Canvas(mBitmap);
    mPath = new Path();

    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setDither(true);
    mPaint.setStyle(Paint.Style.STROKE);
    mPaint.setStrokeJoin(Paint.Join.ROUND);
    mPaint.setStrokeCap(Paint.Cap.ROUND);

//      mBitmapPaint = new Paint(Paint.DITHER_FLAG);
//      mBitmapPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));

    setColor(color);
    setSize(size);
    setState(state);
}

@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    super.onSizeChanged(w, h, oldw, oldh);
}

@Override
protected void onDraw(Canvas canvas) {
//      canvas.drawColor(Color.TRANSPARENT);
//      canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);
//
//      if (state == 0)
//          mBitmap.eraseColor(Color.TRANSPARENT);

    for (int i = 0; i < paths.size(); i++) {
        mPaint.setColor(colors.get(i));
        mPaint.setStrokeWidth(sizes.get(i));
        canvas.drawPath(paths.get(i), mPaint);
    }
    mPaint.setColor(color);
    mPaint.setStrokeWidth(size);
    canvas.drawPath(mPath, mPaint);

}

public void setColor(int color) {
    this.color = color;
}

public void setSize(int size) {
    this.size = size;
}

public void setState(int state) {
    this.state = state;
    // if (state == 0)
    // mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
    // else
    // mPaint.setXfermode(null);
}

public void onClickUndo() {
    if (paths.size() > 0) {
        undonePaths.add(paths.remove(paths.size() - 1));
        sizes.remove(sizes.size() - 1);
        colors.remove(colors.size() - 1);
        invalidate();
    }
}

private void touch_start(float x, float y) {
    undonePaths.clear();
    mPath.reset();
    mPath.moveTo(x, y);
    mX = x;
    mY = y;
}

private void touch_move(float x, float y) {
    float dx = Math.abs(x - mX);
    float dy = Math.abs(y - mY);
    if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) {
        mPath.quadTo(mX, mY, (x + mX) / 2, (y + mY) / 2);
        mX = x;
        mY = y;
    }
}

private void touch_up() {
    mPath.lineTo(mX, mY);
    mCanvas.drawPath(mPath, mPaint);

    colors.add(color);
    sizes.add(size);
    paths.add(mPath);
    mPath = new Path();
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    float x = event.getX();
    float y = event.getY();

    switch (event.getAction()) {
    case MotionEvent.ACTION_DOWN:
        touch_start(x, y);
        invalidate();
        break;
    case MotionEvent.ACTION_MOVE:
        touch_move(x, y);
        invalidate();
        break;
    case MotionEvent.ACTION_UP:
        touch_up();
        invalidate();
        break;
    }
    return true;
}
}

公共类图形扩展视图{
私人油漆mPaint、mBitmapPaint；
私有位图mBitmap；
私人帆布mCanvas；
专用路径mPath；
私人浮动mX，我的；
专用静态最终浮动接触公差=4；
私有int颜色、大小、状态；
私有ArrayList路径=新ArrayList（）；
private ArrayList undonePaths=new ArrayList（）；
private ArrayList colors=new ArrayList（）；
私有ArrayList大小=新ArrayList（）；
公共绘图（上下文c）{
超级（c）；
}
公共图形（上下文c、整数宽度、整数高度、整数大小、整数颜色、整数状态）{
超级（c）；
mBitmap=Bitmap.createBitmap（宽度、高度、Bitmap.Config.ARGB_8888）；
mCanvas=新画布（mBitmap）；
mPath=新路径（）；
mPaint=新油漆（）；
mPaint.setAntiAlias（true）；
mPaint.setDither（true）；
mPaint.setStyle（油漆、样式、笔划）；
mPaint.setStrokeJoin（油漆.连接.圆形）；
mPaint.setStrokeCap（油漆盖圆形）；
//mBitmapPaint=新油漆（油漆抖动标志）；
//mBitmapPaint.setXfermode（新的PorterDuffXfermode（PorterDuff.Mode.SRC））；
设置颜色（颜色）；
设置大小（大小）；
设置状态（状态）；
}
@凌驾
已更改尺寸的受保护空心（整数w、整数h、整数oldw、整数oldh）{
super.onSizeChanged（w，h，oldw，oldh）；
}
@凌驾
受保护的void onDraw（画布）{
//画布。drawColor（颜色。透明）；
//drawBitmap（mBitmap，0，0，mbitMapPoint）；
//
//如果（状态==0）
//mBitmap.橡皮擦颜色（颜色.透明）；
对于（int i=0；i0）{
undonePaths.add（path.remove（path.size（）-1））；
删除（size.size（）-1）；
colors.remove（colors.size（）-1）；
使无效（）；
}
}
专用无效触摸启动（浮动x、浮动y）{
撤销海王星。清除（）；
mPath.reset（）；
移动到（x，y）的速度；
mX=x；
mY=y；
}
私有无效触摸移动（浮动x、浮动y）{
float dx=Math.abs（x-mX）；
float dy=Math.abs（y-mY）；
如果（dx>=接触公差| | dy>=接触公差）{
兆帕四分之一秒（mX，mY，（x+mX）/2，（y+mY）/2）；
mX=x；
mY=y；
}
}
私人空间修补（）{
mPath.lineTo（mX，mY）；
mCanvas.drawPath（mPath，mPaint）；
颜色。添加（颜色）；
尺寸。添加（尺寸）；
路径。添加（mPath）；
mPath=新路径（）；
}
@凌驾
公共布尔onTouchEvent（运动事件）{
float x=event.getX（）；
float y=event.getY（）；
开关（event.getAction（））{
case MotionEvent.ACTION\u DOWN：
触摸启动（x，y）；
使无效（）；
打破
case MotionEvent.ACTION\u移动：
触摸移动（x，y）；
使无效（）；
打破
case MotionEvent.ACTION\u UP：
润色；
使无效（）；
打破
}
返回true；
}
}

---

我尝试将颜色设置为透明，但没有意义，因为没有更改像素，而是创建新路径。

以下内容可用于绘制擦除、浮雕、保存到图库、模糊。您可以使用该代码添加撤消和重做功能。下面的代码工作正常。您可以在Graphics文件夹的api演示下，从adk的samples文件夹中slo检查FingerPaint.java

。此链接将帮助您通过喷洒点来创建喷洒效果

public class FingerPaintActivity extends GraphicsActivity
    implements ColorPickerDialog.OnColorChangedListener {

    private Paint       mPaint;
    private MaskFilter  mEmboss;
    private MaskFilter  mBlur;
    Button b;
    Dialog dialog;
    static MyView mv;
    File f;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    LinearLayout ll = (LinearLayout) findViewById(R.id.ll);
    mv= new MyView(this);
    mv.setDrawingCacheEnabled(true);
    ll.addView(mv);
    b= (Button) findViewById(R.id.button1);
    b.setOnClickListener(new OnClickListener()
    {

        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
            final CharSequence[] items = {"Pick Color", "Emboss", "Blur","Erase","SaveToGallery"};

            AlertDialog.Builder builder = new AlertDialog.Builder(FingerPaintActivity.this);
            builder.setTitle("Options");
            builder.setItems(items, new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int item) {

                       if(item==0)
                       {
                           new ColorPickerDialog(FingerPaintActivity.this, FingerPaintActivity.this, mPaint.getColor()).show();
                       }
                       if(item==1)
                       {
                           if (mPaint.getMaskFilter() != mEmboss) {
                                mPaint.setMaskFilter(mEmboss);
                            } else {
                                mPaint.setMaskFilter(null);
                            }

                       }
                       if(item==2)
                       {
                           if (mPaint.getMaskFilter() != mBlur) {
                                mPaint.setMaskFilter(mBlur);
                            } else {
                                mPaint.setMaskFilter(null);
                            }
                       }
                       if(item==3)
                       {
                           mPaint.setXfermode(new PorterDuffXfermode(
                                   PorterDuff.Mode.CLEAR));
                       }
                       if(item==4)
                       {

                          saveImage();
                       }
                   }
               });


            builder.show();
        }


    });
    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setDither(true);
    mPaint.setColor(0xFFFF0000);
    mPaint.setStyle(Paint.Style.STROKE);
    mPaint.setStrokeJoin(Paint.Join.ROUND);
    mPaint.setStrokeCap(Paint.Cap.ROUND);
    mPaint.setStrokeWidth(20);

    mEmboss = new EmbossMaskFilter(new float[] { 1, 1, 1 },
                                   0.4f, 6, 3.5f);

    mBlur = new BlurMaskFilter(8, BlurMaskFilter.Blur.NORMAL);
}


public void colorChanged(int color) {
    mPaint.setColor(color);
}


public class MyView extends View {

    private static final float MINP = 0.25f;
    private static final float MAXP = 0.75f;

    private Bitmap  mBitmap;
    private Canvas  mCanvas;
    private Path    mPath;
    private Paint   mBitmapPaint;
    Context mcontext;

    public MyView(Context c) {
        super(c);
        mcontext=c;
        mPath = new Path();
        mBitmapPaint = new Paint();
        mBitmapPaint.setColor(Color.RED);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        mBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
        mCanvas = new Canvas(mBitmap);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        canvas.drawColor(0xFFAAAAAA);
        Display display = ( (Activity) mcontext).getWindowManager().getDefaultDisplay();  
        float w = display.getWidth(); 
        float h = display.getHeight();
        canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);
        canvas.drawLine(0, 0, w, 0,mBitmapPaint);
        canvas.drawLine(0, 0, 0, h,mBitmapPaint);
        canvas.drawLine(w,h,w,0,mBitmapPaint);
        canvas.drawLine(w, h, 0,h , mBitmapPaint);
        canvas.drawPath(mPath, mPaint);
    }

    private float mX, mY;
    private static final float TOUCH_TOLERANCE = 4;

    private void touch_start(float x, float y) {
        mPath.reset();
        mPath.moveTo(x, y);
        mX = x;
        mY = y;
    }
    private void touch_move(float x, float y) {
        float dx = Math.abs(x - mX);
        float dy = Math.abs(y - mY);
        if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) {
            mPath.quadTo(mX, mY, (x + mX)/2, (y + mY)/2);
            mX = x;
            mY = y;
        }
    }
    private void touch_up() {
        mPath.lineTo(mX, mY);
        // commit the path to our offscreen
        mCanvas.drawPath(mPath, mPaint);
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SCREEN));
        // kill this so we don't double draw
        mPath.reset();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        float x = event.getX();
        float y = event.getY();

        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                touch_start(x, y);
                invalidate();
                break;
            case MotionEvent.ACTION_MOVE:
                touch_move(x, y);
                invalidate();
                break;
            case MotionEvent.ACTION_UP:
                touch_up();
                invalidate();
                break;
        }
        return true;
    }
}
    public void saveImage()
    {
    AlertDialog.Builder editalert = new AlertDialog.Builder(FingerPaintActivity.this);
    editalert.setTitle("Please Enter the name with which you want to Save");
    final EditText input = new EditText(FingerPaintActivity.this);
    LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
            LinearLayout.LayoutParams.FILL_PARENT,
            LinearLayout.LayoutParams.FILL_PARENT);
    input.setLayoutParams(lp);
    editalert.setView(input);
    editalert.setPositiveButton("OK", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int whichButton) {
        mv.setDrawingCacheEnabled(true);
        String name= input.getText().toString();
        Bitmap bitmap = mv.getDrawingCache();
     String root = Environment.getExternalStorageDirectory().toString();
        File myDir = new File(root + "/MapleBearDraw");    
        myDir.mkdirs();
        File file = new File (myDir, name+".jpg");
        if (file.exists ()) file.delete ();         
        try 
        {
            if(!file.exists())
        {
            file.createNewFile();
        }
            FileOutputStream ostream = new FileOutputStream(file);
            bitmap.compress(CompressFormat.JPEG, 50, ostream);
            ostream.flush();
            ostream.close();  
            mv.invalidate();                            
        } 
        catch (Exception e) 
        {
            e.printStackTrace();
        }finally
        {

            mv.setDrawingCacheEnabled(false);                           
        }
        }
    });

    editalert.show();   
 }
private static final int COLOR_MENU_ID = Menu.FIRST;
private static final int EMBOSS_MENU_ID = Menu.FIRST + 1;
private static final int BLUR_MENU_ID = Menu.FIRST + 2;
private static final int ERASE_MENU_ID = Menu.FIRST + 3;
private static final int SRCATOP_MENU_ID = Menu.FIRST + 4;


public boolean onCreateOptionsMenu(Menu menu) {
    super.onCreateOptionsMenu(menu);

    menu.add(0, COLOR_MENU_ID, 0, "Color").setShortcut('3', 'c');
    menu.add(0, EMBOSS_MENU_ID, 0, "Emboss").setShortcut('4', 's');
    menu.add(0, BLUR_MENU_ID, 0, "Blur").setShortcut('5', 'z');
    menu.add(0, ERASE_MENU_ID, 0, "Erase").setShortcut('5', 'z');
    menu.add(0, SRCATOP_MENU_ID, 0, "SrcATop").setShortcut('5', 'z');

    /****   Is this the mechanism to extend with filter effects?
    Intent intent = new Intent(null, getIntent().getData());
    intent.addCategory(Intent.CATEGORY_ALTERNATIVE);
    menu.addIntentOptions(
                          Menu.ALTERNATIVE, 0,
                          new ComponentName(this, NotesList.class),
                          null, intent, 0, null);
    *****/
    return true;
}

@Override
public boolean onPrepareOptionsMenu(Menu menu) {
    super.onPrepareOptionsMenu(menu);
    return true;
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    mPaint.setXfermode(null);
    mPaint.setAlpha(0xFF);

    switch (item.getItemId()) {
        case COLOR_MENU_ID:
            new ColorPickerDialog(FingerPaintActivity.this, this, mPaint.getColor()).show();
            return true;
        case EMBOSS_MENU_ID:
            if (mPaint.getMaskFilter() != mEmboss) {
                mPaint.setMaskFilter(mEmboss);
            } else {
                mPaint.setMaskFilter(null);
            }
            return true;
        case BLUR_MENU_ID:
            if (mPaint.getMaskFilter() != mBlur) {
                mPaint.setMaskFilter(mBlur);
            } else {
                mPaint.setMaskFilter(null);
            }
            return true;
        case ERASE_MENU_ID:
            mPaint.setXfermode(new PorterDuffXfermode(
                                                    PorterDuff.Mode.CLEAR));
            return true;
        case SRCATOP_MENU_ID:
            mPaint.setXfermode(new PorterDuffXfermode(
                                                PorterDuff.Mode.SRC_ATOP));
            mPaint.setAlpha(0x80);
            return true;
    }
    return super.onOptionsItemSelected(item);
}

}

---

请参阅此选项可能有用不确定且此选项不适用，无法使用橡皮擦颜色，因为我的选项是“擦除所需内容”，而不是整个bitmapI更新了我的代码，如果我命令输出drawitmap，则“撤消”可以正常工作，但“取消命令”将不起作用。我看到您的代码与我的代码几乎相似。如果我使用mBitmapPaint绘制位图，则撤消无法工作。我想要的是在位图上绘制路径，这样我就可以动态地更改路径像素。我认为这更清晰，我在橡皮擦上得到了画笔大小，所以用户可以选择大小，我只是通过添加

mPaint.setXfermode（新的PorterDuffXfermode（PorterDuff.Mode.CLEAR））它在整个路径中消失，而路径仍然保留在那里，当我切换回绘制时，路径将被重新绘制为mpaint.setXfermode（new PorterDuffXfermode（PorterDuff.Mode.CLEAR））；取消抽签。对于“撤消”，您需要记住绘制点（将其存储在arraylist中），每次删除1条路径并在画布上重新绘制。创建菜单选项并选择不同的选项。您可以更改画笔的大小。上面的代码有一个选项来选择颜色、擦除和绘制。将“撤消”功能添加到相同的文件夹中。