一个简单的定时器(flex版)

- 日理万妓 2022-04-01 11:20 178阅读 0赞

这个定时系统的UML类图如下：

![2007111901.jpg][]

AnalogClockFace类

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][ContractedBlock.gif] AnalogClockFace   
package com.example.programmingas3.clock  
\{  
import flash.display.Shape;  
import flash.display.Sprite;  
import flash.display.StageAlign;  
import flash.display.StageScaleMode;  
import flash.text.StaticText;  
import flash.events.\*;  
import flash.text.TextField;  
import flash.text.TextFormat;  
  
import mx.core.UIComponent;  
  
/\*\*  
\* Displays a round clock face with an hour hand, a minute hand, and a second hand.  
\*/  
publicclass AnalogClockFace extends UIComponent  
\{  
/\*\*  
\* The desired width of this component, as opposed to the .width  
\* property which represents tha actual width.  
\*/  
public var w:uint=200;  
  
/\*\*  
\* The desired height of this component, as opposed to the .height  
\* property which represents tha actual height.  
\*/  
public var h:uint=200;  
  
/\*\*  
\* The radius from the center of the clock to the  
\* outer edge of the circular face outline.  
\*/  
public var radius:uint;  
  
/\*\*  
\* The coordinates of the center of the face.  
\*/  
public var centerX:int;  
public var centerY:int;  
  
/\*\*  
\* The three hands of the clock.  
\*/  
public var hourHand:Shape;  
public var minuteHand:Shape;  
public var secondHand:Shape;  
  
/\*\*  
\* The colors of the background and each hand.  
\* These could be set using parameters or  
\* styles in the future.  
\*/  
public var bgColor:uint=0xEEEEFF;  
public var hourHandColor:uint=0x003366;  
public var minuteHandColor:uint=0x000099;  
public var secondHandColor:uint=0xCC0033;  
  
/\*\*  
\* Stores a snapshot of the current time, so it  
\* doesn't change while in the middle of drawing the  
\* three hands.  
\*/  
public var currentTime:Date;  
  
/\*\*  
\* Contructs a new clock face. The width and  
\* height will be equal.  
\*/  
public function AnalogClockFace(w:uint)  
\{  
this.w = w;  
this.h = w;  
  
// Rounds to the nearest pixel  
this.radius = Math.round(this.w /2);  
  
// The face is always square now, so the  
// distance to the center is the same  
// horizontally and vertically  
this.centerX =this.radius;  
this.centerY =this.radius;  
\}  
  
/\*\*  
\* Creates the outline, hour labels, and clock hands.  
\*/  
public function init():void  
\{  
// draws the circular clock outline  
 drawBorder();  
  
// draws the hour numbers  
 drawLabels();  
  
// creates the three clock hands  
 createHands();  
\}  
  
/\*\*  
\* Draws a circular border.  
\*/  
public function drawBorder():void  
\{  
graphics.lineStyle(0.5, 0x999999);  
graphics.beginFill(bgColor);  
graphics.drawCircle(centerX, centerY, radius);  
graphics.endFill();  
\}  
  
/\*\*  
\* Puts numeric labels at the hour points.  
\*/  
public function drawLabels():void  
\{  
for (var i:Number =1; i <=12; i\++)  
\{  
// Creates a new TextField showing the hour number  
 var label:TextField =new TextField();  
label.text = i.toString();  
  
// Places hour labels around the clock face.  
// The sin() and cos() functions both operate on angles in radians.  
 var angleInRadians:Number = i \*30\* (Math.PI/180)  
  
// Place the label using the sin() and cos() functions to get the x,y coordinates.  
// The multiplier value of 0.9 puts the labels inside the outline of the clock face.  
// The integer value at the end of the equation adjusts the label position,  
// since the x,y coordinate is in the upper left corner.  
 label.x = centerX \+ (0.9\* radius \* Math.sin( angleInRadians )) \-5;  
label.y = centerY \- (0.9\* radius \* Math.cos( angleInRadians )) \-9;  
  
// Formats the label text.  
 var tf:TextFormat =new TextFormat();  
tf.font ="Arial";  
tf.bold ="true";  
tf.size =12;  
label.setTextFormat(tf);  
  
// Adds the label to the clock face display list.  
 addChild(label);  
\}  
\}  
  
/\*\*  
\* Creates hour, minute, and second hands using the 2D drawing API.  
\*/  
public function createHands():void  
\{  
// Uses a Shape since it's the simplest component that supports  
// the 2D drawing API.  
 var hourHandShape:Shape =new Shape();  
drawHand(hourHandShape, Math.round(radius \*0.5), hourHandColor, 3.0);  
this.hourHand = Shape(addChild(hourHandShape));  
this.hourHand.x = centerX;  
this.hourHand.y = centerY;  
  
var minuteHandShape:Shape =new Shape();  
drawHand(minuteHandShape, Math.round(radius \*0.8), minuteHandColor, 2.0);  
this.minuteHand = Shape(addChild(minuteHandShape));  
this.minuteHand.x = centerX;  
this.minuteHand.y = centerY;  
  
var secondHandShape:Shape =new Shape();  
drawHand(secondHandShape, Math.round(radius \*0.9), secondHandColor, 0.5);  
this.secondHand = Shape(addChild(secondHandShape));  
this.secondHand.x = centerX;  
this.secondHand.y = centerY;  
\}  
  
/\*\*  
\* Draws a clock hand with a given size, color, and thickness.  
\*/  
public function drawHand(hand:Shape, distance:uint, color:uint, thickness:Number):void  
\{  
hand.graphics.lineStyle(thickness, color);  
hand.graphics.moveTo(0, distance);  
hand.graphics.lineTo(0, 0);  
\}  
  
/\*\*  
\* Called by the parent container when the display is being drawn.  
\*/  
public function draw():void  
\{  
// Stores the current date and time in an instance variable  
 currentTime =new Date();  
showTime(currentTime);  
\}  
  
/\*\*  
\* Displays the given Date/Time in that good old analog clock style.  
\*/  
public function showTime(time:Date):void  
\{  
// Gets the time values  
 var seconds:uint= time.getSeconds();  
var minutes:uint= time.getMinutes();  
var hours:uint= time.getHours();  
  
// Multiplies by 6 to get degrees  
this.secondHand.rotation =180\+ (seconds \*6);  
this.minuteHand.rotation =180\+ (minutes \*6);  
  
// Multiplies by 30 to get basic degrees, and then  
// adds up to 29.5 degrees (59 \* 0.5) to account  
// for the minutes  
this.hourHand.rotation =180\+ (hours \*30) \+ (minutes \*0.5);  
\}  
\}  
\}

