/*
 * @(#)PhotoFrame.java	1.4 04/01/27
 *
 * Copyright (c) 2000-2004 Sun Microsystems, Inc. All rights reserved. 
 * PROPRIETARY/CONFIDENTIAL
 * Use is subject to license terms
 */

package example.photoalbum;

import java.util.Vector;
import javax.microedition.lcdui.*;

/**
 * This PhotoFrame provides the picture frame and drives the animation
 * of the frames and the picture. It handles the starting and stopping
 * of the Animation and contains the Thread used to do
 * the timing and requests that the Canvas be repainted
 * periodically.
 * It controls the border style and animation speed.
 */
class PhotoFrame extends Canvas implements Runnable {

    /** border style */
    private int style;
    /** animation speed set */
    private int speed;

    /** Vector of images to display */
    private Vector images;
    /** Index of next image to display */
    private int index;
    /** X offset of image in frame */
    private int imageX;
    /** X offset of image in frame */
    private int imageY;
    /** Width and height of image */
    private int imageWidth, imageHeight;
    
    /** Thread used for triggering repaints */
    private Thread thread;
    /** buffer image of the screen */
    private Image image;
    /** Pattern image used for border */
    private Image bimage;
    /** Time of most recent paint */
    private long paintTime; 
    /** Time of most recent frame rate report */
    private long statsTime;
    /** Number of frames since last frame rate report */
    int frameCount;
    /** Last reported frame rate (for re-paint) */
    int frameRate;

    /**
     * Create a new PhotoFrame.
     * Create an offscreen mutable image into which the border is drawn.
     * Border style is none (0).
     * Speed is stopped (0) until set.
     */
    PhotoFrame() {
        image = Image.createImage(getWidth(), getHeight());
        setStyle(0);
        setSpeed(0);
    }
    
    /**
     * Set the array of images to be displayed.
     * Update the width and height of the image and draw
     * the border to fit around it in the offscreen image.
     * @param images a vector of images to be displayed.
     */
    void setImages(Vector images) {
        this.images = images;
        if (images.size() > 0) {
            Image image = (Image)images.elementAt(0);
            imageWidth = image.getWidth();
            imageHeight = image.getHeight();
        } else {
            imageWidth = 0;
            imageHeight = 0;
        }
	index = 0;
        imageX = (getWidth() - imageWidth) / 2;
        imageY = (getHeight() - imageHeight) / 2;
        genFrame(style, imageX, imageY, imageWidth, imageHeight);
    }

    /**
     * Advance to the next image and wrap around if necessary.
     */
    void next() {
        if (images == null || ++index >= images.size()) {
            index = 0;
        } 
    }

    /**
     * Back up to the previous image.
     * Wrap around to the end if at the beginning.
     */
    void previous() {
        if (images != null && --index < 0) {
            index = images.size()-1;
        } else {
	    index = 0;
	}
    }
 
    /**
     * Reset the PhotoFrame so it holds minimal resources.
     * The animation thread is stopped.
     */
    void reset() {
        images = null;
        thread = null;
    }

    /**
     * Handle key events. FIRE events toggle between
     * running and stopped.  LEFT and RIGHT key events
     * when stopped show the previous or next image.
     * @param keyCode of the key pressed
     */
    protected void keyPressed(int keyCode) {
        int action = getGameAction(keyCode);
        switch (action) {
        case RIGHT:
	    if (thread == null) {
		next();
		repaint();
	    }
            break;
        case LEFT:
	    if (thread == null) {
		previous();
		repaint();
	    }
            break;
        case FIRE:
            // Use FIRE to toggle the activity of the thread
            if (thread == null) {
                thread = new Thread(this);
                thread.start();
            } else {
                synchronized (this) {
                    // Wake up the thread to change the timing
                    this.notify();
                }
                // Shouldn't be in synchronized block
                thread = null;
            }
            break;
        }
    }
    
    /**
     * Handle key repeat events as regular key events.
     * @param keyCode of the key repeated
     */
    protected void keyRepeated(int keyCode) {
        keyPressed(keyCode);
    }

    /**
     * Set the animation speed.
     * Speed:
     * <OL>
     * <LI>0 = stop
     * <LI>1 = slow
     * <LI>2 = medium
     * <LI>3 = fast
     * <LI>4 = unlimited
     * </OL>
     * @param speed speedo of animation 0-3;
     */
    void setSpeed(int speed) {
	this.speed = speed;
	statsTime = 0;
    }

