OOP2

	private Enum<BookType> bookType;

	private int price;

	private int inStock;

	public Book(Enum<BookType> bookType, int price, int inStock) { 

		this.bookType = bookType;

		this.price = price;

		this.inStock = inStock;

	}

	public void setBookType(Enum<BookType> bookType) {

		this.bookType = bookType;

	}

	public Enum<BookType> getBookType() {	

		return bookType;

	}

	public void setPrice(int price) {

		this.price = price;

	}

	public int getPrice() {	

		return price;

	}

	public void setInStock(int inStock) {

		this.inStock = inStock;

	}

	public int getInStock() {	

		return inStock;

	}

}

public class BookList {

	private List<Book> bookList;

	public BookList(List<Book> bookList) { 

		this.bookList = bookList;

	}

	private List<int> prices;

	public void setPrices(List<int> prices) {

		this.prices = prices;

	}

	private generateBookList() {

	public void setBookList(List<Book> bookList) {

		this.bookList = bookList;

	}

	public List<Book> getBookList() {	

		return bookList;

	}

}

/**

 *

 * @author jvermeulen

 */

public abstract class AbstractController implements Controller {

    private Observable mModel;

    private View mView;

    public AbstractController(Observable model) {

        // Set the model.

        setModel(model);

    }

    @Override

    public void setView(View view) {

        mView = view;

    }

    @Override

    public View getView() {

        return mView;

    }

    @Override

    public void setModel(Observable model) {

        mModel = model;

    }

    @Override

    public Observable getModel() {

        return mModel;

    }

}

import java.util.Observer;

/**

 *

 * @author jvermeulen

 */

public abstract class AbstractView implements View, Observer {

    private Observable mModel;

    private Controller mController;

    /**

     * Empty constructor so that the model and controller can be set later.

     */

    public AbstractView() {        

    }

    public AbstractView(Observable model, Controller controller) {

        // Set the model.

        setModel(model);

        // If a controller was supplied, use it. Otherwise let the first call to 

        // getController() create the default controller.

        if (controller != null) {

            setController(controller);

        }

    }

    @Override

    public void setController(Controller controller) {

        mController = controller;

        // Tell the controller this object is its view.

        getController().setView(this);

    }

    @Override

    public Controller getController() {

        // If a controller hasn't been defined yet...

        if (mController == null) {

            // ...make one. Note that defaultController is normally overriden by 

            // the AbstractView subclass so that it returns the appropriate 

            // controller for the view.

            setController(defaultController(getModel()));

        }

        return mController;

    }

    @Override

    public void setModel(Observable model) {

        mModel = model;

    }

    @Override

    public Observable getModel() {

        return mModel;

    }

    @Override

    public Controller defaultController(Observable model) {

        return null;

    }

    /**

     * A do-nothing implementation of the Observer interface's update method.

     * Subclasses of AbstractView will provide a concrete implementation for 

     * this method.

     */

    @Override

    public void update(Observable o, Object arg) {    

    }

}

import java.awt.event.WindowEvent;

import javax.swing.BoxLayout;

import javax.swing.JFrame;

/**

 * Main user interface for the application. Makes sure the model, views and

 * controllers are connected to each other.

 * @author jvermeulen

 */

public class Clock {

    // The clock data (i.e., the Model).

    private ClockModel mModel;

    // A digital view of the clock.

    private ClockDigitalView mDigitalView;

    // A toolbar for controlling the clock.

    private ClockTools mTools;

    // An analog view of the clock.

    private final ClockAnalogView mAnalogView;

    public Clock(int hour, int minute, int second) {

        // Create the data model.

        mModel = new ClockModel();

        // Create the digital clock view.

        mDigitalView = new ClockDigitalView(mModel, null);

        mModel.addObserver(mDigitalView);

        // Create the analog clock view.

        mAnalogView = new ClockAnalogView(mModel, null);

        mModel.addObserver(mAnalogView);

        // Create the clock tools view.

        mTools = new ClockTools(mModel, null);

        mModel.addObserver(mTools);

        // Set the time.

        mModel.setTime(hour, minute, second);

        // Start the clock ticking.

        mModel.start();

    }

