时钟计时器

核心提示：*-- * AnimatedTimer - Main midlet. * Shows canvas with an animated timer. Includes * configuration options to start/stop the timer * and to adjust the sleep int

*--------------------------------------------------
 * AnimatedTimer - Main midlet.
 * Shows canvas with an animated timer. Includes
 * configuration options to start/stop the timer
 * and to adjust the sleep interval of the thread
 *
 * Example from the book:　　 Core J2ME Technology
 * Copyright John W. MUChow　 http://www.CoreJ2ME.com
 * You may use/modify for any non-commercial purpose 
 *-------------------------------------------------*/

import java.util.Stack;

import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Gauge;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.List;
import javax.microedition.midlet.MIDlet;

public class AnimatedTimer extends MIDlet {
　PRivate Display display; // The display

　protected TimerCanvas cvTimer; // Canvas to display timer

　protected OptionsList lsOptions; // List to change timer options

　protected SleepForm fmSleep; // Form with gauge to set timer sleep

　protected DisplayManager displayMgr; // Class to help manage screens

　public AnimatedTimer() {
　　display = Display.getDisplay(this);
　　cvTimer = new TimerCanvas(this);
　　lsOptions = new OptionsList("Timer options", List.IMPLICIT, this);
　　fmSleep = new SleepForm("Adjust sleep", this);

　　// Create a display manager object
　　displayMgr = new DisplayManager(display, cvTimer);
　}

　protected void startApp() {
　　// Start with the canvas
　　display.setCurrent(cvTimer);
　}

　protected void pauseApp() {
　}

　protected void destroyApp(boolean unconditional) {
　}

　public void exitMIDlet() {
　　destroyApp(true);
　　notifyDestroyed();
　}
}

/*--------------------------------------------------
 * Use a stack to push and pop displayable objects
 *
 * public void pushDisplayable(Displayable)
 * public void popDisplayable()
 * public void home()　
 *
 * Example from the book:　　 Core J2ME Technology
 * Copyright John W. Muchow　 http://www.CoreJ2ME.com
 * You may use/modify for any non-commercial purpose 
 *-------------------------------------------------*/

class DisplayManager extends Stack {
　private Display display; // Reference to Display object

　private Displayable mainDisplayable; // Main displayable for MIDlet

　private Alert alStackError; // Alert for error conditions

　/*--------------------------------------------------
　 * Display manager constructor
　 *-------------------------------------------------*/
　public DisplayManager(Display display, Displayable mainDisplayable) {
　　// Only one display object per midlet, this is it
　　this.display = display;
　　this.mainDisplayable = mainDisplayable;

　　// Create an alert displayed when an error occurs
　　alStackError = new Alert("Displayable Stack Error");
　　alStackError.setTimeout(Alert.FOREVER); // Modal
　}

　/*--------------------------------------------------
　 * Push the current displayable onto stack and set
　 * the passed in displayable as active
　 *-------------------------------------------------*/
　public void pushDisplayable(Displayable newDisplayable) {
　　push(display.getCurrent());
　　display.setCurrent(newDisplayable);
　}

　/*--------------------------------------------------
　 * Return to the main displayable object of MIDlet
　 *-------------------------------------------------*/
　public void home() {
　　while (elementCount > 1)
　　　pop();
　　display.setCurrent(mainDisplayable);
　}

　/*--------------------------------------------------
　 * Pop displayable from stack and set as active
　 *-------------------------------------------------*/
　public void popDisplayable() {
　　// If the stack is not empty, pop next displayable
　　if (empty() == false)
　　　display.setCurrent((Displayable) pop());
　　else
　　　// On error show an alert
　　　// Once acknowledged, set 'mainDisplayable' as active
　　　display.setCurrent(alStackError, mainDisplayable);
　}
}

/*--------------------------------------------------
 * Class TimerCanvas
 *
 * Animate a sequence of images to simulate 
 * a moving timer
 *
 * Example from the book:　　 Core J2ME Technology
 * Copyright John W. Muchow　 http://www.CoreJ2ME.com
 * You may use/modify for any non-commercial purpose 
 *-------------------------------------------------*/