    /**
     * Get the speed at which animation occurs.
     * @return the current speed.
     * @see setSpeed
     */
    int getSpeed() {
        return speed;
    }

    /**
     * Set the frame style.
     * Recreate the photo frame image from the current style
     * and location and size
     * <p>
     * Style:
     * <OL>
     * <LI> Style 0: No border is drawn.
     * <LI> Style 1: A simple border is drawn
     * <LI> Style 2: The border is outlined and an image
     * is created to tile within the border.
     * </OL>
     * @param style the style of the border; 0 = none, 1 = simple,
     * 2 = fancy.
     */
    void setStyle(int style) {
	this.style = style;
        genFrame(style, imageX, imageY, imageWidth, imageHeight);
    }

    /**
     * Get the style being used for borders.
     * @return the style.
     */
    int getStyle() {
        return style;
    }

    /**
     * Notified when Canvas is made visible.
     * If there is more than one image to display
     * create the thread to run the animation timing.
     */
    protected void showNotify() {
        if (images != null && images.size() > 1) {
            thread = new Thread(this);
            thread.start();
        }
    }

    /**
     * Notified when the Canvas is no longer visible.
     * Signal the running Thread that it should stop.
     */
    protected void hideNotify() {
        thread = null;
    }

    
    /**
     * Return true if the specified rectangle does not intersect
     * the clipping rectangle of the graphics object.  If it returns
     * true then the object must be drawn otherwise it would be clipped
     * completely.
     * The checks are done
     * @param g the Graphics context to check.
     * @param x the x value of the upper left corner of the rectange
     * @param y the y value of the upper left corner of the rectange
     * @param w the width of the rectangle
     * @param h the height of the rectangle
     * @return true if the rectangle intersects the clipping region
     */
    boolean intersectsClip(Graphics g, int x, int y, int w, int h) {
        int cx = g.getClipX();
        if (x + w <= cx)
            return false;

        int cw = g.getClipWidth();
        if (x > cx + cw)
            return false;

        int cy = g.getClipY();
        if (y + h <= cy)
            return false;

        int ch = g.getClipHeight();
        if (y > cy + ch)
            return false;
        return true;
    }

    /**
     * Runs the animation and makes the repaint requests.
     * The thread will exit when it is no longer the current
     * Animation thread.
     */
    public void run() {
        Thread mythread = Thread.currentThread();
        long scheduled = System.currentTimeMillis();
	statsTime = scheduled;
        paintTime = scheduled;
	frameCount = 0;
	frameRate = 0;

        /*
         * The following code was changed to fix bug 4918599.
         * The bug is caused by a deadlock caused by
         * bad-designed use of synchronized blocks in demo.
         */
         while (thread == mythread) {
             
             // Update when the next frame should be drawn
             // and compute the delta till then
             scheduled += speeds[speed];
             long delta = scheduled - paintTime;
             
             if (delta > 0)  {
                 synchronized (this) {
                     try {
                        this.wait(delta);
                     } catch (InterruptedException e) {
                     }
                 }
             }
             
             // Advance and repaint the screen
             next();
             repaint();
             serviceRepaints();
         }
    }

    /** 
     * Paint is called whenever the canvas should be redrawn.
     * It clears the canvas and draws the frame and the current 
     * current frame from the animation.
     * @param g the Graphics context to which to draw
     */
    protected void paint(Graphics g) {
	paintTime = System.currentTimeMillis();
	if (image != null) {
	    
	    // Draw the frame unless only the picture is being re-drawn
	    // This is the inverse of the usual clip check.
	    int cx = 0, cy = 0, cw = 0, ch = 0;
	    if ((cx = g.getClipX()) < imageX || 
		(cy = g.getClipY()) < imageY ||
		(cx + (cw = g.getClipWidth())) > (imageX + imageWidth) ||
		(cy + (ch = g.getClipHeight())) > (imageY + imageHeight)) {
		g.drawImage(image, 0, 0, Graphics.LEFT|Graphics.TOP);
		if (frameRate > 0) {
		    g.fillRect(0, getHeight(), 60, 20);
		    g.drawString("FPS = " + frameRate, 0, getHeight(), 
				 Graphics.BOTTOM|Graphics.LEFT);
		}
	    }

	    // Draw the image if it intersects the clipping region
	    if (images != null &&
		index < images.size() &&
		intersectsClip(g, imageX, imageY, imageWidth, imageHeight)) {
		g.drawImage((Image)images.elementAt(index),
			    imageX, imageY, Graphics.LEFT|Graphics.TOP);
	    }
	    frameCount++;


	    // Update Frame rate
	    int delta = (int)(paintTime - statsTime);
	    if (delta > 1000 && delta < 10000) {
		frameRate = ((frameCount * 1000 + 500) / delta);
		frameCount = 0;
		statsTime = paintTime;
		repaint();	// queue full repaint to display frame rate
	    }
	}
    }
    