SimpleClock类

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][ContractedBlock.gif] SimpleClock   
package com.example.programmingas3.clock  
\{  
import mx.core.UIComponent;  
  
publicclass SimpleClock extends UIComponent  
\{  
import com.example.programmingas3.clock.AnalogClockFace;  
import flash.events.TimerEvent;  
import flash.utils.Timer;  
  
/\*\*  
\* The time display component.  
\*/  
public var face:AnalogClockFace;  
  
/\*\*  
\* The Timer that acts like a heartbeat for the application.  
\*/  
public var ticker:Timer;  
  
publicstaticconst millisecondsPerMinute:int=1000\*60;  
publicstaticconst millisecondsPerHour:int=1000\*60\*60;  
publicstaticconst millisecondsPerDay:int=1000\*60\*60\*24;  
  
/\*\*  
\* Sets up a SimpleClock instance.  
\*/  
public function initClock(faceSize:Number =200):void  
\{  
// sets the invoice date to today’s date  
 var invoiceDate:Date =new Date();  
  
// adds 30 days to get the due date  
 var millisecondsPerDay:int=1000\*60\*60\*24;  
var dueDate:Date =new Date(invoiceDate.getTime() \+ (30\* millisecondsPerDay));  
  
var oneHourFromNow:Date =new Date(); // starts at the current time  
 oneHourFromNow.setTime(oneHourFromNow.getTime() \+ millisecondsPerHour);  
  
// Creates the clock face and adds it to the Display List  
 face =new AnalogClockFace(Math.max(20, faceSize));  
face.init();  
addChild(face);  
  
// Draws the initial clock display  
 face.draw();  
  
// Creates a Timer that fires an event once per second.  
 ticker =new Timer(1000);  
  
// Designates the onTick() method to handle Timer events  
 ticker.addEventListener(TimerEvent.TIMER, onTick);  
  
// Starts the clock ticking  
 ticker.start();  
\}  
  
/\*\*  
\* Called once per second when the Timer event is received.  
\*/  
public function onTick(evt:TimerEvent):void  
\{  
// Updates the clock display.  
 face.draw();  
\}  
\}  
\}

