/*
 * Copyright (c) 2007-2010 by The Broad Institute, Inc. and the Massachusetts Institute of Technology.
 * All Rights Reserved.
 *
 * This software is licensed under the terms of the GNU Lesser General Public License (LGPL), Version 2.1 which
 * is available at http://www.opensource.org/licenses/lgpl-2.1.php.
 *
 * THE SOFTWARE IS PROVIDED "AS IS." THE BROAD AND MIT MAKE NO REPRESENTATIONS OR WARRANTIES OF
 * ANY KIND CONCERNING THE SOFTWARE, EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT
 * OR OTHER DEFECTS, WHETHER OR NOT DISCOVERABLE.  IN NO EVENT SHALL THE BROAD OR MIT, OR THEIR
 * RESPECTIVE TRUSTEES, DIRECTORS, OFFICERS, EMPLOYEES, AND AFFILIATES BE LIABLE FOR ANY DAMAGES OF
 * ANY KIND, INCLUDING, WITHOUT LIMITATION, INCIDENTAL OR CONSEQUENTIAL DAMAGES, ECONOMIC
 * DAMAGES OR INJURY TO PROPERTY AND LOST PROFITS, REGARDLESS OF WHETHER THE BROAD OR MIT SHALL
 * BE ADVISED, SHALL HAVE OTHER REASON TO KNOW, OR IN FACT SHALL KNOW OF THE POSSIBILITY OF THE
 * FOREGOING.
 */

/*
 * Paints.java
 *
 * Created on November 17, 2007, 10:54 AM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package demos;

import javax.swing.*;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.font.GlyphVector;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;

/**
 * A demonstration of Java2D transformations
 */
public class Paints extends JPanel {
    static final int WIDTH = 800, HEIGHT = 375; // Size of our example

    public String getName() {
        return "Paints";
    }

    public int getWidth() {
        return WIDTH;
    }

    public int getHeight() {
        return HEIGHT;
    }

    /**
     * Draw the example
     */
    public void paint(Graphics g1) {
        Graphics2D g = (Graphics2D) g1;
        // Paint the entire background using a GradientPaint.
        // The background color varies diagonally from deep red to pale blue
        g.setPaint(new GradientPaint(0, 0, new Color(150, 0, 0), WIDTH, HEIGHT,
                new Color(200, 200, 255)));
        g.fillRect(0, 0, WIDTH, HEIGHT); // fill the background

        // Use a different GradientPaint to draw a box.
        // This one alternates between deep opaque green and transparent green.
        // Note: the 4th arg to Color() constructor specifies color opacity
        g.setPaint(new GradientPaint(0, 0, new Color(0, 150, 0), 20, 20,
                new Color(0, 150, 0, 0), true));
        g.setStroke(new BasicStroke(15)); // use wide lines
        g.drawRect(25, 25, WIDTH - 50, HEIGHT - 50); // draw the box

        // The glyphs of fonts can be used as Shape objects, which enables
        // us to use Java2D techniques with letters Just as we would with
        // any other shape. Here we get some letter shapes to draw.
        Font font = new Font("Serif", Font.BOLD, 10); // a basic font
        Font bigfont = // a scaled up version
                font.deriveFont(AffineTransform.getScaleInstance(30.0, 30.0));
        GlyphVector gv = bigfont.createGlyphVector(g.getFontRenderContext(),
                "JAV");
        Shape jshape = gv.getGlyphOutline(0); // Shape of letter J
        Shape ashape = gv.getGlyphOutline(1); // Shape of letter A
        Shape vshape = gv.getGlyphOutline(2); // Shape of letter V

        // We're going to outline the letters with a 5-pixel wide line
        g.setStroke(new BasicStroke(5.0f));

        // We're going to fake shadows for the letters using the
        // following Paint and AffineTransform objects
        Paint shadowPaint = new Color(0, 0, 0, 100); // Translucent black
        AffineTransform shadowTransform = AffineTransform.getShearInstance(
                -1.0, 0.0); // Shear to the right
        shadowTransform.scale(1.0, 0.5); // Scale height by 1/2

        // Move to the baseline of our first letter
        g.translate(65, 270);

        // Draw the shadow of the J shape
        g.setPaint(shadowPaint);
        g.translate(15, 20); // Compensate for the descender of the J
        // transform the J into the shape of its shadow, and fill it
        g.fill(shadowTransform.createTransformedShape(jshape));
        g.translate(-15, -20); // Undo the translation above

        // Now fill the J shape with a solid (and opaque) color
        g.setPaint(Color.blue); // Fill with solid, opaque blue
        g.fill(jshape); // Fill the shape
        g.setPaint(Color.black); // Switch to solid black
        g.draw(jshape); // And draw the outline of the J

        // Now draw the A shadow
        g.translate(75, 0); // Move to the right
        g.setPaint(shadowPaint); // Set shadow color
        g.fill(shadowTransform.createTransformedShape(ashape)); // draw shadow

        // Draw the A shape using a solid transparent color
        g.setPaint(new Color(0, 255, 0, 125)); // Transparent green as paint
        g.fill(ashape); // Fill the shape
        g.setPaint(Color.black); // Switch to solid back
        g.draw(ashape); // Draw the outline

        // Move to the right and draw the shadow of the letter V
        g.translate(175, 0);
        g.setPaint(shadowPaint);
        g.fill(shadowTransform.createTransformedShape(vshape));

        // We're going to fill the next letter using a TexturePaint, which
        // repeatedly tiles an image. The first step is to obtain the image.
        // We could load it from an image file, but here we create it
        // ourselves by drawing a into an off-screen image. Note that we use
        // a GradientPaint to fill the off-screen image, so the fill pattern
        // combines features of both Paint classes.
        BufferedImage tile = // Create an image
                new BufferedImage(50, 50, BufferedImage.TYPE_INT_RGB);
        Graphics2D tg = tile.createGraphics(); // Get its Graphics for drawing
        tg.setColor(Color.pink);
        tg.fillRect(0, 0, 50, 50); // Fill tile background with pink
        tg.setPaint(new GradientPaint(40, 0, Color.green, // diagonal gradient
                0, 40, Color.gray)); // green to gray
        tg.fillOval(5, 5, 40, 40); // Draw a circle with this gradient

        // Use this new tile to create a TexturePaint and fill the letter V
        g.setPaint(new TexturePaint(tile, new Rectangle(0, 0, 50, 50)));
        g.fill(vshape); // Fill letter shape
        g.setPaint(Color.black); // Switch to solid black
        g.draw(vshape); // Draw outline of letter

        // Move to the right and draw the shadow of the final A
        g.translate(160, 0);
        g.setPaint(shadowPaint);
        g.fill(shadowTransform.createTransformedShape(ashape));


        g.fill(ashape); // Fill letter A
        g.setPaint(Color.black); // Revert to solid black
        g.draw(ashape); // Draw the outline of the A
    }

    public static void main(String[] a) {
        JFrame f = new JFrame();
        f.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        f.setContentPane(new Paints());
        f.setSize(800, 375);
        f.setVisible(true);
    }
}
