package com.kw.components
{
 import flash.display.DisplayObject;
 import flash.text.TextLineMetrics;

 import mx.controls.Button;
 import mx.core.IFlexDisplayObject;
 import mx.core.mx_internal;
 use namespace mx_internal;

 public class KWButton extends Button
 {
 public function KWButton()
 {
 super();
 }
 public var tagid:Number;
 override protected function createChildren():void
 {
 if (!textField)
 {
 textField = new NoTruncationUITextField();
 textField.styleName = this;
 addChild(DisplayObject(textField));
 }
 super.createChildren();
 textField.multiline = true;
 textField.wordWrap = true;
 textField.width = width;
 }
 override protected function measure():void
 {
 if (!isNaN(explicitWidth))
 {
 var tempIcon:IFlexDisplayObject = getCurrentIcon();
 var w:Number = explicitWidth;
 if (tempIcon)
 w -= tempIcon.width + getStyle("horizontalGap") + getStyle("paddingLeft") + getStyle("paddingRight");
 textField.width = w;
 }
 super.measure();
 }
 override public function measureText(s:String):TextLineMetrics
 {
 textField.text = s;
 var lineMetrics:TextLineMetrics = textField.getLineMetrics(0);
 lineMetrics.width = textField.textWidth + 4;
 lineMetrics.height = textField.textHeight + 4;
 return lineMetrics;
 }
 }
}
import mx.core.UITextField;
class NoTruncationUITextField extends UITextField
{
 public function NoTruncationUITextField()
 {
 super();
 }
 override public function truncateToFit(s:String = null):Boolean
 {
 return false;
 }
}

public static function formatTime ( time:Number ):String
 {
 var remainder:Number;            
 var hours:Number = time / ( 60 * 60 );            
 remainder = hours - (Math.floor ( hours ));            
 hours = Math.floor ( hours );            
 var minutes:Number = remainder * 60;            
 remainder = minutes - (Math.floor ( minutes ));            
 minutes = Math.floor ( minutes );            
 var seconds:Number = remainder * 60;            
 remainder = seconds - (Math.floor ( seconds ));            
 seconds = Math.floor ( seconds );            
 var hString:String = hours < 10 ? "0" + hours : "" + hours;    
 var mString:String = minutes < 10 ? "0" + minutes : "" + minutes;
 var sString:String = seconds < 10 ? "0" + seconds : "" + seconds;                        
 if ( time < 0 || isNaN(time)) return "00:00";                        
 if ( hours > 0 )
 {            
 return hString + ":" + mString + ":" + sString;
 }else
 {
 return mString + ":" + sString;
 }
 }

here is the simple class that helps you to create a custom MovieClip and you can change its registration point at anytime,

package com.karthik.web.display {
 import flash.display.MovieClip;
 import flash.events.Event;
 import flash.geom.Point;    

 public class KMovieClip extends MovieClip {

 protected var _registrationX:Number;        // Registration point X
 protected var _registrationY:Number;        // Registration point Y
 protected var _x:Number;            // User-defined X
 protected var _y:Number;            // User-defined Y

 protected var setToUpdate:Boolean;        // Whether this instance is already set to update on the next Event.RENDER

 // CONSTRUCTOR 

 public function KMovieClip() {
 super();

 // Reads the current __values to keep them
 _x = super.x;
 _y = super.y;
 _registrationX = 0;
 _registrationY = 0;
 fixPosition();
 }

 // INTERNAL functions 

 protected function fixPosition(): void {
 // Using localToGlobal/globalToLocal is less precise than doing it mathematically, but the end result is more accurate inside Flash because it's in sync with Flash's positioning and rotating limitations
 var op:Point = new Point(0, 0);
 var rp:Point = new Point(_registrationX, _registrationY);
 rp = parent.globalToLocal(localToGlobal(rp));
 op = parent.globalToLocal(localToGlobal(op));
 super.x = _x - (rp.x - op.x);
 super.y = _y - (rp.y - op.y);
 }

 protected function requestPositionFix(): void {
 if (Boolean(stage) && !setToUpdate) {
 setToUpdate = true;
 stage.addEventListener(Event.RENDER, onRender, false, 0, true);
 stage.invalidate();
 }
 }

 // EVENT functions ------------------------------------------------------------------------------------------------

 protected function onRender(e:Event): void {
 stage.removeEventListener(Event.RENDER, onRender);
 setToUpdate = false;
 fixPosition();
 }

 // ACCESSOR functions ---------------------------------------------------------------------------------------------

 override public function get x(): Number {
 return _x;
 }
 override public function set x(__value:Number): void {
 _x = __value;
 requestPositionFix();
 }

 override public function get y(): Number {
 return _y;
 }
 override public function set y(__value:Number): void {
 _y = __value;
 requestPositionFix();
 }

 override public function set rotation(__value:Number): void {
 super.rotation = __value;
 requestPositionFix();
 }
 override public function set scaleX(__value:Number): void {
 super.scaleX = __value;
 requestPositionFix();
 }
 override public function set scaleY(__value:Number): void {
 super.scaleY = __value;
 requestPositionFix();
 }

 public function get registrationX(): Number {
 return _registrationX;
 }
 public function set registrationX(__value:Number): void {
 _registrationX = __value;
 requestPositionFix();
 }

 public function get registrationY(): Number {
 return _registrationY;
 }
 public function set registrationY(__value:Number): void {
 _registrationY = __value;
 requestPositionFix();
 }

 }
}