    public void createGUI() {

        JFrame frame = new JFrame("Clock");

        frame.setLayout(new BoxLayout(frame.getContentPane(), BoxLayout.Y_AXIS));

        frame.getContentPane().add(mDigitalView.getUI());

        frame.getContentPane().add(mAnalogView);

        frame.getContentPane().add(mTools.getUI());                

        frame.addWindowListener(new WindowAdapter() {

            @Override

            public void windowClosing(WindowEvent e) {

                System.exit(0);

            }

        });

        frame.pack();

        frame.setVisible(true);

    }

    private static void createAndShowGUI() {

        Clock clock = new Clock(9, 10, 22);

        clock.createGUI();

    }

    public static void main(String[] args) {

        //Schedule a job for the event-dispatching thread:

        //creating and showing this application's GUI.

        javax.swing.SwingUtilities.invokeLater(new Runnable() {

            @Override

            public void run() {

                createAndShowGUI();

            }

        });

    }

}

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.RenderingHints;

import java.awt.geom.AffineTransform;

import java.awt.geom.Ellipse2D;

import java.awt.geom.GeneralPath;

import java.util.Calendar;

import java.util.Observable;

import javax.swing.JComponent;

/**

 * An analog clock View for the ClockModel. This View has no user inputs, so

 * no controller is required. This class implements the View interface, and

 * subclasses JComponent directly, to illustrate that not all Views need to

 * inherit from AbstractView.

 *

 * Note: it is not necessary to understand all the details of the rendering 

 * of the analog clock.

 *

 * @author jvermeulen (inspired by IBM Java2D tutorial)

 */

public class ClockAnalogView extends JComponent implements View {

    private Observable mModel;

    private Controller mController;

    int mHour;

    int mMinute;

    int mSecond;

    ClockAnalogView(Observable model, Controller controller) {

        mModel = model;

        mController = controller;

    }

    @Override

    public void setController(Controller controller) {

        mController = controller;

    }

    @Override

    public Controller getController() {

        return mController;

    }

    @Override

    public void setModel(Observable model) {

        mModel = model;

    }

    @Override

    public Observable getModel() {

        return mModel;

    }

    @Override

    public Controller defaultController(Observable model) {

        return null;

    }

    @Override

    public void update(Observable o, Object info) {

        // Cast info to ClockUpdate type.

        ClockUpdate clockInfo = (ClockUpdate) info;

        // Store hour, minute, second for repainting.

        mHour = clockInfo.getHour()+5; // +5 Geeft een latere tijdzone weer. Dit is namelijk opdracht 3.

        mMinute = clockInfo.getMinute();

        mSecond = clockInfo.getSecond();

        // Using a little trigonometry, set the transforms to rotate

        // each hand into the proper position.  Center the rotation

        // around the pivot point (50, 50) instead of the origin

        hourTransform.setToRotation(((double) mHour) *

                                            (Math.PI / 6.0), 50, 50);

        minuteTransform.setToRotation(((double) mMinute) *

                                            (Math.PI / 30.0), 50, 50);

        secondTransform.setToRotation(((double) mSecond) *

                                            (Math.PI / 30.0), 50, 50);

        repaint();

    }

    /**

     * Sets this components preferred size to 150x150.

     * @return

     */

    @Override

    public Dimension getPreferredSize() {

        return new Dimension(100, 100);

    }

    // Create a shape for the face of the clock

    protected static Ellipse2D face = new Ellipse2D.Float(3, 3, 94, 94);

    // Create a path that represents a tick mark

    protected static GeneralPath tick = new GeneralPath();

    static // http://www.jusfortechies.com/java/core-java/static-blocks.php

    {

        tick.moveTo(100, 100);

        tick.moveTo(49, 0);

        tick.lineTo(51, 0);

        tick.lineTo(51, 6);

        tick.lineTo(49, 6);

        tick.lineTo(49, 0);

    }

    // Create a cool hour hand

    protected static GeneralPath hourHand = new GeneralPath();

    static

    {

        hourHand.moveTo(50, 15);

        hourHand.lineTo(53, 50);

        hourHand.lineTo(50, 53);

        hourHand.lineTo(47, 50);

        hourHand.lineTo(50, 15);

    }

