/*
 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Oracle nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * This source code is provided to illustrate the usage of a given feature
 * or technique and has been deliberately simplified. Additional steps
 * required for a production-quality application, such as security checks,
 * input validation and proper error handling, might not be present in
 * this sample code.
 */



import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.applet.Applet;


@SuppressWarnings("serial")
class GraphicsPanel extends Panel {

    ActionListener al;
    ItemListener il;
    public GraphicsCards cards;

    GraphicsPanel(EventListener listener) {
        al = (ActionListener) listener;
        il = (ItemListener) listener;

        setLayout(new BorderLayout());

        add("Center", cards = new GraphicsCards());

        Panel p = new Panel();
        //p.setLayout(new BorderLayout());

        Button b = new Button("next");
        b.addActionListener(al);
        p.add(b);

        b = new Button("previous");
        b.addActionListener(al);
        p.add(b);

        p.add(new Label("go to:", Label.RIGHT));

        Choice c = new Choice();
        c.addItemListener(il);
        p.add(c);

        c.addItem("Arc");
        c.addItem("Oval");
        c.addItem("Polygon");
        c.addItem("Rect");
        c.addItem("RoundRect");

        add("North", p);

        setSize(400, 400);
    }

    @Override
    public Dimension getPreferredSize() {
        return new Dimension(200, 100);
    }
}


@SuppressWarnings("serial")
public class GraphicsTest extends Applet
        implements ActionListener, ItemListener {

    GraphicsPanel mainPanel;

    @Override
    public void init() {
        setLayout(new BorderLayout());
        add("Center", mainPanel = new GraphicsPanel(this));
    }

    @Override
    public void destroy() {
        remove(mainPanel);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        String arg = e.getActionCommand();

        if ("next".equals(arg)) {
            ((CardLayout) mainPanel.cards.getLayout()).next(mainPanel.cards);
        } else if ("previous".equals(arg)) {
            ((CardLayout) mainPanel.cards.getLayout()).previous(mainPanel.cards);
        }
    }

    @Override
    public void itemStateChanged(ItemEvent e) {
        ((CardLayout) mainPanel.cards.getLayout()).show(mainPanel.cards,
                (String) e.getItem());
    }

    public static void main(String args[]) {
        AppletFrame.startApplet("GraphicsTest", "Graphics Test", args);
    }

    @Override
    public String getAppletInfo() {
        return "An interactive demonstration of some graphics.";
    }
}   // end class GraphicsTest


@SuppressWarnings("serial")
class GraphicsCards extends Panel {

    public GraphicsCards() {
        setLayout(new CardLayout());
        add("Arc", new ArcCard());
        add("Oval", new ShapeTest(new OvalShape()));
        add("Polygon", new ShapeTest(new PolygonShape()));
        add("Rect", new ShapeTest(new RectShape()));
        add("RoundRect", new ShapeTest(new RoundRectShape()));
    }
}   // end class GraphicsCards


@SuppressWarnings("serial")
class ArcCard extends Panel {

    public ArcCard() {
        setLayout(new GridLayout(0, 2));
        add(new ArcPanel(true));
        add(new ArcPanel(false));
        add(new ArcDegreePanel(true));
        add(new ArcDegreePanel(false));
    }
}   // end class ArcCard


@SuppressWarnings("serial")
class ArcDegreePanel extends Panel {

    boolean filled;

    public ArcDegreePanel(boolean filled) {
        this.filled = filled;
    }

    void arcSteps(Graphics g,
            int step,
            int x,
            int y,
            int w,
            int h,
            Color c1,
            Color c2) {
        int a1 = 0;
        int a2 = step;
        int progress = 0;
        g.setColor(c1);
        for (; (a1 + a2) <= 360; a1 = a1 + a2, a2 += 1) {
            if (g.getColor() == c1) {
                g.setColor(c2);
            } else {
                g.setColor(c1);
            }

            if (filled) {
                g.fillArc(x, y, w, h, a1, a2);
            } else {
                g.drawArc(x, y, w, h, a1, a2);
            }

            progress = a1 + a2;
        }  // end for

        if (progress != 360) {
            if (filled) {
                g.fillArc(x, y, w, h, a1, 360 - progress);
            } else {
                g.drawArc(x, y, w, h, a1, 360 - progress);
            }
        }  // end if
    }  // end arcSteps()

    @Override
    public void paint(Graphics g) {
        Rectangle r = getBounds();

        arcSteps(g, 3, 0, 0, r.width, r.height, Color.orange, Color.blue);

        arcSteps(g,
                2,
                r.width / 4,
                r.height / 4,
                r.width / 2,
                r.height / 2,
                Color.yellow,
                Color.green);

        arcSteps(g,
                1,
                (r.width * 3) / 8,
                (r.height * 3) / 8,
                r.width / 4,
                r.height / 4,
                Color.magenta,
                Color.white);

    }  // end paint()
}   // end class ArcDegreePanel


@SuppressWarnings("serial")
class ArcPanel extends Panel {

    boolean filled;

    public ArcPanel(boolean filled) {
        this.filled = filled;
    }

