// stop the timeline
stop();

// first get this current year so this example
// remains valid for some time to come
currentDate = new Date();
thisYear = currentDate.getFullYear();

// define the event date counting down to
// this is constant so it won't need to be
// calculated in the onEnterFrame function below
// currently counting down 'til 1st jenuary 2008
// Date( year, month-1, date [, hour [, minute [, second [, millisecond]]]])
// ITA: in questo esempio la data evento č il primo gennaio 2008
// Puoi modificare la data ricordando che al numero del mese devi sottrarre 1
eventDate = new Date(2008, 00, 01);
eventMillisecs = eventDate.getTime();

counter.onEnterFrame = function(){
	// get the current date and time as it exists at
	// this instance in time when the frame is entered
	currentDate = new Date();
	currentMillisecs = currentDate.getTime();
	
	// the milliseconds between the current time and the
	// time of the event can then be calculated by simply
	// subtracting the current time's milliseconds from the
	// milliseconds of the time of the event
	this.msecs = eventMillisecs - currentMillisecs;
	
	// if the msecs variable is less than 0, that means the
	// current time is greater that the time of the event
	if (this.msecs <= 0){
		// and the event time has been reached!
		// play the next frame for the result of the countdown.
		// ITA: raggiunta la data evento verrā riprodotto il frame successivo
		play();
		// a return can be used to exit the function since
		// in going to the next frame, there's no need to
		// continue with the remaining operations.
		return;
	}
	
	// if the date hasn't been reached, continue to
	// devise seconds, minutes, hours and days from
	// the calculated milliseconds
	this.secs = Math.floor(this.msecs/1000); // 1000 milliseconds make a second
	this.mins = Math.floor(this.secs/60); // 60 seconds make a minute
	this.hours = Math.floor(this.mins/60); // 60 minutes make a hour
	this.days = Math.floor(this.hours/24); // 24 hours make a second
	
	// make sure each value doesn't exceed the range in
	// which they exist.  Milliseconds, for example, will
	// be shown in a range of 0 - 999.  The modulous
	// operator, or %, well help in that.  Here the values
	// are also turned into strings preparing for the next step
	this.msecs = string(this.msecs % 1000);
	this.secs = string(this.secs % 60);
	this.mins = string(this.mins % 60);
	this.hours = string(this.hours % 24);
	this.days = string(this.days);
	
	// add on leading zeros for all the number values (which are
	// now strings) that aren't 3 or 2 characters long based on the
	// range being used to represent them.  Because mseconds and
	// days have up to 3 characters, a while loop is used to
	// continuously add 0s until they have 3.  Other values which
	// only need 2 leading 0s can get by on a single if check
	while (this.msecs.length < 3) this.msecs = "0" + this.msecs;
	if (this.secs.length < 2) this.secs = "0" + this.secs;
	if (this.mins.length < 2) this.mins = "0" + this.mins;
	if (this.hours.length < 2) this.hours = "0" + this.hours;
	while (this.days.length < 3) this.days = "0" + this.days;

	// finally, display your values.  If you want to put your values
	// in a textField, you can pretty much just stop here and throw them
	// into your textField as desired.  This example, however will go a step
	// further and use images for numbers for each numerical value in the
	// countdown to the desired date.
	
	// So, for that, loop through all the movies in this counter clip using the
	// evaluateFrameFrom prototype method on each. A single check for a
	// _parent variable is used to make sure the property found in a for
	// loop is a movieclip and is within the timeline of this counter clip.
	// TextFields and buttons would also be true here, but since the contents
	// within counter are strictly those numbers movieclips, we won't have to
	// be concerned with such complications.  The only movieclips in this counter
	// clip are the numbers movieclips with the frames of the imagery making up
	// the numbers of 0-9.
	for(movie in this){
		if (this[movie]._parent == this) this[movie].evaluateFrameFrom(this);
	}
};

// this function is a MovieClip.prototype meaning its available to be used by
// all movieclips.  It's a sneaky function that saves a lot of work by using
// name each numbers movieclip in the counter movieclip to determine which value
// it needs to display based on the times derived from the previous 
// calculations of the onEnterFrame. What it does is seperates a movieclip's
// _name into a variable word and a number.  The variable word will represent
// the variable to look up a value for in the passed variableClip and the
// number will be used to get a character from that value (a string) which
// represents which number this movieclip should display.
MovieClip.prototype.evaluateFrameFrom = function(variableClip){
	// split this _name into an array of 2 values seperated by an underscore
	var nameArray = this._name.split("_");
	// the first value represents what variable in variableClip (counter clip)
	// this movieclip is used to represent whether it be mins or hours etc.
	var numberSet = variableClip[nameArray[0]];
	// next a number representing which character in that first value this
	// movieclip should display.  this will be between 0 and 2 (any one of
	// three values).  number() is used to force it to be a number value.
	var character = number(nameArray[1]);
	// a frame number can then be derived from the value of the numberset
	// variable based on the character defined by character.  number() is
	// used to force it to a number value and 1 is added to offset the
	// frame value by one since 0 is at frame 1 and 1 at frame 2 etc.
	var frame = 1 + number(numberSet.charAt(character));
	// if the movieclip is not already at the frame, move it there!
	if (this._currentframe != frame) this.gotoAndStop(frame);
};

// an example of the above function in action would be for a movieclip
// with the name "days_1".  days_1 is seperated into an array by dividing
// the name by its "_" character giving "days" (nameArray[0]) and "1" (nameArray[1]).
// The value of days is then retrieved from the passed variableClip using
// associative array ssntax and is set to numberset.  The value of days in variableClip
// would be a string something along the lines of "045".  character is then used
// to get which of those 3 values this movieclip is to represent. It is just
// nameArray[1] turned into a number or "1" to 1.  So, charAt(1) of "045" would
// be 4.  Turn that into a number and add one and you get frame 5 where the image of
// the 4 is located.  The movieclip, days_1, is then played to that frame to show it.