retro pixel art

PaintingView.java

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PointF;
import android.view.MotionEvent;
import android.view.View;

import spencerstudios.com.jetdblib.JetDB;

@SuppressLint("ViewConstructor")
class PaintingView extends View {

    private float cell_size;
    private float touch_x = 0;
    private float touch_y = 0;
    private float canvas_sqr_root;
    private float x_cells;
    
    private Paint[] paints;
    private PointF[] points;
    private Paint gridPaint;
    
    private boolean showGrid;
    
    private int base_color = Color.rgb(155, 188, 15);
    private int selectedColor = Color.rgb(15, 56, 15);

    public PaintingView(Context context, float width, int x_cells) {
        super(context);

        showGrid = JetDB.getBoolean(context, "show_grid");
        this.x_cells = x_cells;
        this.canvas_sqr_root = width;
        int total_cells = x_cells * x_cells;
        cell_size = canvas_sqr_root / x_cells;

        paints = new Paint[total_cells];
        points = new PointF[total_cells];

        gridPaint = new Paint();
        gridPaint.setColor(Color.WHITE);
        gridPaint.setStrokeWidth(1.0f);

        offsetXY();

        float y_top = 0, x_left = 0;

        for (int i = 0; i < points.length; i++) {
            paints[i] = new Paint();
            paints[i].setColor(base_color);
            if (i > 0 && i % x_cells == 0) {
                y_top += cell_size;
                x_left = 0;
            }
            points[i] = new PointF(x_left, y_top);
            x_left += cell_size;
        }
    }

    @SuppressLint("ClickableViewAccessibility")
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
            case MotionEvent.ACTION_MOVE:
                touch_x = event.getX();
                touch_y = event.getY();
                invalidate();
                break;
        }
        return true;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        boolean found = false;

        for (int i = 0; i < points.length; i++) {
            float l = points[i].x, t = points[i].y, r = l + cell_size, b = t + cell_size;
            if (!found) {
                if (touch_x >= l && touch_x <= r && touch_y >= t && touch_y <= b) {
                    paints[i].setColor(selectedColor);
                    found = true;
                }
            }
            canvas.drawRect(l, t, l + cell_size, t + cell_size, paints[i]);

        }

        if (showGrid) {
            float left = cell_size, top = cell_size;
            for (int i = 0; i < x_cells - 1; i++) {
                canvas.drawLine(left, 0, left, canvas_sqr_root, gridPaint);
                canvas.drawLine(0, top, canvas_sqr_root, top, gridPaint);
                top += cell_size;
                left += cell_size;
            }
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        setMeasuredDimension((int) canvas_sqr_root, (int) canvas_sqr_root);
    }

    public void enableGrid(boolean b) {
        showGrid = b;
        invalidate();
    }

    public void resetMatrix() {
        for (Paint paint : paints) {
            paint.setColor(base_color);
        }
        offsetXY();
        invalidate();
    }

    public Bitmap getCanvasBitmap() {
        this.setDrawingCacheEnabled(true);
        return this.getDrawingCache();
    }

    public void setPaintColor(int color) {
        selectedColor = color;
    }

    public void disableDrawingCache() {
        this.setDrawingCacheEnabled(false);
    }

    private void offsetXY() {
        touch_y = 0 - (cell_size * cell_size);
        touch_x = 0 - (cell_size * cell_size);
    }
}