    @Override
    public void paint(Graphics g) {
        Rectangle r = getBounds();

        g.setColor(Color.yellow);
        if (filled) {
            g.fillArc(0, 0, r.width, r.height, 0, 45);
        } else {
            g.drawArc(0, 0, r.width, r.height, 0, 45);
        }

        g.setColor(Color.green);
        if (filled) {
            g.fillArc(0, 0, r.width, r.height, 90, -45);
        } else {
            g.drawArc(0, 0, r.width, r.height, 90, -45);
        }

        g.setColor(Color.orange);
        if (filled) {
            g.fillArc(0, 0, r.width, r.height, 135, -45);
        } else {
            g.drawArc(0, 0, r.width, r.height, 135, -45);
        }

        g.setColor(Color.magenta);

        if (filled) {
            g.fillArc(0, 0, r.width, r.height, -225, 45);
        } else {
            g.drawArc(0, 0, r.width, r.height, -225, 45);
        }

        g.setColor(Color.yellow);
        if (filled) {
            g.fillArc(0, 0, r.width, r.height, 225, -45);
        } else {
            g.drawArc(0, 0, r.width, r.height, 225, -45);
        }

        g.setColor(Color.green);
        if (filled) {
            g.fillArc(0, 0, r.width, r.height, -135, 45);
        } else {
            g.drawArc(0, 0, r.width, r.height, -135, 45);
        }

        g.setColor(Color.orange);
        if (filled) {
            g.fillArc(0, 0, r.width, r.height, -45, -45);
        } else {
            g.drawArc(0, 0, r.width, r.height, -45, -45);
        }

        g.setColor(Color.magenta);
        if (filled) {
            g.fillArc(0, 0, r.width, r.height, 315, 45);
        } else {
            g.drawArc(0, 0, r.width, r.height, 315, 45);
        }

    }  // end paint()
}   // end class ArcPanel


abstract class Shape {

    abstract void draw(Graphics g, int x, int y, int w, int h);

    abstract void fill(Graphics g, int x, int y, int w, int h);
}


class RectShape extends Shape {

    @Override
    void draw(Graphics g, int x, int y, int w, int h) {
        g.drawRect(x, y, w, h);
    }

    @Override
    void fill(Graphics g, int x, int y, int w, int h) {
        g.fillRect(x, y, w, h);
    }
}


class OvalShape extends Shape {

    @Override
    void draw(Graphics g, int x, int y, int w, int h) {
        g.drawOval(x, y, w, h);
    }

    @Override
    void fill(Graphics g, int x, int y, int w, int h) {
        g.fillOval(x, y, w, h);
    }
}


class RoundRectShape extends Shape {

    @Override
    void draw(Graphics g, int x, int y, int w, int h) {
        g.drawRoundRect(x, y, w, h, 10, 10);
    }

    @Override
    void fill(Graphics g, int x, int y, int w, int h) {
        g.fillRoundRect(x, y, w, h, 10, 10);
    }
}


class PolygonShape extends Shape {
    // class variables

    Polygon p;
    Polygon pBase;

    public PolygonShape() {
        pBase = new Polygon();
        pBase.addPoint(0, 0);
        pBase.addPoint(10, 0);
        pBase.addPoint(5, 15);
        pBase.addPoint(10, 20);
        pBase.addPoint(5, 20);
        pBase.addPoint(0, 10);
        pBase.addPoint(0, 0);
    }

    void scalePolygon(float w, float h) {
        p = new Polygon();
        for (int i = 0; i < pBase.npoints; ++i) {
            p.addPoint((int) (pBase.xpoints[i] * w),
                    (int) (pBase.ypoints[i] * h));
        }

    }

    @Override
    void draw(Graphics g, int x, int y, int w, int h) {
        Graphics ng = g.create();
        try {
            ng.translate(x, y);
            scalePolygon(((float) w / 10f), ((float) h / 20f));
            ng.drawPolygon(p);
        } finally {
            ng.dispose();
        }
    }

    @Override
    void fill(Graphics g, int x, int y, int w, int h) {
        Graphics ng = g.create();
        try {
            ng.translate(x, y);
            scalePolygon(((float) w / 10f), ((float) h / 20f));
            ng.fillPolygon(p);
        } finally {
            ng.dispose();
        }
    }
}


@SuppressWarnings("serial")
class ShapeTest extends Panel {

    Shape shape;
    int step;

    public ShapeTest(Shape shape, int step) {
        this.shape = shape;
        this.step = step;
    }

    public ShapeTest(Shape shape) {
        this(shape, 10);
    }

    @Override
    public void paint(Graphics g) {
        Rectangle bounds = getBounds();

        int cx, cy, cw, ch;

        Color color;

        for (color = Color.red, cx = bounds.x, cy = bounds.y,
                cw = bounds.width / 2, ch = bounds.height;
                cw > 0 && ch > 0;
                cx += step, cy += step, cw -= (step * 2), ch -= (step * 2),
                color = ColorUtils.darker(color, 0.9)) {
            g.setColor(color);
            shape.draw(g, cx, cy, cw, ch);
        }

        for (cx = bounds.x + bounds.width / 2, cy = bounds.y,
                cw = bounds.width / 2, ch = bounds.height;
                cw > 0 && ch > 0;
                cx += step, cy += step, cw -= (step * 2), ch -= (step * 2)) {
            if (g.getColor() == Color.red) {
                g.setColor(Color.blue);
            } else {
                g.setColor(Color.red);
            }

            shape.fill(g, cx, cy, cw, ch);
        }  // end for
    }  // end paint()
}   // end class ShapeTest


class ColorUtils {

    static Color brighter(Color c, double factor) {
        return new Color(Math.min((int) (c.getRed() * (1 / factor)), 255),
                Math.min((int) (c.getGreen() * (1 / factor)), 255),
                Math.min((int) (c.getBlue() * (1 / factor)), 255));
    }

    static Color darker(Color c, double factor) {
        return new Color(Math.max((int) (c.getRed() * factor), 0),
                Math.max((int) (c.getGreen() * factor), 0),
                Math.max((int) (c.getBlue() * factor), 0));
    }
}