    /**
     * Paint the photo frame into the buffered screen image.
     * This will avoid drawing each of its parts on each repaint.
     * Paint will only need to put the image into the frame.
     * @param style the style of frame to draw.
     * @param x the x offset of the image.
     * @param y the y offset of the image
     * @param width the width of the anmiation image
     * @param height the height of the animation image
     */
    private void genFrame(int style, int x, int y, int width, int height) {
        Graphics g = image.getGraphics();

        // Clear the entire image to white
        g.setColor(0xffffff);
        g.fillRect(0, 0, image.getWidth()+1, image.getHeight()+1);
        
        // Set the origin of the image and paint the border and image.
        g.translate(x, y);
        paintBorder(g, style, width, height);
    }

    /**
     * Draw a border of the selected style.
     * @param g graphics context to which to draw.
     * @param style of the border to display
     * @param w the width reserved for the image
     * @param h the height reserved of the image
     * @see setStyle
     */
    private void paintBorder(Graphics g, int style, int w, int h) {
	if (style == 1) {
	    g.setGrayScale(128);
	    g.drawRect(-1, -1, w + 1, h + 1);
	    g.drawRect(-2, -2, w + 3, h + 3);
	}

	if (style == 2) {
            // Draw fancy border with image between outer and inner rectangles
            if (bimage == null) 
                bimage = genBorder();          // Generate the border image
	    int bw = bimage.getWidth();
	    int bh = bimage.getHeight();
	    int i;
            // Draw the inner and outer solid border
	    g.setGrayScale(128);
	    g.drawRect(-1, -1, w + 1, h + 1);
	    g.drawRect(-bw - 2, -bh - 2, w + bw * 2 + 3, h + bh * 2 + 3);

            // Draw it in each corner
            g.drawImage(bimage, -1, -1, Graphics.BOTTOM|Graphics.RIGHT);
 	    g.drawImage(bimage, -1, h + 1, Graphics.TOP|Graphics.RIGHT);
	    g.drawImage(bimage, w + 1, -1, Graphics.BOTTOM|Graphics.LEFT);
	    g.drawImage(bimage, w + 1, h + 1, Graphics.TOP|Graphics.LEFT);

            // Draw the embedded image down left and right sides
            for (i = ((h % bh) / 2); i < h - bh; i += bh) {
		g.drawImage(bimage, -1, i, Graphics.RIGHT|Graphics.TOP);
		g.drawImage(bimage, w + 1, i, Graphics.LEFT|Graphics.TOP);
	    }
            // Draw the embedded image across the top and bottom
	    for (i = ((w % bw) / 2); i < w - bw; i += bw) {
		g.drawImage(bimage, i, -1, Graphics.LEFT|Graphics.BOTTOM);
		g.drawImage(bimage, i, h + 1, Graphics.LEFT|Graphics.TOP);
	    }
	}
    }

    /**
     * Create an image for the border.
     * The border consists of a simple "+" drawn in a 5x5 image.
     * Fill the image with white and draw the "+" as magenta.
     * @return the image initialized with the pattern
     */
    private Image genBorder() {
        Image image = Image.createImage(5, 5);
        Graphics g = image.getGraphics();
        g.setColor(255, 255, 255);
        g.fillRect(0, 0, 5, 5);
        g.setColor(128, 0, 255);
        g.drawLine(2, 1, 2, 3); // vertical
        g.drawLine(1, 2, 3, 2); // horizontal
        return image;
    }

    /**
     * Mapping of speed values to delays in ms.
     * Indices map to those in the speed ChoiceGroup in the options form.
     * The indices are: 0 = stop, 1 = slow, 2 = medium, 3 = fast.
     * @see setSpeed
     */
    private final static int speeds[] = {999999999, 500, 250, 100, 0};
}
