/* * * Copyright (c) 2007, Sun Microsystems, Inc. * * 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 Sun Microsystems 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. */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 {    /**     * 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 static final int[] speeds = { 999999999, 500, 250, 100, 0 };    /** 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;    /** Width and height of image */    private int 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) {