/* * * Copyright ? 2007 Sun Microsystems, Inc. All rights reserved. * 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 {    /**     * 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) {        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 rectangle     * @param y the y value of the upper left corner of the rectangle     * @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;            // Draw the frame unless only the picture is being re-drawn            // This is the inverse of the usual clip check.            int cy = 0;            // Draw the frame unless only the picture is being re-drawn            // This is the inverse of the usual clip check.            int cw = 0;            // Draw the frame unless only the picture is being re-drawn            // This is the inverse of the usual clip check.            int 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 animation 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;    }}