[부나] 뷰 챌린지 미션 2단계 제출합니다.

app/src/main/java/woowacourse/paint/MainActivity.kt

@@ -1,37 +1,91 @@
 package woowacourse.paint
 
 import android.os.Bundle
+import android.view.Menu
+import android.view.MenuItem
+import android.widget.LinearLayout
 import androidx.appcompat.app.AppCompatActivity
-import woowacourse.paint.view.CanvasView
-import woowacourse.paint.view.PaletteColor
-import woowacourse.paint.view.PaletteView
+import androidx.appcompat.widget.AppCompatButton
+import woowacourse.paint.view.canvas.CanvasView
+import woowacourse.paint.view.palette.color.PaletteColor
+import woowacourse.paint.view.palette.PaletteMode
+import woowacourse.paint.view.palette.shape.PaletteShape
+import woowacourse.paint.view.palette.PaletteView
 
 class MainActivity : AppCompatActivity() {
     private val canvasView: CanvasView by lazy { findViewById(R.id.canvas_view) }
     private val paletteView: PaletteView by lazy { findViewById(R.id.palette_view) }
+    private val paletteModeView: LinearLayout by lazy { findViewById(R.id.palette_mode_view) }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_main)
 
         setupCanvasView()
         setupPaletteView()
+        setupPaletteModeView()
     }
 
     private fun setupCanvasView() {
         canvasView.setPaintThickness(paletteView.selectedPaintThickness)
-        canvasView.setPaintColor(paletteView.selectedPaintColor)
+        canvasView.setPaletteColor(paletteView.selectedPaletteColor)
     }
 
     private fun setupPaletteView() {
         paletteView.setOnPropertyChangeListener(object : PaletteView.OnPaintPropertyChangeListener {
-            override fun onColorSelected(paintColor: PaletteColor) {
-                canvasView.setPaintColor(paintColor)
+            override fun onColorSelected(paletteColor: PaletteColor) {
+                canvasView.setPaletteColor(paletteColor)
+            }
+
+            override fun onShapeSelected(paletteShape: PaletteShape) {
+                canvasView.setPaletteShape(paletteShape)
             }
 
             override fun onStrokeThicknessChanged(paintThickness: Float) {
                 canvasView.setPaintThickness(paintThickness)
             }
         })
+        paletteView.changePaletteMode(PaletteMode.BRUSH)
+    }
+
+    private fun setupPaletteModeView() {
+        PaletteMode.values().forEach { paletteMode ->
+            val modeButton = createModeButton(paletteMode) { newPaletteMode ->
+                paletteView.changePaletteMode(newPaletteMode)
+                canvasView.changePaletteMode(newPaletteMode)
+            }
+
+            paletteModeView.addView(modeButton)
+            modeButton.layoutParams = (modeButton.layoutParams as LinearLayout.LayoutParams).apply {
+                weight = 1F
+                marginStart = 10
+                marginEnd = 10
+            }
+        }
+    }
+
+    private fun createModeButton(
+        mode: PaletteMode,
+        onClick: (PaletteMode) -> Unit,
+    ): AppCompatButton = AppCompatButton(this).apply {
+        text = mode.modeName
+        textSize = 20F
+        setTextColor(getColor(R.color.white))
+        setBackgroundColor(getColor(R.color.purple_500))
+        setOnClickListener { onClick(mode) }
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.menu_main, menu)
+        return true
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        when (item.itemId) {
+            R.id.undo -> canvasView.undo()
+            R.id.redo -> canvasView.redo()
+            R.id.reset -> canvasView.reset()
+        }
+        return true
     }
 }

app/src/main/java/woowacourse/paint/common/PaintExt.kt

@@ -0,0 +1,19 @@
+package woowacourse.paint.common
+
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+import woowacourse.paint.view.palette.color.PaletteColor
+
+fun Paint.softPainter(
+    paletteColor: PaletteColor = PaletteColor.RED,
+    paintStyle: Paint.Style = Paint.Style.STROKE,
+    porterDuffMode: PorterDuff.Mode = PorterDuff.Mode.SRC_OVER,
+): Paint = apply {
+    isAntiAlias = true
+    style = paintStyle
+    strokeJoin = Paint.Join.ROUND
+    strokeCap = Paint.Cap.ROUND
+    color = paletteColor.color
+    xfermode = PorterDuffXfermode(porterDuffMode)
+}

app/src/main/java/woowacourse/paint/view/ViewDsl.kt → app/src/main/java/woowacourse/paint/common/ViewDsl.kt

@@ -1,4 +1,4 @@
-package woowacourse.paint.view
+package woowacourse.paint.common
 
 import android.content.Context
 import com.google.android.material.slider.RangeSlider