class TimerCanvas extends Canvas implements Runnable, CommandListener {
　private AnimatedTimer midlet; // Main midlet

　private Command cmExit; // Exit midlet

　private Command cmOptions; // Display options list

　private Image im = null; // Sequence of images

　private int imageCount = 4; // Four images in the sequence

　private int imageWidth; // Width of one image in the sequence

　private int imageHeight; // Height of one image in the sequence

　private int imageIndex; // Current image in the sequence

　private int translate_x; // Translated x and y

　private int translate_y;

　private int viewport_x; // Location of the viewport

　private int viewport_y;

　private boolean active = false; // Timer active?

　private boolean requestedToStop = false; // Did user request to stop timer

　private int sleepTime = 400; // Current sleep time (milliseconds)

　public TimerCanvas(AnimatedTimer midlet) {
　　// Call canvas constructor
　　super();

　　// Save reference to MIDlet so we can
　　// access the display manager class
　　this.midlet = midlet;

　　// Create commands & listen for events
　　cmExit = new Command("Exit", Command.EXIT, 1);
　　cmOptions = new Command("Config", Command.SCREEN, 2);
　　addCommand(cmExit);
　　addCommand(cmOptions);
　　setCommandListener(this);
　}

　/*--------------------------------------------------
　 * application manager is about to display canvas
　 *-------------------------------------------------*/
　protected void showNotify() {
　　if (im == null) {
　　　try {
　　　　// Read the png from a file and get width and
　　　　// height of one image in the sequence
　　　　im = Image.createImage("/timer.png");
　　　　imageHeight = im.getHeight();
　　　　imageWidth = im.getWidth() / imageCount;

　　　　// Get the coordinates for x/y of viewport
　　　　// Viewport is centered on the display
　　　　viewport_x = (getWidth() / 2) - (imageWidth / 2);
　　　　viewport_y = (getHeight() / 2) - (imageHeight / 2);

　　　　// Set first translated coordinate to match viewport
　　　　translate_x = viewport_x;
　　　　translate_y = viewport_y;
　　　} catch (Exception e) {
　　　　System.err.println("Unable to read png file.");
　　　}

　　　// Begin with the first image in the sequence
　　　imageIndex = 0;
　　}

　　// If the user has not requested to stop the timer...
　　if (!requestedToStop)
　　　active = true;

　　new Thread(this).start();
　}

　/*--------------------------------------------------
　 * Application manager is no longer displaying canvas
　 *-------------------------------------------------*/
　protected void hideNotify() {
　　active = false;
　}

　/*--------------------------------------------------
　 * Draw next timer in sequence
　 *-------------------------------------------------*/
　protected void paint(Graphics g) {
　　if (im != null) {
　　　// Due to a bug in MIDP 1.0.3 we need to
　　　// force a clear of the display
　　　g.setColor(255, 255, 255); // White pen
　　　g.fillRect(0, 0, getWidth(), getHeight());
　　　g.setColor(0, 0, 0); // Black pen

　　　// Viewport at center of display
　　　g.setClip(viewport_x, viewport_y, imageWidth, imageHeight);

　　　// Draw image at translated coordinates
　　　g.drawImage(im, translate_x, translate_y, Graphics.TOP
　　　　　 Graphics.LEFT);
　　}
　}

　/*--------------------------------------------------
　 * Loop forever, translating image coordinates
　 *-------------------------------------------------*/
　public void run() {
　　try {
　　　while (active) {
　　　　Thread.sleep(sleepTime);
　　　　repaint();

　　　　// Reached the last image in sequence
　　　　if (imageIndex == imageCount - 1) {
　　　　　// Reset translated coordinates
　　　　　translate_x = viewport_x;
　　　　　translate_y = viewport_y;
　　　　} else {
　　　　　// Translate coordinate system to the left
　　　　　translate_x -= imageWidth;
　　　　}

　　　　// Which image in the sequence is next
　　　　imageIndex = (imageIndex + 1) % imageCount;
　　　}
　　} catch (InterruptedException e) {
　　}
　}

　/*--------------------------------------------------
　 * Called from the "Config" options menu
　 *-------------------------------------------------*/
　public void startTimer() {
　　requestedToStop = false;
　　active = true;
　　repaint();
　}

　/*--------------------------------------------------
　 * Called from the "Config" options menu
　 *-------------------------------------------------*/
　public void stopTimer() {
　　requestedToStop = true;
　　active = false;
　　repaint();
　}

　/*--------------------------------------------------
　 * Called from form/gauge to adjust sleep
　 *-------------------------------------------------*/
　public void setSleep(int sleepTime) {
　　this.sleepTime = sleepTime;
　}

　/*--------------------------------------------------
　 * Called from form/gauge to adjust sleep
　 *-------------------------------------------------*/
　public int getSleep() {
　　return sleepTime;
　}

　/*--------------------------------------------------
　 * Command event handling
　 *-------------------------------------------------*/
　public void commandAction(Command c, Displayable s) {
　　if (c == cmOptions) {
　　　// Push current displayable and show the options list
　　　midlet.displayMgr.pushDisplayable(midlet.lsOptions);
　　} else if (c == cmExit) {
　　　midlet.exitMIDlet();
　　}
　}
}

