public class PicBgRotator extends Sprite{

 

                public var _loaders:Array = [];

                private var _urls:Array = [];

                private var _loaded:Array = [];

                private var _index:uint = 0;

 

                private var _currentImage:Sprite;

                private var _prevImage:Sprite;

 

                private const _SCALE:Number = 1.07;

 

                private var _timeout:uint;

 

                private var _tw1:TweenLite;

                private var _tw2:TweenLite;

 

                private var _imageAlpha:Number;

                private var _updated:Boolean;

 

                private var _completlyLoaded:Boolean = false;

 

                private var _stopped:Boolean = false;

 

                public static var continueLoading:Boolean = true;

 

                public function PicBgRotator(xml:XMLList, autoRun:Boolean = true) {

                        for each(var img in xml.item) {

                                var l:Loader = new Loader();

                                l.contentLoaderInfo.addEventListener(Event.COMPLETE, _onImageLoaded);

 

                                _loaders.push(l);

                                _urls.push(new URLRequest(img));

                                _loaded.push(false);

                        }

                        if (autoRun)

                                loadNextImage()

 

                        addEventListener(Event.ADDED_TO_STAGE, _onAddedToStage);

 

                }

 

                public function loadNextImage():LoaderInfo {

 

                        var info = _loaders[_index].contentLoaderInfo;

                        _loaders[_index].load(_urls[_index]);

                        _loaders[_index].contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,_onIOError);

 

                        return info;

                }

 

                override public function set alpha(val:Number):void {

                        super.alpha = val;

                        if (!val && _prevImage && (_prevImage.parent == this))

                                removeChild(_prevImage);

                }

 

                private function _onIOError(e:IOErrorEvent):void {

 

                }

 

                private function _onImageLoaded(e:Event):void {

 

                        _loaded[_index] = true;

 

                        if (stage)

                                _addImage(_index);

 

                        for (var i:uint = 0; i < _loaded.length; i++)

                                if (!_loaded[i])

                                        return;

 

                        _completlyLoaded = true;

                }

 

                private function _onAddedToStage(e:Event):void {

 

                        removeEventListener(Event.ADDED_TO_STAGE, _onAddedToStage);

 

                        if(_loaded[_index])

                                _addImage(_index);

 

 

                }

 

                private function _addImage(i:uint):void {                        

 

                        if (_prevImage && (_prevImage.parent == this)) {

                                removeChild(_prevImage);

                                TweenLite.killTweensOf(_prevImage);

                        }

 

                        if (_currentImage)

                                _prevImage = _currentImage;

 

                        var img:Bitmap = _loaders[i].contentLoaderInfo.content;

 

                        img.y = 0;

                        img.smoothing = true;

 

                        var sp:Sprite = new Sprite();

                        sp.addChild(img);

 

                        sp.y = 0;

 

                        _currentImage=sp;

                        addChild(_currentImage);

 

                        _imageAlpha = 1;

                        _updated = false;

 

                        _imageAlpha = 1;

                        _tw1=TweenLite.from(this, 4, { imageAlpha:0, ease:Linear.easeOut, delay:0.2, onComplete:_onTweenComplete} );

                        if (_prevImage) {

                                _tw2=TweenLite.from(_currentImage, 4, { scaleX:_SCALE, scaleY:_SCALE, ease:Linear.easeOut} );

                        }

                        _index = i + 1;

                }

 

                public function set imageAlpha(val:Number):void {

                        _currentImage.alpha=val

                }

 

                public function get imageAlpha():Number {

                        return _imageAlpha;

                }

 

                public function pause():void {

                        _stopped = true;

                }

 

                public function resume():void {

                        _stopped = false;

                }

 

                private function _handleEnterFrame(e:Event):void {

 

                }

 

                private function _onTweenProgress():void {

 

                }

 

                private function _onTweenComplete():void {

                        _timeout = setTimeout(_nextImage, 7000);

                }

 

                private function _nextImage():void {

 

                        clearTimeout(_timeout);

 

                        if (!(continueLoading || _completlyLoaded) || _stopped) {

                                _timeout = setTimeout(_nextImage, 5000);

                                return;

                        }

 

                        var key:Boolean = true;

                        var i:int = 0;

 

                        while ((key = _loaded[i]) && (++i < _loaded.length) )

                        trace(_loaded[i])

                        if(!key)

                                loadNextImage();

                        else

                                _addImage(_index %= _loaded.length);

                }                

        }