app/src/main/java/woowacourse/paint/view/canvas/CanvasView.kt

@@ -0,0 +1,71 @@
+package woowacourse.paint.view.canvas
+
+import android.content.Context
+import android.graphics.Canvas
+import android.util.AttributeSet
+import android.view.MotionEvent
+import android.view.View
+import woowacourse.paint.view.canvas.paintHistory.PainterHistory
+import woowacourse.paint.view.palette.color.PaletteColor
+import woowacourse.paint.view.palette.PaletteMode
+import woowacourse.paint.view.palette.shape.PaletteShape
+
+class CanvasView : View {
+    constructor(context: Context) : super(context)
+    constructor(context: Context, attrs: AttributeSet) : super(context, attrs)
+
+    private val painterHistory = PainterHistory()
+
+    init {
+        setLayerType(LAYER_TYPE_HARDWARE, null)
+    }
+
+    override fun onDraw(canvas: Canvas) {
+        super.onDraw(canvas)
+        painterHistory.draw(canvas)
+    }
+
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+        val pointX = event.x
+        val pointY = event.y
+
+        when (event.action) {
+            MotionEvent.ACTION_DOWN -> painterHistory.onActionDown(pointX, pointY)
+            MotionEvent.ACTION_MOVE -> painterHistory.onActionMove(pointX, pointY)
+            MotionEvent.ACTION_UP -> painterHistory.onActionUp(pointX, pointY)
+        }
+        invalidate()
+        return true
+    }
+
+    fun setPaletteColor(paletteColor: PaletteColor) {
+        painterHistory.setPaletteColor(paletteColor)
+    }
+
+    fun setPaintThickness(painterThickness: Float) {
+        painterHistory.setPaintThickness(painterThickness)
+    }
+
+    fun setPaletteShape(paletteShape: PaletteShape) {
+        painterHistory.setPaletteShape(paletteShape)
+    }
+
+    fun changePaletteMode(paletteMode: PaletteMode) {
+        painterHistory.changePaletteMode(paletteMode)
+    }
+
+    fun undo() {
+        painterHistory.undo()
+        invalidate()
+    }
+
+    fun redo() {
+        painterHistory.redo()
+        invalidate()
+    }
+
+    fun reset() {
+        painterHistory.clear()
+        invalidate()
+    }
+}

app/src/main/java/woowacourse/paint/view/canvas/paintHistory/PainterHistory.kt

@@ -0,0 +1,62 @@
+package woowacourse.paint.view.canvas.paintHistory
+
+import android.graphics.Canvas
+import woowacourse.paint.view.canvas.painter.BrushPainter
+import woowacourse.paint.view.canvas.painter.Painter
+import woowacourse.paint.view.palette.color.PaletteColor
+import woowacourse.paint.view.palette.PaletteMode
+import woowacourse.paint.view.palette.shape.PaletteShape
+
+class PainterHistory(
+    private val undoes: ArrayList<Painter> = ArrayList(),
+    private val redoes: ArrayList<Painter> = ArrayList(),
+    private var currentPainter: Painter = BrushPainter(),
+) {
+    fun draw(canvas: Canvas) {
+        undoes.forEach { painter -> painter.draw(canvas) }
+    }
+
+    fun setPaletteColor(paletteColor: PaletteColor) {
+        currentPainter = currentPainter.setPaletteColor(paletteColor)
+    }
+
+    fun setPaintThickness(painterThickness: Float) {
+        currentPainter = currentPainter.setThickness(painterThickness)
+    }
+
+    fun setPaletteShape(paletteShape: PaletteShape) {
+        currentPainter = currentPainter.changePainter(PaletteMode.SHAPE, paletteShape)
+    }
+
+    fun changePaletteMode(paletteMode: PaletteMode) {
+        currentPainter = currentPainter.changePainter(paletteMode)
+    }
+
+    fun onActionDown(x: Float, y: Float) {
+        undoes.add(currentPainter)
+        currentPainter.onActionDown(x, y)
+    }
+
+    fun onActionMove(x: Float, y: Float) {
+        currentPainter.onActionMove(x, y)
+    }
+
+    fun onActionUp(x: Float, y: Float) {
+        currentPainter = currentPainter.extract()
+    }
+
+    fun undo() {
+        val redo = undoes.removeLastOrNull() ?: return
+        redoes.add(redo)
+    }
+
+    fun redo() {
+        val undo = redoes.removeLastOrNull() ?: return
+        undoes.add(undo)
+    }
+
+    fun clear() {
+        undoes.clear()
+        redoes.clear()
+    }
+}