Impossible de changer de couleur dans le dessin Android

Question

J'ai différents ensembles de couleurs dans l'application de peinture. Je suis capable de dessiner des lignes sur la vue de la toile avec la couleur par défaut. Mais quand je change de couleur, il change de couleur pour toutes les lignes, y compris les anciennes lignes.

ci-dessous est le code.

public class DrawingArea extends View { 

private Path drawPath; 
private Paint drawPaint, canvasPaint; 
private int paintColor = 0xFF660000; 
private Canvas drawCanvas; 
private Bitmap canvasBitmap; 
private ArrayList<Path> paths = new ArrayList<Path>(); 
private ArrayList<Path> undonePaths = new ArrayList<Path>(); 
private ArrayList<Integer> colors = new ArrayList<Integer>(); 
private float mX, mY; 
private static final float TOUCH_TOLERANCE = 4; 
private static boolean mRedoStatus = false; 
private static boolean mUndoStatus = false; 
private float currentBrushSize; 
private float lastBrushSize; 
// for Undo, Redo 
private int historyPointer = 0; 
private boolean erase = false; 

public DrawingArea(Context context) { 
    super(context); 
    setupDrawing(); 
} 

public DrawingArea(Context context, AttributeSet attrs) { 
    super(context, attrs); 
    setupDrawing(); 
} 

public void setupDrawing() { 
    drawPath = new Path(); 
    drawPaint = new Paint(); 
    drawPaint.setAntiAlias(true); 
    drawPaint.setStrokeWidth(20); 
    drawPaint.setStyle(Paint.Style.STROKE); 
    drawPaint.setStrokeJoin(Paint.Join.ROUND); 
    drawPaint.setStrokeCap(Paint.Cap.ROUND); 
    canvasPaint = new Paint(Paint.DITHER_FLAG); 
    //paths.add(drawPath); 
} 

public void setColor(String newColor) { 
    invalidate(); 
    paintColor = Color.parseColor(newColor); 
    drawPaint.setColor(paintColor); 
} 

@Override 
protected void onDraw(Canvas canvas) { 
    for (Path p : paths) { 
     canvas.drawPath(p, drawPaint); 
    } 
    canvas.drawPath(drawPath, drawPaint); 
} 

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

@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; 
} 

private void touch_start(float x, float y) { 
    undonePaths.clear(); 
    drawPath.reset(); 
    drawPath.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) { 
     drawPath.quadTo(mX, mY, (x + mX)/2, (y + mY)/2); 
     mX = x; 
     mY = y; 
    } 
} 

public void setErase() { 
    canvasBitmap.eraseColor(Color.TRANSPARENT); 
    drawPath.reset(); 
    invalidate(); 
} 

private void touch_up() { 
    drawPath.lineTo(mX, mY); 
    // commit the path to our offscreen 
    drawCanvas.drawPath(drawPath, drawPaint); 
    paths.add(drawPath); 
    // kill this so we don't double draw 
    drawPath = new Path(); 
} 

public void startNew() { 
    drawCanvas.drawColor(0, PorterDuff.Mode.CLEAR); 
    invalidate(); 
} 

public void undo() { 
    if (paths.size() > 0) { 
     undonePaths.add(paths.remove(paths.size() - 1)); 
     invalidate(); 
    } else { 
     setEmptyStatus(false); 
    } 
} 

public void setEmptyStatus(boolean status) { 
    mRedoStatus = status; 
    mUndoStatus = status; 
} 

public void redo() { 
    if (undonePaths.size() > 0) { 
     paths.add(undonePaths.remove(undonePaths.size() - 1)); 
     invalidate(); 
    } else { 
     setEmptyStatus(false); 
    } 
} 

public void setBrushSize(float newSize) { 
    float pixelAmount = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 
      newSize, getResources().getDisplayMetrics()); 
    currentBrushSize = pixelAmount; 
    canvasPaint.setStrokeWidth(newSize); 
} 

public void setLastBrushSize(float lastSize) { 
    lastBrushSize = lastSize; 
} 

public float getLastBrushSize() { 
    return lastBrushSize; 
} 

}

Answer 1

On dirait que vous configurez la nouvelle couleur de votre variable drawPaint. Cependant, dans votre méthode onDraw:

for (Path p : paths) { 
    canvas.drawPath(p, drawPaint); 
} 

Cette boucle dessine tous les chemins précédents utilisant le même objet de peinture, drawPaint, ce qui est la raison pour laquelle ils sont tous dessinés avec la même couleur. Une solution possible à considérer est de sauver chaque objet Paint avec le chemin, et d'appeler drawPath pour chaque chemin et son Paint.Just correspondant car vous avez une liste de tous les anciens chemins, vous pouvez également créer une liste de vieilles peintures. Lorsque vous enregistrez chaque chemin d'accès à la liste des chemins d'accès, vous pouvez ajouter le drawPaint actuel à la liste des textures. Ensuite, dans votre méthode onDraw, vous pouvez changer votre boucle pour ressembler à quelque chose comme ceci:

for(int i = 0 ; i < paths.size() ; i++) { 
    canvas.drawPath(paths.get(i), paints.get(i)); 
} 

Ce dessineriez chaque chemin avec sa peinture correspondant, en conservant chaque couleur des chemins.