After creating an instance of this MovieClip class, you can change the registration point as below,
mc.registrationX = 10;
mc.registrationY = 10;

PopUp window:

<mx:script>
dispatchEvent( new Event(MyEvent.MY_DATA_CHANGED, true));
</mx:script>

Other mxml component:

<mx:script>
     private function onClick():void {
       var win:MyForm = PopUpManager.createPopUp(this, MyForm, true) as MyForm;
       win.addEventListener(MyEvent.MY_DATA_CHANGED, onMyDataChanged);
     }
     private function onMyDataChanged(event:Event):void {
       trace("DATA CHANGED");
     }
</mx:script>

MyEvent:

public static const MY_DATA_CHANGED:String = "myDataChanged";

I hope this will help.

str.replace(/\b./g,function(...m):String{return m[0].toUpperCase()});

public class Main extends Sprite{
public function Main(){
var msg1:XML = <GREETING>
<TO>A</TO>
<FROM>Programmer</FROM>
<MESSAGE>Hello</MESSAGE>
</GREETING>;

var msg2:XML = <GREETING>
<TO>A</TO>
<FROM>Programmer</FROM>
<MESSAGE>Hello</MESSAGE>
</GREETING>;

trace(msg1.* == msg2.*);  // Displays: true
}
}
}

var player:Mp3Player = new Mp3Player();
player.play('blah.mp3');
or
var player:Mp3Player = new Mp3Player();
player.playlist = ['item1.mp3','item2.mp3'];
player.next();

