Preliminary solutions for Exercise 5

Author: csvan

.idea/misc.xml

@@ -0,0 +1,17 @@
+package ex5.question1;
+
+import javax.swing.*;
+
+/**
+ * This class IS a JFrame, since it extends it. What this means in
+ * practice is that this class will have access to all non-private
+ * methods of JFrame.
+ */
+class MyFrame extends JFrame {
+
+    public MyFrame() {
+        this.setTitle("Programmering");
+        this.setSize(300, 300);
+        this.setVisible(true);
+    }
+}

.idea/workspace.xml

@@ -0,0 +1,25 @@
+package ex5.question1;
+
+import javax.swing.*;
+
+/**
+ * Created by christopher on 1/30/14.
+ * <p/>
+ * This class HAS a JFrame, and thus uses the Composition pattern,
+ * rather than Inheritance. In practice, this means that we can use
+ * the JFrame according to its public API only - we cannot access
+ * inner members for the frame, as we could in the Inheritance example.
+ */
+public class MyFrame2 {
+
+    public MyFrame2() {
+        JFrame frame = new JFrame();
+        frame.setTitle("Programmering");
+        frame.setSize(300, 300);
+        frame.setVisible(true);
+    }
+
+    public static void main(String[] args) {
+
+    }
+}

src/ex5/question1/MyFrame.java

@@ -0,0 +1,17 @@
+package ex5.question1;
+
+import javax.swing.*;
+
+/**
+ * Created by christopher on 1/29/14.
+ */
+public class question1 {
+
+    public static void main(String[] args) {
+        JFrame frame = new JFrame();
+        frame.setTitle("Programmering");
+        frame.setSize(300, 300);
+        frame.setVisible(true);
+    }
+}
+

src/ex5/question1/MyFrame2.java

@@ -0,0 +1,40 @@
+package ex5.question2;
+
+import javax.swing.*;
+
+/**
+ * This custom JFrame places each new instance of itself
+ * on a new area of the screen.
+ */
+class MyMultiFrame extends JFrame {
+
+    /*
+     * We make use of these static (i.e. JVM-global) variables
+     * in order to indicate what position the next frame should take.
+     *
+     * Note that we do not pay any special respect to upper bounds here -
+     * if we create enough frames during a single run, we will eventually
+     * end up placing them beyond the physical constraints of the users
+     * monitor, effectively rendering them invisible after creation.
+     */
+    private static int X_POSITION = 100;
+    private static int Y_POSITION = 100;
+
+    public MyMultiFrame() {
+        this.setTitle("Programmering");
+        this.setSize(300, 300);
+
+        // Set the location, and then increase the coordinates.
+        this.setLocation(X_POSITION, Y_POSITION);
+        X_POSITION += 50;
+        Y_POSITION += 50;
+
+        this.setVisible(true);
+    }
+
+    public static void main(String[] args) {
+        for (int i = 0; i < 10; i++) {
+            new MyMultiFrame();
+        }
+    }
+}

src/ex5/question1/question1.java

@@ -0,0 +1,26 @@
+package ex5.question2;
+
+import javax.swing.*;
+
+public class MyMultiFrame2 {
+    private static int X_POSITION = 100;
+    private static int Y_POSITION = 100;
+
+    public MyMultiFrame2() {
+        JFrame frame = new JFrame();
+        frame.setTitle("Programmering");
+        frame.setSize(300, 300);
+
+        frame.setLocation(X_POSITION, Y_POSITION);
+        X_POSITION += 50;
+        Y_POSITION += 50;
+
+        frame.setVisible(true);
+    }
+
+    public static void main(String[] args) {
+        for (int x = 0; x < 10; x++) {
+            new MyMultiFrame2();
+        }
+    }
+}

src/ex5/question2/MyMultiFrame.java

@@ -0,0 +1,106 @@
+package ex5.question6;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * Created by christopher on 1/30/14.
+ * <p/>
+ * Notice that our class IS a JFrame. We are creating a custom frame tailored
+ * for function plotting, rather than reusing a basic JFrame.
+ */
+public class DrawFunction extends JFrame {
+
+    public DrawFunction() throws HeadlessException {
+
+        /*
+         * We use a standard border layout, since we will only need
+         * to consider a single component.
+         */
+        setLayout(new BorderLayout());
+
+        /*
+         * Here, we create and attach the actual "drawing surface to
+         * the frame. The second parameter, BorderLayout.CENTER, tells
+         * the system that the component should be placed at the center
+         * of the frames layout.
+         */
+        add(new DrawingBoard(), BorderLayout.CENTER);
+
+        /*
+         * This defines what action to take when we close the frame (by
+         * clicking the "X" in the top-right corner, if we are on a
+         * Windows machine, for example). In our case, we shut down the
+         * frame when it is closes.
+         */
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+        /*
+         * Set the title to appear in the top-bar of the frame.
+         */
+        setTitle("Draw");
+    }
+
+    /**
+     * This will be our "drawing board", where we do the actual plotting.
+     * Our board is a JPanel, which is a multi-purpose component which
+     * can be used to hold text, graphics, or other components.
+     */
+    class DrawingBoard extends JPanel {
+
+        /**
+         * The function which we will be plotting. Could easily be replaced by an
+         * interface like we did in previous exercises.
+         *
+         * @param x
+         * @return
+         */
+        private double f(double x) {
+            return x * x;
+        }
+
+        @Override
+        protected void paintComponent(final Graphics g) {
+            super.paintComponent(g);
+
+            /*
+             * First, we draw the arrows on our chart (to give it that nice, math-ish feeling).
+             */
+            g.drawLine(390, 200, 370, 190);
+            g.drawLine(390, 200, 370, 210);
+            g.drawLine(200, 30, 190, 50);
+            g.drawLine(200, 30, 210, 50);
+
+            /*
+             * Draw the X and Y axes
+             */
+            g.drawLine(10, 200, 390, 200);
+            g.drawLine(200, 30, 200, 390);
+
+            /*
+             * Draw the labels for the axes
+             */
+            g.drawString("X", 390, 170);
+            g.drawString("Y", 220, 40);
+
+            /*
+             * To do the actual drawing, we use a Polygon.
+             */
+            Polygon polygon = new Polygon();
+
+            for (int x = -40; x <= 40; x++) {
+                polygon.addPoint(x + 200, 200 - (int) ((0.1) * f(x)));
+            }
+
+            g.drawPolyline(polygon.xpoints, polygon.ypoints, polygon.npoints);
+        }
+    }
+
+    public static void main(String[] args) {
+        final int FRAME_WIDTH = 400;
+        final int FRAME_HEIGHT = 400;
+        DrawFunction frame = new DrawFunction();
+        frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
+        frame.setVisible(true);
+    }
+}

src/ex5/question2/MyMultiFrame2.java

@@ -0,0 +1,12 @@
+package ex5.question6;
+
+/**
+ * Created by christopher on 1/30/14.
+ */
+public class Test {
+
+    public static void main(String[] args) {
+        DrawFunction drawFunction = new DrawFunction();
+        drawFunction.setVisible(true);
+    }
+}

src/ex5/question6/DrawFunction.java

@@ -0,0 +1,15 @@
+package ex5.question7;
+
+import javax.swing.*;
+
+/**
+ * Created by christopher on 1/30/14.
+ */
+public class NameFrame {
+
+    private final JFrame frame = new JFrame();
+
+    public NameFrame() {
+        
+    }
+}