Trouble with JColorChooser colors when drawing different shapes java

Question

I am implementing a paint app in java. I am having trouble with choosing the colors of the shapes that are drawn. I am able to choose the color and draw with it but if i draw a change the color to blue, draw a blue rectangle, change the color to red, draw rectangle in red, it changes the rectangle in blue to red as well, happens with every shape. I think its because Im saving the shapes in an arrayList which changes the color of all the shapes, but, I have different arrayLists for different shapes.

I am trying to save the color in static color1 and using setPaint(color1) to change the color to the chosen one. Any help would be appreciated.

Below I have part of my code:

  public class PaintAppFrame extends JFrame implements MouseListener,    MouseMotionListener, ActionListener {
static final long serialVersionUID = 2L;


static int flag = 0;
// -------------------------------------------------------------------------

private JButton changeColor;
private JButton rectButton;
private JButton rectfillButton;
private JButton lineButton;
static Color color1;


static Graphics2D gr;

public static ArrayList<Shape> rectStruct = new ArrayList<Shape>();
public static ArrayList<Shape> rectFillStruct = new ArrayList<Shape>();
public static ArrayList<Shape> lineStruct = new ArrayList<Shape>();

private static Point mouseStart;
private static Point mouseEnd;

    changeColor = new JButton("CHANGE COLOR");
    changeColor.setActionCommand("color");
    changeColor.addActionListener(this);


    // added the menu goes here
    image = Toolkit.getDefaultToolkit().getImage(".");
    paintPanel = new PaintPanel();
    paintPanel.addMouseMotionListener(this);
    paintPanel.addMouseListener(this);

    // make this a toolbar and images

    Icon lineIcon = new ImageIcon("icons/line.png");
    Icon rgbIcon = new ImageIcon("icons/color.png");
    Icon rectIcon = new ImageIcon("icons/rect.png");
    Icon rectfillIcon = new ImageIcon("icons/fullRect.png");

    changeColor = new JButton(rgbIcon);
    changeColor.setActionCommand("color");
    changeColor.addActionListener(this);

    rectButton = new JButton(rectIcon);
    rectButton.setActionCommand("rectangle");
    rectButton.addActionListener(this);

    rectfillButton = new JButton(rectfillIcon);
    rectfillButton.setActionCommand("rectanglefill");
    rectfillButton.addActionListener(this);

    lineButton = new JButton(lineIcon);
    lineButton.setActionCommand("line");
    lineButton.addActionListener(this);

    JPanel buttons = new JPanel(new GridLayout());
    buttons.setBorder(BorderFactory.createRaisedSoftBevelBorder());
    buttons.setLayout(new GridLayout(16, 2));

    buttons.add(changeColor);
    buttons.add(rectButton);
    buttons.add(rectfillButton);
    buttons.add(lineButton);


    paintCanvas = new JPanel(new BorderLayout());
    paintCanvas.add(paintPanel, "Center");
    paintCanvas.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
    paintCanvas.setBackground(new Color(100, 100, 142));
    paintCanvas.setPreferredSize(new Dimension(650, 520));
    paintCanvas.setMaximumSize(new Dimension(2000, 1600));

}

public void mouseDragged(MouseEvent me) {


    if (flag == 1) {
        mouseEnd = new Point(me.getX(), me.getY());
        repaint();
        System.out.println("rect dragged");
    }


    else if (flag == 3) {
        mouseEnd = new Point(me.getX(), me.getY());
        repaint();
    }

    } else if (flag == 7) {
        mouseEnd = new Point(me.getX(), me.getY());
        repaint();
    }



}

public void mouseMoved(MouseEvent me) {
}

public void mouseClicked(MouseEvent me) {

}

public void mouseEntered(MouseEvent me) {
}

public void mouseExited(MouseEvent me) {
}

public void mousePressed(MouseEvent me) {


    if (flag == 1) {
        mouseStart = new Point(me.getX(), me.getY());
        mouseEnd = mouseStart;
        repaint();
    }



    else if (flag == 3) {
        mouseStart = new Point(me.getX(), me.getY());
        mouseEnd = mouseStart;
        repaint();
    }


    else if (flag == 7) {
        mouseStart = new Point(me.getX(), me.getY());
        mouseEnd = mouseStart;
        repaint();
    } 
}

