/*
 * Copyright (c) 2000 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 2nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book (recommended),
 * visit http://www.davidflanagan.com/javaexamples2.
 */
package com.davidflanagan.examples.graphics;
import java.awt.*;
import java.awt.geom.*;
import java.awt.font.*;
import java.awt.image.*;

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

    public String getName() { return "Paints"; } // From GraphicsExample
    public int getWidth() { return WIDTH; }      // From GraphicsExample
    public int getHeight() { return HEIGHT; }    // From GraphicsExample

    /** Draw the example */
    public void draw(Graphics2D g, Component c) {
	// 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));

	// For the last letter, use a custom Paint class to fill with a 
	// complex mathematically defined pattern.  The GenericPaint
	// class is defined later in the chapter.
	g.setPaint(new GenericPaint() {
		public int computeRed(double x, double y) { return 128; }
		public int computeGreen(double x, double y) {
		    return (int)((Math.sin(x/7) + Math.cos(y/5) + 2)/4 *255);
		}
		public int computeBlue(double x, double y) {
		    return ((int)(x*y))%256;
		}
		public int computeAlpha(double x, double y) {
		    return ((int)x%25*8+50) + ((int)y%25*8+50);
		}
	    });
	g.fill(ashape);                // Fill letter A
	g.setPaint(Color.black);       // Revert to solid black
	g.draw(ashape);                // Draw the outline of the A
    }
}