Is this MVC? Simple Java Graphics2D drawing program

Question

I'm after opinions please on this attempt at MVC using Java Graphics2D. I wanted to get my head round MVC using a simple example.

Have I got it right please?

Docs here.

http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller

http://www.oracle.com/technetwork/articles/javase/index-142890.html

Feedback appreciated cheers.

Edit: Code below has now been fixed based on feedback by Rasmus and further research.

public class App {

    /*
     * The view registers as a listener on the model. Any changes to the
     * underlying data of the model immediately result in a broadcast change
     * notification, which the view receives.
     * 
     * Note that the model is not aware of the view or the controller -- it
     * simply broadcasts change notifications to all interested listeners.
     * 
     * The controller is bound to the view. This typically means that any user
     * actions that are performed on the view will invoke a registered listener
     * method in the controller class.
     * 
     * The controller is given a reference to the underlying model.
     */
    public static void main(String[] args) {
        Model model = new Model();
        Controller controller = new Controller(model);
        View view = new View(controller);
        model.addModelChangedListener(view);

    }
}

import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.Iterator;

public class Model {

    private ArrayList<Rectangle> rectangles = new ArrayList<Rectangle>();
    private ArrayList<ModelChangedEventListener> listeners = new ArrayList<ModelChangedEventListener>();

    public void addRectangle(int x, int y, int width, int height) {
        rectangles.add(new Rectangle(x, y, width, height));
        modelChangedEvent();
    }

    public ArrayList<Rectangle> getRectangles() {
        return rectangles;
    }

    public synchronized void addModelChangedListener(
            ModelChangedEventListener listener) {
        listeners.add(listener);
    }

    public synchronized void removeModelChangedListener(
            ModelChangedEventListener listener) {
        listeners.remove(listener);
    }

    private synchronized void modelChangedEvent() {
        ModelChangeEvent event = new ModelChangeEvent(this);
        Iterator<ModelChangedEventListener> i = listeners.iterator();
        while (i.hasNext()) {
            ((ModelChangedEventListener) i.next()).handleModelChange(event);
        }
    }

}

import java.awt.Container;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.EventObject;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class View extends JFrame implements ModelChangedEventListener {

    private static final int DISPLAY_WIDTH = 300;
    private static final int DISPLAY_HEIGHT = 300;
    private ViewPanel viewPanel;
    private Controller controller;

    public View(Controller controller) {
        this.controller = controller;
        setSize(DISPLAY_WIDTH, DISPLAY_HEIGHT);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        Container contentPane = getContentPane();
        viewPanel = new ViewPanel();
        contentPane.add(viewPanel);
        setVisible(true);
    }

    @Override
    public void handleModelChange(EventObject e) {
        viewPanel.repaint();
    }

    public class ViewPanel extends JPanel implements MouseListener {

        public ViewPanel() {
            addMouseListener(this);
        }

        public void paintComponent(Graphics g) {
            Graphics2D g2 = (Graphics2D) g;
            controller.draw(g2);
        }

        @Override
        public void mouseClicked(MouseEvent arg0) {
            controller.click(arg0.getX(), arg0.getY());
        }

        @Override
        public void mouseEntered(MouseEvent arg0) {
        }

        @Override
        public void mouseExited(MouseEvent arg0) {
        }

        @Override
        public void mousePressed(MouseEvent arg0) {
        }

        @Override
        public void mouseReleased(MouseEvent arg0) {
        }

    }

}

import java.awt.Graphics2D;
import java.awt.Rectangle;

public class Controller {

    private Model model;

    public Controller(Model model) {
        this.model = model;
    }

    public void click(int x, int y) {
        model.addRectangle(x, y, 25, 25);
    }

    public void draw(Graphics2D g2) {
        for (Rectangle rectangle : model.getRectangles()) {
            g2.draw(rectangle);
        }
    }
}

import java.util.EventObject;

public interface ModelChangedEventListener {
    public void handleModelChange(EventObject e);
}

public class ModelChangeEvent extends java.util.EventObject {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    public ModelChangeEvent(Object source) {
        super(source);
    }
}

Answer 1

You got it the wrong way around. One of the points of MVC is to make the model independent of the view. I.e the model shouldn't know about the view (or rather it shouldn't need to care). The view on the other hand needs to use model objects to do its thing. I've never designed a non-web application with MVC in mind. The view is normally a JSP/HTML/XHTML/XML file, its role is about making the program look in a certain way. So everything regarding rendering, placement, etc. fits into the view. The controllers job is to collect data from the model and pass it along to the view in a form that the view can use in a simple way, and also handle things like navigation between views. It's the glue that keeps the view and model together. Thus:

The model depends on nothing. The controller depends on the model. The view depends on the controller and model.