package {
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.media.Sound;
	import flash.media.SoundChannel;
	import flash.media.SoundTransform;
	import flash.net.URLRequest;
	import flash.utils.clearInterval;
	import flash.utils.setInterval;		

	public class Mp3Player extends EventDispatcher {

		static public const EVENT_TIME_CHANGE:String = 'Mp3Player.TimeChange';
		static public const EVENT_VOLUME_CHANGE:String = 'Mp3Player.VolumeChange';
		static public const EVENT_PAN_CHANGE:String = 'Mp3Player.PanningChange';
		static public const EVENT_PAUSE:String = 'Mp3Player.Pause';
		static public const EVENT_UNPAUSE:String = 'Mp3Player.Unpause';
		static public const EVENT_PLAY:String = 'Mp3Player.Play';
		//
		public var playing:Boolean;
		public var playlist:Array;
		public var currentUrl:String;
		public var playlistIndex:int = -1;
		//
		protected var sound:Sound;
		protected var soundChannel:SoundChannel;
		protected var soundTrans:SoundTransform;
		protected var progressInt:Number;

		public function play( url:String ):void {
			clearInterval(progressInt);
			if ( sound ) {
				soundChannel.stop();
			}
			currentUrl = url;
			sound = new Sound();
			sound.addEventListener(Event.COMPLETE, onLoadSong);
			sound.addEventListener(Event.ID3, onId3Info);

			sound.load(new URLRequest(currentUrl));

			soundChannel = sound.play();
			if ( soundTrans ) {
				soundChannel.soundTransform = soundTrans;
			} else {
				soundTrans = soundChannel.soundTransform;
			}
			soundChannel.addEventListener(Event.COMPLETE, onSongEnd);
			playing = true;
			clearInterval(progressInt);
			progressInt = setInterval(updateProgress, 30);
			dispatchEvent(new Event(EVENT_PLAY));
		}
		public function pause():void {
			if ( soundChannel ) {
				soundChannel.stop();
				dispatchEvent(new Event(EVENT_PAUSE));
				playing = false;
			}
		}
		public function unpause():void {
			if ( playing ) return;
			if ( soundChannel.position < sound.length ) {
				soundChannel = sound.play(soundChannel.position);
				soundChannel.soundTransform = soundTrans;
			} else {
				soundChannel = sound.play();
			}
			dispatchEvent(new Event(EVENT_UNPAUSE));
			playing = true;
		}
		public function seek( percent:Number ):void {
			soundChannel.stop();
			soundChannel = sound.play(sound.length * percent);
		}
		public function prev():void {
			playlistIndex--;
			if ( playlistIndex < 0 ) playlistIndex = playlist.length - 1;
			play(playlist[playlistIndex]);
		}
		public function next():void {
			playlistIndex++;
			if ( playlistIndex == playlist.length ) playlistIndex = 0;
			play(playlist[playlistIndex]);
		}
		public function get volume():Number {
			if (!soundTrans) return 0;
			return soundTrans.volume;
		}
		public function set volume( n:Number ):void {
			if ( !soundTrans ) return;
			soundTrans.volume = n;
			soundChannel.soundTransform = soundTrans;
			dispatchEvent(new Event(EVENT_VOLUME_CHANGE));
		}
		public function get pan():Number {
			if (!soundTrans) return 0;
			return soundTrans.pan;
		}
		public function set pan( n:Number ):void {
			if ( !soundTrans ) return;
			soundTrans.pan = n;
			soundChannel.soundTransform = soundTrans;
			dispatchEvent(new Event(EVENT_PAN_CHANGE));
		}
		public function get length():Number {
			return sound.length;
		}
		public function get time():Number {
			return soundChannel.position;
		}
		public function get timePretty():String {
			var secs:Number = soundChannel.position / 1000;
			var mins:Number = Math.floor(secs / 60);
			secs = Math.floor(secs % 60);
			return mins + ":" + (secs < 10 ? "0" : "") + secs;
		}
		public function get timePercent():Number {
			if ( !sound.length ) return 0;
			return soundChannel.position / sound.length;
		}
		protected function onLoadSong( e:Event ):void {
		}
		protected function onSongEnd( e:Event ):void {
			if ( playlist )
				next();
		}
		protected function onId3Info( e:Event ):void {
			dispatchEvent(new Event(Event.ID3, e.target.id3));
		}
		protected function updateProgress():void {
			dispatchEvent(new Event(EVENT_TIME_CHANGE));
			if ( timePercent >= .99 ) {
				onSongEnd(new Event(Event.COMPLETE));
				clearInterval(progressInt);
			}
		}
	}
}

For this you need to create four dynamic text boxes and name those as txtHrs, txtMins, txtSecs, and txtDate.

Put the following actions in your movie frame and create a class and use these.

var time:Timer = new Timer(10);

tm.addEventListener(TimerEvent.TIMER, update);

function update(tevt:TimerEvent):void {

                         var now:Date = new Date();

                         var hr:Number = now.hours;

                         var min:Number = now.minutes;

                         var sec:Number = now.seconds;

                         if (hr > 12) {

                                                  hr -= 12;

                         }

                         txtHrs.text = String(hr);

                         if (min < 10) {

                                                  txtMins.text = “0″;

                         }

                         else {

                                                  txtMins.text = “”;

                         }

                         txtMins.appendText(String(min));

                         if (sec < 10) {

                                                  txtSecs.text = “0″;

                         }

                         else {

                                                  txtSecs.text = “”;

                         }

                         txtSecs.appendText(String(sec));

                         txtDate.text = now.toDateString();

}

time.start();

Now test your movie and you can see your system time on your movie display.

Try this!.