UniPix_PixView

package com.creetail.unipix;
import android.view.*;
import android.content.*;
import android.graphics.*;
import android.util.*;
import android.widget.*;
import java.util.*;
import android.support.annotation.*;

public class PixView extends View
{
    private Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG),
        border = new Paint(Paint.ANTI_ALIAS_FLAG),
        figures = new Paint();
    private int nowColor = Color.TRANSPARENT;
    public boolean grid = true, editMode = true, ffmode = false;
    private TouchListener tl;
    int width = 10, height = 10;
    private int[] lastPix = new int[4];
    private Bitmap bm, gridBm;
    private Rect src, dest;
    int figureType = 0;
    private Bitmap fgBm;

    public PixView(Context c, AttributeSet attr){
        super(c, attr);

        paint.setStyle(Paint.Style.FILL);
        figures.setStyle(Paint.Style.STROKE);
        figures.setColor(Color.BLACK);
        figures.setAntiAlias(false);

        border.setStyle(Paint.Style.STROKE);
        border.setColor(Color.BLACK);

        create(Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888));
    }

    public void create(Bitmap newBm){
        width = newBm.getWidth();
        height = newBm.getHeight();
        bm = newBm;
        src = new Rect(0, 0, width, height);
        dest = new Rect(0, 0, width * getPixelSize(), height * getPixelSize());
        gridBm = gridBm();

        Layers.layers = new ArrayList<Layers.Layer>();
        Layers.Layer l = new Layers.Layer();
        l.bm = bm;
        l.hidden = false;
        Layers.layers.add(l);
        Layers.nowBitmap = bm;

        setOnTouchListener(new OnTouchListener(){
                public boolean onTouch(View v, MotionEvent m){
                    if (Mode.currentMode != Mode.Modes.MOVE_MODE){
                        int x = (int)m.getX(), y = (int)m.getY();

                        if (x < 0) x = 0;
                        if (y < 0) y = 0;

                        int iX = x / getPixelSize(),
                            iY = y / getPixelSize();

                        if (iX > width - 1) iX = width - 1;
                        if (iY > height - 1) iY = height - 1;

                        if (m.getAction() == m.ACTION_DOWN || m.getAction() == m.ACTION_MOVE){
                            if (Mode.currentMode == Mode.Modes.DRAW_MODE){
                                Layers.nowBitmap.setPixel(iX, iY, nowColor);
                            }else if (Mode.currentMode == Mode.Modes.RUBBER_MODE){
                                Layers.nowBitmap.setPixel(iX, iY, Color.TRANSPARENT);
                            }else if (Mode.currentMode == Mode.Modes.FLOODFILL_MODE){
                                floodFill(Layers.nowBitmap, new Point(iX, iY), Layers.nowBitmap.getPixel(iX, iY), nowColor);
                            }else if (Mode.currentMode == Mode.Modes.PICK_MODE){
                                MainActivity.getCurrentColorView().setColor(Layers.nowBitmap.getPixel(iX, iY));
                                setColor(Layers.nowBitmap.getPixel(iX, iY));
                            }
                            invalidate();
                        }

                        if (Mode.currentMode == Mode.Modes.FIGURE_MODE){
                            if (m.getAction() == m.ACTION_DOWN){
                                lastPix[0] = iX;
                                lastPix[1] = iY;
                                lastPix[2] = iX;
                                lastPix[3] = iY + 1;
                            }else if (m.getAction() == m.ACTION_MOVE){
                                lastPix[2] = iX;
                                lastPix[3] = iY + 1;
                            }else if (m.getAction() == m.ACTION_UP){
                                Canvas c = new Canvas(Layers.nowBitmap);
                                c.drawLine(lastPix[0], lastPix[1], lastPix[2], lastPix[3], figures);
                            }

                            invalidate();
                        }
                    }
                    tl.onTouch(m);
                    return true;
                }
            });
    }

    public void newField(Bitmap newBm){
        create(newBm);
        invalidate();
    }

    public Bitmap getBitmap (){
        return bm;
    }

    public void setTouchListener (TouchListener tl){
        this.tl = tl;
    }

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

    private Bitmap gridBm(){
        Bitmap b = Bitmap.createBitmap(width * getPixelSize(), height * getPixelSize(), Bitmap.Config.ARGB_8888);
        Canvas c = new Canvas(b);
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
        p.setColor(Color.BLACK);
        p.setStyle(Paint.Style.STROKE);
        for (int x = 0; x < width; x++){
            for (int y = 0; y < height; y++){
                int xx = x * getPixelSize(),
                    yy = y * getPixelSize();
                Rect r = new Rect(xx, yy, xx + getPixelSize(), yy + getPixelSize());
                c.drawRect(r, p);
            }
        }
        return b;
    }

    public void floodFill(Bitmap image, Point node, int targetColor, int replacementColor) {
        int width = image.getWidth();
        int height = image.getHeight();
        int target = targetColor;
        int replacement = replacementColor;
        if (target != replacement) {
            Deque<Point> queue = new LinkedList<Point>();
            do {
                int x = node.x;
                int y = node.y;
                while (x > 0 && image.getPixel(x - 1, y) == target) {
                    x--;
                }
                boolean spanUp = false;
                boolean spanDown = false;
                while (x < width && image.getPixel(x, y) == target) {
                    image.setPixel(x, y, replacement);
                    if (!spanUp && y > 0 && image.getPixel(x, y - 1) == target) {
                        queue.add(new Point(x, y - 1));
                        spanUp = true;
                    } else if (spanUp && y > 0 && image.getPixel(x, y - 1) != target) {
                        spanUp = false;
                    }
                    if (!spanDown && y < height - 1 && image.getPixel(x, y + 1) == target) {
                        queue.add(new Point(x, y + 1));
                        spanDown = true;
                    } else if (spanDown && y < height - 1 && image.getPixel(x, y + 1) != target) {
                        spanDown = false;
                    }
                    x++;
                }
            } while ((node = queue.pollFirst()) != null);
        }
    }

    public int getPixelSize (){
        DisplayMetrics d = getResources().getDisplayMetrics();
        return Math.min (d.widthPixels, d.heightPixels) / Math.max(width, height);
    }

    @Override
    public void onDraw(Canvas can){
        super.onDraw(can);
        for (int i = Layers.layers.size() != 0?Layers.layers.size() - 1 : 0; i >= 0; i--){
            Layers.Layer layer = Layers.layers.get(i);
            if (!layer.hidden){
                paint.setAlpha(layer.alpha);
                can.drawBitmap(layer.bm, src, dest, paint);
            }
        }
        can.drawLine(lastPix[0], lastPix[1], lastPix[2], lastPix[3], figures);
        if (grid) can.drawBitmap(gridBm, 0, 0, border);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
    {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        setMeasuredDimension(width * getPixelSize(), height * getPixelSize());
    }

    public void setEditMode (boolean editMode){
        this.editMode = editMode;
    }

    public void grid (boolean bool){
        this.grid = bool;
        invalidate();
    }

    public boolean grid (){
        return grid;
    }
}