AlarmClock类

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][ContractedBlock.gif] AlarmClock   
package com.example.programmingas3.clock  
\{  
import mx.core.UIComponent;  
  
publicclass AlarmClock extends SimpleClock  
\{  
import com.example.programmingas3.clock.AnalogClockFace;  
import flash.events.TimerEvent;  
import flash.utils.Timer;  
  
public var alarmTime:Date;  
  
public var alarmMessage:String;  
  
/\*\*  
\* The Timer that will be used for the alarm.  
\*/  
public var alarmTimer:Timer;  
  
publicstatic var MILLISECONDS\_PER\_DAY:Number =1000\*60\*60\*24;  
  
/\*\*  
\* Instantiates a new AlarmClock of a given size  
\*/  
publicoverride function initClock(faceSize:Number =200):void  
\{  
super.initClock(faceSize);  
  
alarmTimer =new Timer(0, 1);  
alarmTimer.addEventListener(TimerEvent.TIMER, onAlarm);  
\}  
  
  
/\*\*  
\* Sets the time at which the alarm should go off.  
\* @param hour The hour portion of the alarm time  
\* @param minutes The minutes portion of the alarm time  
\* @param message The message to display when the alarm goes off.  
\* @return The time at which the alarm will go off.  
\*/  
public function setAlarm(hour:Number =0, minutes:Number =0, message:String ="Alarm!"):Date  
\{  
this.alarmMessage = message;  
  
var now:Date =new Date();  
  
// create this time on today's date  
 alarmTime =new Date(now.fullYear, now.month, now.date, hour, minutes);  
  
// determine if the specified time has already passed today  
if (alarmTime <= now)  
\{  
alarmTime.setTime(alarmTime.time \+ MILLISECONDS\_PER\_DAY);  
\}  
  
// reset the alarm timer if it's currently set  
 alarmTimer.reset();  
// calculate how many milliseconds should pass before the alarm should  
// go off (the difference between the alarm time and now) and set that  
// value as the delay for the alarm timer  
 alarmTimer.delay = Math.max(1000, alarmTime.time \- now.time);  
alarmTimer.start();  
  
return alarmTime;  
\}  
  
  
/\*\*  
\* Called when the Timer event is received  
\*/  
public function onAlarm(event:TimerEvent):void  
\{  
trace("Alarm!");  
var alarm:AlarmEvent =new AlarmEvent(this.alarmMessage);  
this.dispatchEvent(alarm);  
\}  
\}  
\}

AlarmEvent类

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][ContractedBlock.gif] AlarmEvent   
package com.example.programmingas3.clock  
\{  
import flash.events.Event;  
  
/\*\*  
\* This custom Event class adds a message property to a basic Event.  
\*/  
publicclass AlarmEvent extends Event  
\{  
/\*\*  
\* The name of the new AlarmEvent type.  
\*/  
publicstaticconst ALARM:String ="alarm";  
  
/\*\*  
\* A text message that can be passed to an event handler  
\* with this event object.  
\*/  
public var message:String;  
  
/\*\*  
\* Constructor.  
\* @param message The text to display when the alarm goes off.  
\*/  
public function AlarmEvent(message:String ="ALARM!")  
\{  
super(ALARM);  
  
this.message = message;  
\}  
  
  
/\*\*  
\* Creates and returns a copy of the current instance.  
\* @return A copy of the current instance.  
\*/  
publicoverride function clone():Event  
\{  
returnnew AlarmEvent(message);  
\}  
  
  
/\*\*  
\* Returns a String containing all the properties of the current  
\* instance.  
\* @return A string representation of the current instance.  
\*/  
publicoverride function toString():String  
\{  
return formatToString("AlarmEvent", "type", "bubbles", "cancelable", "eventPhase", "message");  
\}  
\}  
\}

页面AS脚本

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][ContractedBlock.gif] Code   
 import com.example.programmingas3.clock.AlarmEvent;  
  
  
public function initApp():void  
\{  
clock.addEventListener(AlarmEvent.ALARM, onAlarm);  
  
// Adds 60 seconds to the current time and preloads the alarm fields  
 var alarmTime:Date =new Date();  
alarmTime.setTime(alarmTime.time \+60000);  
hourNs.value = alarmTime.hours;  
minuteNs.value = alarmTime.minutes;  
\}  
  
public function setAlarm():void  
\{  
var alarmTime:Date = clock.setAlarm(hourNs.value, minuteNs.value, messageTxt.text);  
  
alarmTimeTxt.text ="Alarm Time:"\+ alarmTime.hours \+":"\+ padZeroes(alarmTime.minutes.toString());  
\}  
  
public function onAlarm(evt:AlarmEvent):void  
\{  
alarmTimeTxt.text = evt.message;  
\}  
  
public function padZeroes(numStr:String, desiredLength:uint=2):String  
\{  
if (numStr.length < desiredLength)  
\{  
for (var i:uint=0; i < (desiredLength \- numStr.length); i\++)  
\{  
numStr ="0"\+ numStr;  
\}  
\}  
return numStr;  
\}

运行结果：

![2007111902.jpg][]

[2007111901.jpg]: /images/20220401/d9268442455c4aeba3b3a8db46f1510c.png
[ContractedBlock.gif]: 
[2007111902.jpg]: /images/20220401/063e84c64bf044738a384b141a78c83f.png