    // Create a cool minute hand

    protected static GeneralPath minuteHand = new GeneralPath();

    static

    {

        minuteHand.moveTo(50, 2);

        minuteHand.lineTo(53, 50);

        minuteHand.lineTo(50, 58);

        minuteHand.lineTo(47, 50);

        minuteHand.lineTo(50, 2);

    }

    // And a cool second hand

    protected static GeneralPath secondHand = new GeneralPath();

    static

    {

        secondHand.moveTo(49, 5);

        secondHand.lineTo(51, 5);

        secondHand.lineTo(51, 62);

        secondHand.lineTo(49, 62);

        secondHand.lineTo(49, 5);

    }

    // Create some colors for the pieces of the clock

    protected static Color faceColor = new Color(220, 220, 220);

    protected static Color hourColor = Color.red.darker();

    protected static Color minuteColor = Color.blue.darker();

    protected static Color secondColor = new Color(180, 180, 0);

    protected static Color pinColor = Color.gray.brighter();

    // Create circles for the pivot and center pin

    protected Ellipse2D pivot = new Ellipse2D.Float(47, 47, 6, 6);

    protected Ellipse2D centerPin = new Ellipse2D.Float(49, 49, 2, 2);

    // Create three transforms that center around the pivot point

    protected AffineTransform hourTransform =

                    AffineTransform.getRotateInstance(0, 50, 50);

    protected AffineTransform minuteTransform =

                    AffineTransform.getRotateInstance(0, 50, 50);

    protected AffineTransform secondTransform =

                    AffineTransform.getRotateInstance(0, 50, 50);

    // Create a timer that fires once a second and a Calendar

    // instance for getting the time values

    // protected Timer timer = new Timer(1000, this);

    protected Calendar calendar = Calendar.getInstance();

    // This is an alternative to creating a UI delegate.  Since JPanel's

    // paint() method only paints the border and backgound, we can just

    // override the paint method of the component to do the graphics.

    public void paint(Graphics g)

    {

        // Call the superclass first to paint the border (if one is assigned)

        super.paint(g);

        // Get the graphics context and turn on anti-aliasing

        Graphics2D g2 = (Graphics2D) g;

        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

                            RenderingHints.VALUE_ANTIALIAS_ON);

        // Set the paint for the clock face and fill it in

        g2.setPaint(faceColor);

        g2.fill(face);

        // Set the paint to black and draw the clock's outline

        g2.setPaint(Color.black);

        g2.draw(face);

        // Fill in the 12 ticks around the face of the clock

        for (double p = 0.0; p < 12.0; p += 1.0)

        {

            // This is probably terribly inefficient and should be

            // done statically or in the constructor - draw the

            // tick as a transformed shape that is rotated.

            g2.fill(tick.createTransformedShape(

                AffineTransform.getRotateInstance((Math.PI / 6.0)  * p,

                        50, 50)));

        }

        // Set the paint and draw the hour hand.  It is lowest in the

        // 'z-order' so will appear underneath the other hands.  Notice

        // how each hand is transformed by a different <AffineTransform>.

        g2.setPaint(hourColor);

        g2.fill(hourHand.createTransformedShape(hourTransform));

        // Set the paint and draw the minute hand, the second hand,

        // the pivot and the center pin

        g2.setPaint(minuteColor);

        g2.fill(minuteHand.createTransformedShape(minuteTransform));

        g2.setPaint(secondColor);

        g2.fill(secondHand.createTransformedShape(secondTransform));

        g2.fill(pivot);

        g2.setPaint(pinColor);

        g2.fill(centerPin);

    }

}

import java.util.Calendar;

/**

 * A clock controller that allows the clock to be started, stopped and reset.

 * @author jvermeulen

 */

//Toevoeging van Maarten V.: onSystemTime() voor updaten systeemtijd. Ook het aanpassen van ClockDigitalView wordt hier behandeld.

//Extra toevoeging voor OEF04: onEdit() als de gebruiker via het tekstveld een aanpassing doorvoert.

public class ClockController extends AbstractController {

    public ClockController(Observable model) {

        super(model);

    }

    public void onStart() {

        ((ClockModel)getModel()).start();

    }