public void mouseReleased(MouseEvent me) {

    } else if (flag == 1) {
        Shape r = createRect(mouseStart.x, mouseStart.y, me.getX(), me.getY());
        rectStruct.add(r);
        mouseStart = null;
        mouseEnd = null;
        repaint();
    }

    else if (flag == 3) {
        Shape r = createFillRect(mouseStart.x, mouseStart.y, me.getX(), me.getY());
        rectFillStruct.add(r);
        mouseStart = null;
        mouseEnd = null;
        repaint();
    }


    else if (flag == 7) {
        Shape r = createLine(mouseStart.x, mouseStart.y, me.getX(), me.getY());
        lineStruct.add(r);
        mouseStart = null;
        mouseEnd = null;
        repaint();
    } 
}

@SuppressWarnings("static-access")
public void actionPerformed(ActionEvent ae) {
    String command = ae.getActionCommand();
    Object source = ae.getSource();
    // instantiate the filechooser
    switch (command) {

    case "color":
        this.setPaintColor();
        break;

    case "rectangle":
        flag = 1;
        FLAG = 0;
        this.paintRect(gr);
        break;

    case "rectanglefill":
        flag = 3;
        this.paintRectFill(gr);
        break;


    case "line":
        flag = 7;
        this.paintLine(gr);
        break;


private void setPaintColor() {
    Color color = JColorChooser.showDialog(null, "Choose Paint Color", Color.black);
    color1 = color;
}


public static void paintRect(Graphics g) {

    gr = (Graphics2D) g;

    for (Shape s : rectStruct) {
        gr.setPaint(color1);
        gr.setStroke(new BasicStroke(2));

        gr.draw(s);
        // gr.setPaint(this.LINE_COLOR);
        // gr.fill(s);
    }
    if (flag == 1) {
        if (mouseStart != null && mouseEnd != null) {

        //makes outline while dragging rectangle
            gr.setPaint(Color.RED);
            Shape r = createRect(mouseStart.x, mouseStart.y, mouseEnd.x, mouseEnd.y);
            gr.draw(r);
        }
    }
}

public static void paintRectFill(Graphics g) {
    gr = (Graphics2D) g;

  for (Shape s : rectFillStruct) {
        gr.setPaint(color1);
        gr.setStroke(new BasicStroke(2));

        gr.draw(s);
        gr.fill(s);
    }
    if (flag == 3) {

        if (mouseStart != null && mouseEnd != null) {
            //makes outline while dragging rectangle
            gr.setPaint(Color.RED);
            Shape r = createFillRect(mouseStart.x, mouseStart.y, mouseEnd.x, mouseEnd.y);
            gr.draw(r);
        }
    }
}


public static void paintLine(Graphics g) {
    gr = (Graphics2D) g;

    for (Shape s : lineStruct) {
        gr.setPaint(color1);
        gr.setStroke(new BasicStroke(2));

        gr.draw(s);
        gr.fill(s);

    }

    if (flag == 7) {
        if (mouseStart != null && mouseEnd != null) {
            //makes outline while dragging rectangle
            gr.setPaint(Color.GREEN);
            Shape r = createLine(mouseStart.x, mouseStart.y, mouseEnd.x, mouseEnd.y);
            gr.draw(r);
        }
    }
}

public static Rectangle2D.Float createRect(int x1, int y1, int x2, int y2) {
    return new Rectangle2D.Float(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x1 - x2), Math.abs(y1 - y2));
}


public static Rectangle2D.Float createFillRect(int x1, int y1, int x2, int y2) {
    return new Rectangle2D.Float(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x1 - x2), Math.abs(y1 - y2));
}


public static Line2D.Float createLine(int x1, int y1, int x2, int y2) {
    return new Line2D.Float(x1, y1, x2, y2);
}}

Answer 1

As was already suggested earlier in the comments, your program should store the color for each shape. You could create a simple ColoredShape class that can store a shape and a color:

import java.awt.*;

public class ColoredShape {
    private Shape shape;
    private Color color;

    public ColoredShape(Shape shape, Color color) {
        this.shape = shape;
        this.color = color;
    }

    public Shape getShape() {
        return shape;
    }

    public Color getColor() {
        return color;
    }
}

In the PaintAppFrame class, the following changes could be made to use the new ColoredShape class for the rectangles:

// Field definition change:
//public static ArrayList<Shape> rectStruct = new ArrayList<Shape>();
public static ArrayList<ColoredShape> rectStruct = new ArrayList<ColoredShape>();

// Method mouseReleased change:
//rectStruct.add(r);
rectStruct.add(new ColoredShape(r, color1));

// Method paintRect changes:
//for (Shape s : rectStruct) {
    //gr.setPaint(PaintPanel.LINE_COLOR);
    //[...]
    //gr.draw(s);
for (ColoredShape coloredShape : rectStruct) {
    gr.setPaint(coloredShape.getColor());
    [...]
    gr.draw(coloredShape.getShape());

In the PaintPanel class, these changes could be made to use the new ColoredShape class for the rectangles:

// Field definition added:
private static ArrayList<ColoredShape> redoStructNew = new ArrayList<ColoredShape>();

// Method undo change:
//redoStruct.add(PaintAppFrame.rectStruct.get(i));
redoStructNew.add(PaintAppFrame.rectStruct.get(i));

// Method redo changes:
//if (!PaintAppFrame.rectStruct.isEmpty() && !redoStruct.isEmpty()) {
    //for (int i = 0; i < redoStruct.size(); i++) {
        //PaintAppFrame.rectStruct.add(redoStruct.get(i));
    //[...]
if (!PaintAppFrame.rectStruct.isEmpty() && !redoStructNew.isEmpty()) {
    for (int i = 0; i < redoStructNew.size(); i++) {
        PaintAppFrame.rectStruct.add(redoStructNew.get(i));
    [...]

You can change the code for the other types of shapes in a similar way.

Edit 1: line segments

For line segments, you'll need to store all relevant data as well. Looking at the drawInk method, I think you need: line coordinates, color, and stroke. So instead of storing the coordinates only (see the allStrokes field), you can store a list of line segments in a class like this:

import java.awt.*;
import java.awt.geom.Line2D;

public class LineSegment {
    private Line2D.Double coordinates;
    private Color color;
    private Stroke stroke;

    public LineSegment(Line2D.Double coordinates, Color color, Stroke stroke) {
        this.coordinates = coordinates;
        this.color = color;
        this.stroke = stroke;
    }

    public void draw(Graphics2D graphics2D) {
        graphics2D.setColor(color);
        graphics2D.setStroke(stroke);
        graphics2D.draw(coordinates);
    }
}

Edit 2: drawing order

The order in which the different graphical objects are currently drawn is based on the type of the object instead of when the user added the object. I think the best way to fix this is by storing all graphical objects in a single list, which will decide the drawing order. You can create a super class GraphicalObject that the ColoredShape, Entity, and LineSegment classes extend from. This class can even define shared/overridable methods like draw (already in LineSegment). The GraphicalObject class can be very simple:

import java.awt.Graphics2D;

public abstract class GraphicalObject {
    public abstract void draw(Graphics2D graphics2D);
}

Modify the ColoredShape, Entity, and LineSegment classes like this:

public class LineSegment extends GraphicalObject {
    // [...]

    // Each class should implement the draw method:
    public void draw(Graphics2D graphics2D) {
        // [...]
    }
}

Now you can replace all data structures that store shapes, lines, and entities with a single list of graphical objects:

private List<GraphicalObject> graphicalObjects = new ArrayList<>();

//public static ArrayList<ColoredShape> rectStruct = new ArrayList<ColoredShape>();
// [...]
//public static ArrayList<ColoredShape> lineStruct = new ArrayList<ColoredShape>();

Make sure you use this new list to store all graphical objects that you want to draw in the PaintPanel.paintComponent method (it seems that at the moment some objects are stored in the PaintAppFrame class and others in the PaintPanel class):

paintInkStrokes(g);
paintEraser(g);
PaintAppFrame.paintRect(g);
PaintAppFrame.paintCircle(g);
PaintAppFrame.paintRectFill(g);
PaintAppFrame.paintFillCircle(g);
PaintAppFrame.paintRoundRectangle(g);
PaintAppFrame.paintRoundRectangleFill(g);
PaintAppFrame.paintLine(g);
paintEntities(g);

Some additional advice: I think it would also be possible to make some parts of the code be able to handle all types of shapes, instead of having code for each type. For example in the PaintAppFrame class, the paintRect until paintLine methods have a lot of code in common. Also in the undo and redo methods of the PaintPanel class, there are a lot of blocks of code that are almost the same.