/*--------------------------------------------------
 * Class SleepForm
 *
 * Form with gauge to adjust sleep interval of timer
 *
 * Example from the book:　　 Core J2ME Technology
 * Copyright John W. Muchow　 http://www.CoreJ2ME.com
 * You may use/modify for any non-commercial purpose 
 *-------------------------------------------------*/

class SleepForm extends Form implements CommandListener {
　private AnimatedTimer midlet; // Main midlet

　private Command cmBack, // Back to options list
　　　cmHome, // Go to main displayable (canvas)
　　　cmSave; // Save new sleep time

　private Gauge gaSleep; // Gauge to adjust sleep

　public SleepForm(String title, AnimatedTimer midlet) {
　　// Call the form constructor
　　super(title);

　　// Save reference to MIDlet so we can
　　// access the display manager class
　　this.midlet = midlet;

　　// Commands
　　cmSave = new Command("Save", Command.SCREEN, 1);
　　cmBack = new Command("Back", Command.BACK, 2);
　　cmHome = new Command("Home", Command.SCREEN, 2);

　　// Gauge to adjust the length of timer sleep
　　gaSleep = new Gauge("Timer Sleep", true, 100, 1000);

　　// Set to current sleep. Gauge holds values 0 to 100,
　　// divide the current sleep (milliseconds) by 10
　　gaSleep.setValue(midlet.cvTimer.getSleep() / 10);

　　// Add to form and listen for events
　　append(gaSleep);
　　addCommand(cmSave);
　　addCommand(cmBack);
　　addCommand(cmHome);
　　setCommandListener(this);
　}

　/*--------------------------------------------------
　 * Command event handling
　 *-------------------------------------------------*/
　public void commandAction(Command c, Displayable s) {
　　if (c == cmSave) {
　　　// Gauge returns a value between 0 and 100
　　　// We want milliseconds, so multiply by 10
　　　midlet.cvTimer.setSleep(gaSleep.getValue() * 10);

　　　// Return to main midlet
　　　midlet.displayMgr.home();

　　} else if (c == cmBack) {
　　　// Pop the last displayable off the stack
　　　midlet.displayMgr.popDisplayable();
　　} else if (c == cmHome) {
　　　// Return to main midlet
　　　midlet.displayMgr.home();
　　}
　}
}

/*--------------------------------------------------
 * Class OptionsList
 *
 * List to provide options for configuring of timer
 *
 * Example from the book:　　 Core J2ME Technology
 * Copyright John W. Muchow　 http://www.CoreJ2ME.com
 * You may use/modify for any non-commercial purpose 
 *-------------------------------------------------*/

class OptionsList extends List implements CommandListener {
　private AnimatedTimer midlet; // Main midlet

　private Command cmBack;

　public OptionsList(String title, int listType, AnimatedTimer midlet) {
　　// Call list constructor
　　super(title, listType);

　　// Save reference to MIDlet so we can
　　// access the display manager class
　　this.midlet = midlet;

　　// Create the list entries
　　append("Sleep interval", null);
　　append("Start", null);
　　append("Stop", null);

　　// Create command and listen for events
　　cmBack = new Command("Back", Command.BACK, 1);
　　addCommand(cmBack);
　　setCommandListener(this);
　}

　/*--------------------------------------------------
　 * Command event handling
　 *-------------------------------------------------*/
　public void commandAction(Command c, Displayable s) {
　　// Event generated by the implicit list
　　if (c == List.SELECT_COMMAND) {
　　　switch (getSelectedIndex()) {
　　　case 0:
　　　　// Push current displayable and show the form
　　　　// to adjust the timer sleep
　　　　midlet.displayMgr.pushDisplayable(midlet.fmSleep);
　　　　break;

　　　case 1:
　　　　// Start timer and return to previous displayable
　　　　midlet.cvTimer.startTimer();
　　　　midlet.displayMgr.popDisplayable();
　　　　break;

　　　case 2:
　　　　// Stop timer and return to previous displayable
　　　　midlet.cvTimer.stopTimer();
　　　　midlet.displayMgr.popDisplayable();
　　　　break;
　　　}
　　} else if (c == cmBack) {
　　　// Return to previous displayable
　　　midlet.displayMgr.popDisplayable();
　　}
　}
}

（出处：http://www.cncms.com）