    public void onStop() {

        ((ClockModel)getModel()).stop();

    }

    public void onReset() {

        ((ClockModel)getModel()).setTime(0,0,0);

    }

	public void onSystemTime() {

			Calendar calendar = Calendar.getInstance();

			((ClockModel)getModel()).setTime(calendar.get(Calendar.HOUR_OF_DAY), calendar.get(Calendar.MINUTE), calendar.get(Calendar.SECOND));

	}

    public void onEdit(String givenTime) {

			String[] parts = givenTime.split(":");

			System.out.println("Dit is al iets");

        ((ClockModel)getModel()).setTime(

			Integer.parseInt(parts[0]),

			Integer.parseInt(parts[1]),

			Integer.parseInt(parts[2]));

    }

}

import java.util.Observable;

import javax.swing.JComponent;

import javax.swing.JTextField;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

/**

 * A digital clock View for the ClockModel. This View has no user inputs, so no 

 * Controller is required.

 * @author jvermeulen

 */

//BRING THE CHANGE! This should be updatable, so controllers and stuff will be added.

public class ClockDigitalView extends AbstractView {

    // The user interface for this view.

    private JTextField mClock;

    public ClockDigitalView(Observable model, DigitalClockController controller) {

        super(model, controller);

        init();

    }

    /**

     * Initializes the user interface.

     */

    private void init() {

        mClock = new JTextField();

		mClock.addActionListener(new ActionListener() {

				@Override

				public void actionPerformed(ActionEvent e) {

					((DigitalClockController)getController()).onEdit(mClock.getText());

				}

		});

    }

    /**

     * Updates the state of the on-screen digital clock.

     * Invoked automatically by ClockModel.

     * @param o The ClockModel object that is broadcasting an update

     * @param info A ClockUpdate instance describing the changes that have 

     * occurred in the ClockModel

     */

    @Override

    public void update(Observable o, Object info) {    

        // Cast info to ClockUpdate type.

        ClockUpdate clockInfo = (ClockUpdate) info;

        // Create a String representing the time.        

        String timeString = formatTime(clockInfo);

        // Display the new time in the clock text field.

        mClock.setText(timeString);

        // Fade the color of the display if the clock isn't running.

        if (clockInfo.isRunning()) {

          mClock.setBackground(Color.white);

        } else {

          mClock.setBackground(Color.gray);

        }

    }

    /**

     * Convenience method to return the user interface component. We don't need 

     * this if we implement View directly and directly subclass a GUI component.

     * @return the JComponent representing this View.

     */

	@Override

	public Controller defaultController(Observable model) {

			return new DigitalClockController(model);

	}

    public JComponent getUI() {

        return mClock;

    }

    private String formatTime(ClockUpdate info) {

        return String.format("%d:%d:%d", 

                             info.getHour(), 

                             info.getMinute(), 

                             info.getSecond());

    }        

}

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.Observable;

import java.util.Timer;

import java.util.TimerTask;

import javax.swing.SwingUtilities;

/**

 *

 * @author jvermeulen

 */

public class ClockModel extends Observable {

    private int mHour;

    private int mMinute;

    private int mSecond;

    private final long mTickInterval = 1000; // tick every second

    private Timer mTimer;

    private boolean mIsRunning;

    public ClockModel() {

        // By default, set the clock time to the current system time.

        Calendar now = new GregorianCalendar();        

        setTime(now.get(Calendar.HOUR_OF_DAY), now.get(Calendar.MINUTE), 

                now.get(Calendar.SECOND));        

    }

	public ClockModel(int hour, int minute, int second) {

			setTime(hour, minute, second);

		}

    /**

     * Helper class to run the tick() method multiple times 

     * (e.g., every 1 second).

     */

    class TickTask extends TimerTask {

        public void run() {

            tick();

        }

    }

    public void start() {

        if (!mIsRunning) {

            mIsRunning = true;

            // Schedule the tick() method to run every mTickInterval milliseconds.

            mTimer = new Timer();

            mTimer.schedule(new TickTask(), 0, mTickInterval); 

            ClockUpdate info = new ClockUpdate(mHour, mMinute, mSecond, 

                                               mIsRunning);

            setChanged();

            notifyObservers(info);

        }

    }