home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / preloaders / Preloader.as < prev   
Encoding:
Text File  |  2008-09-02  |  9.6 KB  |  305 lines
  1. package mx.preloaders
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Loader;
  5.    import flash.display.LoaderInfo;
  6.    import flash.display.MovieClip;
  7.    import flash.display.Sprite;
  8.    import flash.events.ErrorEvent;
  9.    import flash.events.Event;
  10.    import flash.events.IEventDispatcher;
  11.    import flash.events.IOErrorEvent;
  12.    import flash.events.ProgressEvent;
  13.    import flash.events.SecurityErrorEvent;
  14.    import flash.events.TimerEvent;
  15.    import flash.net.URLRequest;
  16.    import flash.system.ApplicationDomain;
  17.    import flash.system.LoaderContext;
  18.    import flash.utils.Timer;
  19.    import mx.core.mx_internal;
  20.    import mx.events.FlexEvent;
  21.    import mx.events.RSLEvent;
  22.    
  23.    use namespace mx_internal;
  24.    
  25.    public class Preloader extends Sprite
  26.    {
  27.       
  28.       mx_internal static const VERSION:String = "2.0.1.0";
  29.        
  30.       
  31.       private var showDisplay:Boolean;
  32.       
  33.       private var timer:Timer;
  34.       
  35.       private var rslIndex:int = 0;
  36.       
  37.       private var rslDone:Boolean = false;
  38.       
  39.       private var rslLibs:Array;
  40.       
  41.       private var displayClass:IPreloaderDisplay = null;
  42.       
  43.       public function Preloader()
  44.       {
  45.          displayClass = null;
  46.          rslIndex = 0;
  47.          rslDone = false;
  48.          super();
  49.       }
  50.       
  51.       mx_internal function rslCompleteHandler(param1:Event, param2:RSLNode) : void
  52.       {
  53.          var _loc3_:RSLEvent = null;
  54.          _loc3_ = new RSLEvent(RSLEvent.RSL_COMPLETE);
  55.          _loc3_.bytesLoaded = param2.total;
  56.          _loc3_.bytesTotal = param2.total;
  57.          _loc3_.rslIndex = param2.index;
  58.          _loc3_.rslTotal = rslLibs.length;
  59.          _loc3_.url = param2.url;
  60.          dispatchEvent(_loc3_);
  61.          loadRSL(++rslIndex);
  62.       }
  63.       
  64.       private function appProgressHandler(param1:Event) : void
  65.       {
  66.          dispatchEvent(new FlexEvent(FlexEvent.INIT_PROGRESS));
  67.       }
  68.       
  69.       mx_internal function rslErrorHandler(param1:ErrorEvent, param2:RSLNode) : void
  70.       {
  71.          var _loc3_:RSLEvent = null;
  72.          _loc3_ = new RSLEvent(RSLEvent.RSL_ERROR);
  73.          _loc3_.bytesLoaded = 0;
  74.          _loc3_.bytesTotal = 0;
  75.          _loc3_.rslIndex = param2.index;
  76.          _loc3_.rslTotal = rslLibs.length;
  77.          _loc3_.url = param2.url;
  78.          _loc3_.errorText = param1.text;
  79.          dispatchEvent(_loc3_);
  80.       }
  81.       
  82.       private function displayClassCompleteHandler(param1:Event) : void
  83.       {
  84.          dispatchEvent(new FlexEvent(FlexEvent.PRELOADER_DONE));
  85.       }
  86.       
  87.       private function timerHandler(param1:TimerEvent) : void
  88.       {
  89.          var _loc2_:Object = null;
  90.          var _loc3_:int = 0;
  91.          var _loc4_:int = 0;
  92.          if(!root)
  93.          {
  94.             return;
  95.          }
  96.          _loc2_ = getByteValues();
  97.          _loc3_ = int(_loc2_.loaded);
  98.          _loc4_ = int(_loc2_.total);
  99.          dispatchEvent(new ProgressEvent(ProgressEvent.PROGRESS,false,false,_loc3_,_loc4_));
  100.          if(rslDone && (_loc3_ >= _loc4_ && _loc4_ > 0 || _loc4_ == 0 && _loc3_ > 0 || root is MovieClip && MovieClip(root).totalFrames > 2 && MovieClip(root).framesLoaded >= 2))
  101.          {
  102.             timer.removeEventListener(TimerEvent.TIMER,timerHandler);
  103.             timer.reset();
  104.             dispatchEvent(new Event(Event.COMPLETE));
  105.             dispatchEvent(new FlexEvent(FlexEvent.INIT_PROGRESS));
  106.          }
  107.       }
  108.       
  109.       private function getByteValues() : Object
  110.       {
  111.          var _loc1_:LoaderInfo = null;
  112.          var _loc2_:int = 0;
  113.          var _loc3_:int = 0;
  114.          var _loc4_:int = 0;
  115.          var _loc5_:int = 0;
  116.          _loc1_ = root.loaderInfo;
  117.          _loc2_ = int(_loc1_.bytesLoaded);
  118.          _loc3_ = int(_loc1_.bytesTotal);
  119.          _loc4_ = !!rslLibs ? int(rslLibs.length) : 0;
  120.          _loc5_ = 0;
  121.          while(_loc5_ < _loc4_)
  122.          {
  123.             _loc2_ += rslLibs[_loc5_].loaded;
  124.             _loc3_ += rslLibs[_loc5_].total;
  125.             _loc5_++;
  126.          }
  127.          return {
  128.             "loaded":_loc2_,
  129.             "total":_loc3_
  130.          };
  131.       }
  132.       
  133.       private function ioErrorHandler(param1:IOErrorEvent) : void
  134.       {
  135.       }
  136.       
  137.       public function initialize(param1:Boolean, param2:Class, param3:uint, param4:Number, param5:Object, param6:String, param7:Number, param8:Number, param9:Array = null, param10:Array = null) : void
  138.       {
  139.          var _loc11_:int = 0;
  140.          var _loc12_:int = 0;
  141.          var _loc13_:URLRequest = null;
  142.          var _loc14_:int = 0;
  143.          var _loc15_:RSLNode = null;
  144.          root.loaderInfo.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
  145.          if(Boolean(param9) && param9.length > 0)
  146.          {
  147.             rslLibs = [];
  148.             _loc11_ = int(param9.length);
  149.             _loc12_ = 0;
  150.             while(_loc12_ < _loc11_)
  151.             {
  152.                _loc13_ = new URLRequest(param9[_loc12_]);
  153.                _loc14_ = 0;
  154.                if(Boolean(param10) && param10.length == param9.length)
  155.                {
  156.                   _loc14_ = int(param10[_loc12_]);
  157.                }
  158.                _loc15_ = new RSLNode(_loc13_,_loc12_,_loc14_,this);
  159.                rslLibs.push(_loc15_);
  160.                _loc12_++;
  161.             }
  162.             loadRSL(0);
  163.          }
  164.          else
  165.          {
  166.             rslDone = true;
  167.          }
  168.          this.showDisplay = param1;
  169.          timer = new Timer(10);
  170.          timer.addEventListener(TimerEvent.TIMER,timerHandler);
  171.          timer.start();
  172.          if(param1)
  173.          {
  174.             displayClass = new param2();
  175.             displayClass.addEventListener(Event.COMPLETE,displayClassCompleteHandler);
  176.             addChild(DisplayObject(displayClass));
  177.             displayClass.backgroundColor = param3;
  178.             displayClass.backgroundAlpha = param4;
  179.             displayClass.backgroundImage = param5;
  180.             displayClass.backgroundSize = param6;
  181.             displayClass.stageWidth = param7;
  182.             displayClass.stageHeight = param8;
  183.             displayClass.initialize();
  184.             displayClass.preloader = this;
  185.          }
  186.       }
  187.       
  188.       private function appCreationCompleteHandler(param1:FlexEvent) : void
  189.       {
  190.          dispatchAppEndEvent();
  191.       }
  192.       
  193.       mx_internal function rslProgressHandler(param1:ProgressEvent, param2:RSLNode) : void
  194.       {
  195.          var _loc3_:RSLEvent = null;
  196.          _loc3_ = new RSLEvent(RSLEvent.RSL_PROGRESS);
  197.          _loc3_.bytesLoaded = param1.bytesLoaded;
  198.          _loc3_.bytesTotal = param1.bytesTotal;
  199.          _loc3_.rslIndex = param2.index;
  200.          _loc3_.rslTotal = rslLibs.length;
  201.          _loc3_.url = param2.url;
  202.          dispatchEvent(_loc3_);
  203.       }
  204.       
  205.       private function loadRSL(param1:int) : void
  206.       {
  207.          var _loc2_:RSLNode = null;
  208.          var _loc3_:Loader = null;
  209.          var _loc4_:LoaderContext = null;
  210.          if(param1 < rslLibs.length)
  211.          {
  212.             _loc2_ = rslLibs[param1];
  213.             _loc3_ = new Loader();
  214.             _loc3_.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,_loc2_.progressHandler);
  215.             _loc3_.contentLoaderInfo.addEventListener(Event.COMPLETE,_loc2_.completeHandler);
  216.             _loc3_.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,_loc2_.errorHandler);
  217.             _loc3_.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,_loc2_.errorHandler);
  218.             (_loc4_ = new LoaderContext()).applicationDomain = ApplicationDomain.currentDomain;
  219.             _loc3_.load(_loc2_.url,_loc4_);
  220.          }
  221.          else
  222.          {
  223.             rslDone = true;
  224.          }
  225.       }
  226.       
  227.       public function registerApplication(param1:IEventDispatcher) : void
  228.       {
  229.          param1.addEventListener("validatePropertiesComplete",appProgressHandler);
  230.          param1.addEventListener("validateSizeComplete",appProgressHandler);
  231.          param1.addEventListener("validateDisplayListComplete",appProgressHandler);
  232.          param1.addEventListener(FlexEvent.CREATION_COMPLETE,appCreationCompleteHandler);
  233.       }
  234.       
  235.       private function dispatchAppEndEvent(param1:Object = null) : void
  236.       {
  237.          dispatchEvent(new FlexEvent(FlexEvent.INIT_COMPLETE));
  238.          if(!showDisplay)
  239.          {
  240.             displayClassCompleteHandler(null);
  241.          }
  242.       }
  243.    }
  244. }
  245.  
  246. import flash.events.ErrorEvent;
  247. import flash.events.Event;
  248. import flash.events.ProgressEvent;
  249. import flash.net.URLRequest;
  250. import mx.core.mx_internal;
  251. import mx.preloaders.Preloader;
  252.  
  253. class RSLNode
  254. {
  255.     
  256.    
  257.    public var completed:Boolean = false;
  258.    
  259.    public var loaded:uint = 0;
  260.    
  261.    public var total:uint = 0;
  262.    
  263.    public var index:int;
  264.    
  265.    public var errorText:String;
  266.    
  267.    public var url:URLRequest;
  268.    
  269.    public var owner:Preloader;
  270.    
  271.    public function RSLNode(param1:URLRequest, param2:int, param3:int, param4:Preloader)
  272.    {
  273.       total = 0;
  274.       loaded = 0;
  275.       completed = false;
  276.       super();
  277.       this.url = param1;
  278.       this.index = param2;
  279.       this.total = param3;
  280.       this.owner = param4;
  281.    }
  282.    
  283.    public function errorHandler(param1:ErrorEvent) : void
  284.    {
  285.       errorText = param1.text;
  286.       completed = true;
  287.       loaded = 0;
  288.       total = 0;
  289.       owner.mx_internal::rslErrorHandler(param1,this);
  290.    }
  291.    
  292.    public function progressHandler(param1:ProgressEvent) : void
  293.    {
  294.       loaded = param1.bytesLoaded;
  295.       total = param1.bytesTotal;
  296.       owner.mx_internal::rslProgressHandler(param1,this);
  297.    }
  298.    
  299.    public function completeHandler(param1:Event) : void
  300.    {
  301.       completed = true;
  302.       owner.mx_internal::rslCompleteHandler(param1,this);
  303.    }
  304. }
  305.