home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / preloaders / DownloadProgressBar.as next >
Encoding:
Text File  |  2008-09-02  |  25.7 KB  |  795 lines
  1. package mx.preloaders
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.GradientType;
  5.    import flash.display.Graphics;
  6.    import flash.display.Loader;
  7.    import flash.display.LoaderInfo;
  8.    import flash.display.Sprite;
  9.    import flash.events.Event;
  10.    import flash.events.IOErrorEvent;
  11.    import flash.events.ProgressEvent;
  12.    import flash.events.TimerEvent;
  13.    import flash.geom.Matrix;
  14.    import flash.geom.Rectangle;
  15.    import flash.net.URLRequest;
  16.    import flash.system.ApplicationDomain;
  17.    import flash.system.LoaderContext;
  18.    import flash.text.TextField;
  19.    import flash.text.TextFormat;
  20.    import flash.utils.Timer;
  21.    import flash.utils.getDefinitionByName;
  22.    import flash.utils.getTimer;
  23.    import mx.core.mx_internal;
  24.    import mx.events.FlexEvent;
  25.    import mx.events.RSLEvent;
  26.    import mx.graphics.RectangularDropShadow;
  27.    import mx.graphics.RoundedRectangle;
  28.    
  29.    use namespace mx_internal;
  30.    
  31.    public class DownloadProgressBar extends Sprite implements IPreloaderDisplay
  32.    {
  33.       
  34.       mx_internal static const VERSION:String = "2.0.1.0";
  35.       
  36.       private static var _initializingLabel:String = "Initializing";
  37.        
  38.       
  39.       private var _stageHeight:Number = 375;
  40.       
  41.       private var _percentRect:Rectangle;
  42.       
  43.       private var _percentObj:TextField;
  44.       
  45.       private var _backgroundSize:String = "";
  46.       
  47.       private var _showLabel:Boolean = true;
  48.       
  49.       private var _value:Number = 0;
  50.       
  51.       private var _backgroundAlpha:Number = 1;
  52.       
  53.       private var _backgroundImage:Object;
  54.       
  55.       private var _backgroundColor:uint;
  56.       
  57.       protected var DOWNLOAD_PERCENTAGE:uint = 60;
  58.       
  59.       private var _labelObj:TextField;
  60.       
  61.       private var _barFrameSprite:Sprite;
  62.       
  63.       private var _maximum:Number = 0;
  64.       
  65.       private var _startTime:int;
  66.       
  67.       private var _preloader:Sprite;
  68.       
  69.       private var _displayTime:int;
  70.       
  71.       protected var MINIMUM_DISPLAY_TIME:uint = 0;
  72.       
  73.       private var _stageWidth:Number = 500;
  74.       
  75.       private var _downloadingLabel:String = "Loading";
  76.       
  77.       private var _showProgressBar:Boolean = true;
  78.       
  79.       private var _yOffset:Number = 20;
  80.       
  81.       private var _initProgressCount:uint = 0;
  82.       
  83.       private var _barSprite:Sprite;
  84.       
  85.       private var _visible:Boolean = false;
  86.       
  87.       private var _barRect:RoundedRectangle;
  88.       
  89.       private var _showingDisplay:Boolean = false;
  90.       
  91.       private var _initProgressTotal:uint = 12;
  92.       
  93.       private var _startedInit:Boolean = false;
  94.       
  95.       private var _labelRect:Rectangle;
  96.       
  97.       private var _showPercentage:Boolean = false;
  98.       
  99.       private var _startedLoading:Boolean = false;
  100.       
  101.       private var _displayStartCount:uint = 0;
  102.       
  103.       private var _borderRect:RoundedRectangle;
  104.       
  105.       private var _xOffset:Number = 20;
  106.       
  107.       private var _label:String = "";
  108.       
  109.       private var _barFrameRect:RoundedRectangle;
  110.       
  111.       public function DownloadProgressBar()
  112.       {
  113.          MINIMUM_DISPLAY_TIME = 0;
  114.          DOWNLOAD_PERCENTAGE = 60;
  115.          _showProgressBar = true;
  116.          _labelRect = labelRect;
  117.          _percentRect = percentRect;
  118.          _borderRect = borderRect;
  119.          _barFrameRect = barFrameRect;
  120.          _barRect = barRect;
  121.          _xOffset = 20;
  122.          _yOffset = 20;
  123.          _maximum = 0;
  124.          _value = 0;
  125.          _startedLoading = false;
  126.          _startedInit = false;
  127.          _showingDisplay = false;
  128.          _displayStartCount = 0;
  129.          _initProgressCount = 0;
  130.          _initProgressTotal = 12;
  131.          _visible = false;
  132.          _backgroundAlpha = 1;
  133.          _backgroundSize = "";
  134.          _stageHeight = 375;
  135.          _stageWidth = 500;
  136.          _downloadingLabel = "Loading";
  137.          _label = "";
  138.          _showLabel = true;
  139.          _showPercentage = false;
  140.          super();
  141.       }
  142.       
  143.       public static function get initializingLabel() : String
  144.       {
  145.          return _initializingLabel;
  146.       }
  147.       
  148.       public static function set initializingLabel(param1:String) : void
  149.       {
  150.          _initializingLabel = param1;
  151.       }
  152.       
  153.       private function calcScale() : void
  154.       {
  155.          var _loc1_:Number = NaN;
  156.          if(stageWidth < 160 || stageHeight < 120)
  157.          {
  158.             scaleX = 1;
  159.             scaleY = 1;
  160.          }
  161.          else if(stageWidth < 240 || stageHeight < 150)
  162.          {
  163.             createChildren();
  164.             _loc1_ = Math.min(stageWidth / 240,stageHeight / 150);
  165.             scaleX = _loc1_;
  166.             scaleY = _loc1_;
  167.          }
  168.          else
  169.          {
  170.             createChildren();
  171.          }
  172.       }
  173.       
  174.       protected function get labelFormat() : TextFormat
  175.       {
  176.          var _loc1_:TextFormat = null;
  177.          _loc1_ = new TextFormat();
  178.          _loc1_.color = 3355443;
  179.          _loc1_.font = "Verdana";
  180.          _loc1_.size = 10;
  181.          return _loc1_;
  182.       }
  183.       
  184.       protected function rslCompleteHandler(param1:RSLEvent) : void
  185.       {
  186.          label = "Loaded library " + param1.rslIndex + " of " + param1.rslTotal;
  187.       }
  188.       
  189.       protected function set showLabel(param1:Boolean) : void
  190.       {
  191.          _showLabel = param1;
  192.          draw();
  193.       }
  194.       
  195.       private function calcBackgroundSize() : Number
  196.       {
  197.          var _loc1_:Number = NaN;
  198.          var _loc2_:int = 0;
  199.          _loc1_ = NaN;
  200.          if(backgroundSize)
  201.          {
  202.             _loc2_ = backgroundSize.indexOf("%");
  203.             if(_loc2_ != -1)
  204.             {
  205.                _loc1_ = Number(backgroundSize.substr(0,_loc2_));
  206.             }
  207.          }
  208.          return _loc1_;
  209.       }
  210.       
  211.       protected function rslErrorHandler(param1:RSLEvent) : void
  212.       {
  213.          _preloader.removeEventListener(ProgressEvent.PROGRESS,progressHandler);
  214.          _preloader.removeEventListener(Event.COMPLETE,completeHandler);
  215.          _preloader.removeEventListener(RSLEvent.RSL_PROGRESS,rslProgressHandler);
  216.          _preloader.removeEventListener(RSLEvent.RSL_COMPLETE,rslCompleteHandler);
  217.          _preloader.removeEventListener(RSLEvent.RSL_ERROR,rslErrorHandler);
  218.          _preloader.removeEventListener(FlexEvent.INIT_PROGRESS,initProgressHandler);
  219.          _preloader.removeEventListener(FlexEvent.INIT_COMPLETE,initCompleteHandler);
  220.          if(!_showingDisplay)
  221.          {
  222.             show();
  223.             _showingDisplay = true;
  224.          }
  225.          label = "RSL Error " + (param1.rslIndex + 1) + " of " + param1.rslTotal;
  226.       }
  227.       
  228.       protected function get barFrameRect() : RoundedRectangle
  229.       {
  230.          return new RoundedRectangle(14,40,154,4);
  231.       }
  232.       
  233.       private function loader_ioErrorHandler(param1:IOErrorEvent) : void
  234.       {
  235.       }
  236.       
  237.       protected function get borderRect() : RoundedRectangle
  238.       {
  239.          return new RoundedRectangle(0,0,182,60,4);
  240.       }
  241.       
  242.       protected function showDisplayForDownloading(param1:int, param2:ProgressEvent) : Boolean
  243.       {
  244.          return param1 > 700 && param2.bytesLoaded < param2.bytesTotal / 2;
  245.       }
  246.       
  247.       private function timerHandler(param1:Event = null) : void
  248.       {
  249.          dispatchEvent(new Event(Event.COMPLETE));
  250.       }
  251.       
  252.       protected function progressHandler(param1:ProgressEvent) : void
  253.       {
  254.          var _loc2_:uint = 0;
  255.          var _loc3_:uint = 0;
  256.          var _loc4_:int = 0;
  257.          _loc2_ = param1.bytesLoaded;
  258.          _loc3_ = param1.bytesTotal;
  259.          _loc4_ = getTimer() - _startTime;
  260.          if(_showingDisplay || showDisplayForDownloading(_loc4_,param1))
  261.          {
  262.             if(!_startedLoading)
  263.             {
  264.                show();
  265.                label = downloadingLabel;
  266.                _startedLoading = true;
  267.             }
  268.             setProgress(param1.bytesLoaded,param1.bytesTotal);
  269.          }
  270.       }
  271.       
  272.       public function get backgroundSize() : String
  273.       {
  274.          return _backgroundSize;
  275.       }
  276.       
  277.       override public function get visible() : Boolean
  278.       {
  279.          return _visible;
  280.       }
  281.       
  282.       protected function center(param1:Number, param2:Number) : void
  283.       {
  284.          _xOffset = Math.floor((param1 - _borderRect.width) / 2);
  285.          _yOffset = Math.floor((param2 - _borderRect.height) / 2);
  286.       }
  287.       
  288.       protected function get barRect() : RoundedRectangle
  289.       {
  290.          return new RoundedRectangle(14,39,154,6,0);
  291.       }
  292.       
  293.       protected function rslProgressHandler(param1:RSLEvent) : void
  294.       {
  295.       }
  296.       
  297.       public function set backgroundSize(param1:String) : void
  298.       {
  299.          _backgroundSize = param1;
  300.       }
  301.       
  302.       private function initCompleteHandler(param1:Event) : void
  303.       {
  304.          var _loc2_:int = 0;
  305.          var _loc3_:Timer = null;
  306.          _loc2_ = getTimer() - _displayTime;
  307.          if(_showingDisplay && _loc2_ < MINIMUM_DISPLAY_TIME)
  308.          {
  309.             _loc3_ = new Timer(MINIMUM_DISPLAY_TIME - _loc2_,1);
  310.             _loc3_.addEventListener(TimerEvent.TIMER,timerHandler);
  311.             _loc3_.start();
  312.          }
  313.          else
  314.          {
  315.             timerHandler();
  316.          }
  317.       }
  318.       
  319.       protected function get percentFormat() : TextFormat
  320.       {
  321.          var _loc1_:TextFormat = null;
  322.          _loc1_ = new TextFormat();
  323.          _loc1_.align = "right";
  324.          _loc1_.color = 0;
  325.          _loc1_.font = "Verdana";
  326.          _loc1_.size = 10;
  327.          return _loc1_;
  328.       }
  329.       
  330.       private function calcY(param1:Number) : Number
  331.       {
  332.          return param1 + _yOffset;
  333.       }
  334.       
  335.       protected function setProgress(param1:Number, param2:Number) : void
  336.       {
  337.          if(!isNaN(param1) && !isNaN(param2) && param1 >= 0 && param2 > 0)
  338.          {
  339.             _value = Number(param1);
  340.             _maximum = Number(param2);
  341.             draw();
  342.          }
  343.       }
  344.       
  345.       protected function get downloadingLabel() : String
  346.       {
  347.          return _downloadingLabel;
  348.       }
  349.       
  350.       private function calcX(param1:Number) : Number
  351.       {
  352.          return param1 + _xOffset;
  353.       }
  354.       
  355.       protected function showDisplayForInit(param1:int, param2:int) : Boolean
  356.       {
  357.          return param1 > 300 && param2 == 2;
  358.       }
  359.       
  360.       private function drawProgressBar(param1:Number) : void
  361.       {
  362.          var _loc2_:Graphics = null;
  363.          var _loc3_:Array = null;
  364.          var _loc4_:Array = null;
  365.          var _loc5_:Matrix = null;
  366.          var _loc6_:Number = NaN;
  367.          var _loc7_:Number = NaN;
  368.          var _loc8_:Number = NaN;
  369.          var _loc9_:Number = NaN;
  370.          var _loc10_:Number = NaN;
  371.          var _loc11_:Number = NaN;
  372.          _loc2_ = _barSprite.graphics;
  373.          _loc2_.clear();
  374.          _loc3_ = [16777215,16777215];
  375.          _loc4_ = [0,255];
  376.          _loc5_ = new Matrix();
  377.          _loc7_ = (_loc6_ = _barRect.width * param1 / 100) / 2;
  378.          _loc8_ = _barRect.height - 4;
  379.          _loc9_ = calcX(_barRect.x);
  380.          _loc10_ = calcY(_barRect.y) + 2;
  381.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  382.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.39,0.85],_loc4_,_loc5_);
  383.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,_loc8_);
  384.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  385.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.85,1],_loc4_,_loc5_);
  386.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,_loc8_);
  387.          _loc7_ = _loc6_ / 3;
  388.          _loc8_ = _barRect.height;
  389.          _loc11_ = (_loc10_ = calcY(_barRect.y)) + _loc8_ - 1;
  390.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  391.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.05,0.15],_loc4_,_loc5_);
  392.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,1);
  393.          _loc2_.drawRect(_loc9_,_loc11_,_loc7_,1);
  394.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  395.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.15,0.25],_loc4_,_loc5_);
  396.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,1);
  397.          _loc2_.drawRect(_loc9_ + _loc7_,_loc11_,_loc7_,1);
  398.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_ * 2,_loc10_);
  399.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.25,0.1],_loc4_,_loc5_);
  400.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc10_,_loc7_,1);
  401.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc11_,_loc7_,1);
  402.          _loc7_ = _loc6_ / 3;
  403.          _loc8_ = _barRect.height;
  404.          _loc10_ = calcY(_barRect.y) + 1;
  405.          _loc11_ = calcY(_barRect.y) + _loc8_ - 2;
  406.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  407.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.15,0.3],_loc4_,_loc5_);
  408.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,1);
  409.          _loc2_.drawRect(_loc9_,_loc11_,_loc7_,1);
  410.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  411.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.3,0.4],_loc4_,_loc5_);
  412.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,1);
  413.          _loc2_.drawRect(_loc9_ + _loc7_,_loc11_,_loc7_,1);
  414.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_ * 2,_loc10_);
  415.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.4,0.25],_loc4_,_loc5_);
  416.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc10_,_loc7_,1);
  417.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc11_,_loc7_,1);
  418.       }
  419.       
  420.       public function get backgroundImage() : Object
  421.       {
  422.          return _backgroundImage;
  423.       }
  424.       
  425.       public function set stageWidth(param1:Number) : void
  426.       {
  427.          _stageWidth = param1;
  428.       }
  429.       
  430.       public function get backgroundAlpha() : Number
  431.       {
  432.          if(!isNaN(_backgroundAlpha))
  433.          {
  434.             return _backgroundAlpha;
  435.          }
  436.          return 1;
  437.       }
  438.       
  439.       public function set preloader(param1:Sprite) : void
  440.       {
  441.          _preloader = param1;
  442.          param1.addEventListener(ProgressEvent.PROGRESS,progressHandler);
  443.          param1.addEventListener(Event.COMPLETE,completeHandler);
  444.          param1.addEventListener(RSLEvent.RSL_PROGRESS,rslProgressHandler);
  445.          param1.addEventListener(RSLEvent.RSL_COMPLETE,rslCompleteHandler);
  446.          param1.addEventListener(RSLEvent.RSL_ERROR,rslErrorHandler);
  447.          param1.addEventListener(FlexEvent.INIT_PROGRESS,initProgressHandler);
  448.          param1.addEventListener(FlexEvent.INIT_COMPLETE,initCompleteHandler);
  449.       }
  450.       
  451.       public function get backgroundColor() : uint
  452.       {
  453.          return _backgroundColor;
  454.       }
  455.       
  456.       protected function set showPercentage(param1:Boolean) : void
  457.       {
  458.          _showPercentage = param1;
  459.          draw();
  460.       }
  461.       
  462.       override public function set visible(param1:Boolean) : void
  463.       {
  464.          if(!_visible && param1)
  465.          {
  466.             show();
  467.          }
  468.          else if(_visible && !param1)
  469.          {
  470.             hide();
  471.          }
  472.          _visible = param1;
  473.       }
  474.       
  475.       protected function get labelRect() : Rectangle
  476.       {
  477.          return new Rectangle(14,17,100,16);
  478.       }
  479.       
  480.       private function show() : void
  481.       {
  482.          _showingDisplay = true;
  483.          calcScale();
  484.          draw();
  485.          _displayTime = getTimer();
  486.       }
  487.       
  488.       protected function createChildren() : void
  489.       {
  490.          var _loc1_:Graphics = null;
  491.          var _loc2_:TextField = null;
  492.          var _loc3_:TextField = null;
  493.          var _loc4_:Graphics = null;
  494.          var _loc5_:Matrix = null;
  495.          var _loc6_:RectangularDropShadow = null;
  496.          _loc1_ = graphics;
  497.          if(backgroundImage != null)
  498.          {
  499.             loadBackgroundImage(backgroundImage);
  500.          }
  501.          _barFrameSprite = new Sprite();
  502.          _barSprite = new Sprite();
  503.          addChild(_barFrameSprite);
  504.          addChild(_barSprite);
  505.          _loc1_.beginFill(13421772,0.4);
  506.          _loc1_.drawRoundRect(calcX(_borderRect.x),calcY(_borderRect.y),_borderRect.width,_borderRect.height,_borderRect.cornerRadius * 2,_borderRect.cornerRadius * 2);
  507.          _loc1_.drawRoundRect(calcX(_borderRect.x + 1),calcY(_borderRect.y + 1),_borderRect.width - 2,_borderRect.height - 2,_borderRect.cornerRadius - 1 * 2,_borderRect.cornerRadius - 1 * 2);
  508.          _loc1_.endFill();
  509.          _loc1_.beginFill(13421772,0.4);
  510.          _loc1_.drawRoundRect(calcX(_borderRect.x + 1),calcY(_borderRect.y + 1),_borderRect.width - 2,_borderRect.height - 2,_borderRect.cornerRadius - 1 * 2,_borderRect.cornerRadius - 1 * 2);
  511.          _loc1_.endFill();
  512.          _loc4_ = _barFrameSprite.graphics;
  513.          (_loc5_ = new Matrix()).createGradientBox(_barFrameRect.width,_barFrameRect.height,Math.PI / 2,calcX(_barFrameRect.x),calcY(_barFrameRect.y));
  514.          _loc4_.beginGradientFill(GradientType.LINEAR,[6054502,11909306],[1,1],[0,255],_loc5_);
  515.          _loc4_.drawRoundRect(calcX(_barFrameRect.x),calcY(_barFrameRect.y),_barFrameRect.width,_barFrameRect.height,_barFrameRect.cornerRadius * 2,_barFrameRect.cornerRadius * 2);
  516.          _loc4_.drawRoundRect(calcX(_barFrameRect.x + 1),calcY(_barFrameRect.y + 1),_barFrameRect.width - 2,_barFrameRect.height - 2,_barFrameRect.cornerRadius * 2,_barFrameRect.cornerRadius * 2);
  517.          _loc4_.endFill();
  518.          _labelObj = new TextField();
  519.          _labelObj.x = calcX(_labelRect.x);
  520.          _labelObj.y = calcY(_labelRect.y);
  521.          _labelObj.width = _labelRect.width;
  522.          _labelObj.height = _labelRect.height;
  523.          _labelObj.selectable = false;
  524.          _labelObj.defaultTextFormat = labelFormat;
  525.          addChild(_labelObj);
  526.          _percentObj = new TextField();
  527.          _percentObj.x = calcX(_percentRect.x);
  528.          _percentObj.y = calcY(_percentRect.y);
  529.          _percentObj.width = _percentRect.width;
  530.          _percentObj.height = _percentRect.height;
  531.          _percentObj.selectable = false;
  532.          _percentObj.defaultTextFormat = percentFormat;
  533.          addChild(_percentObj);
  534.          (_loc6_ = new RectangularDropShadow()).color = 0;
  535.          _loc6_.angle = 90;
  536.          _loc6_.alpha = 0.6;
  537.          _loc6_.distance = 2;
  538.          _loc6_.tlRadius = _loc6_.trRadius = _loc6_.blRadius = _loc6_.brRadius = _borderRect.cornerRadius;
  539.          _loc6_.drawShadow(_loc1_,calcX(_borderRect.x),calcY(_borderRect.y),_borderRect.width,_borderRect.height);
  540.          _loc1_.lineStyle(1,16777215,0.3);
  541.          _loc1_.moveTo(calcX(_borderRect.x) + _borderRect.cornerRadius,calcY(_borderRect.y));
  542.          _loc1_.lineTo(calcX(_borderRect.x) - _borderRect.cornerRadius + _borderRect.width,calcY(_borderRect.y));
  543.       }
  544.       
  545.       private function loadBackgroundImage(param1:Object) : void
  546.       {
  547.          var cls:Class = null;
  548.          var newStyleObj:DisplayObject = null;
  549.          var loader:Loader = null;
  550.          var loaderContext:LoaderContext = null;
  551.          var classOrString:Object = param1;
  552.          if(Boolean(classOrString) && Boolean(classOrString as Class))
  553.          {
  554.             cls = Class(classOrString);
  555.             initBackgroundImage(new cls());
  556.          }
  557.          else if(Boolean(classOrString) && classOrString is String)
  558.          {
  559.             try
  560.             {
  561.                cls = Class(getDefinitionByName(String(classOrString)));
  562.             }
  563.             catch(e:Error)
  564.             {
  565.             }
  566.             if(cls)
  567.             {
  568.                newStyleObj = new cls();
  569.                initBackgroundImage(newStyleObj);
  570.             }
  571.             else
  572.             {
  573.                loader = new Loader();
  574.                loader.contentLoaderInfo.addEventListener(Event.COMPLETE,loader_completeHandler);
  575.                loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,loader_ioErrorHandler);
  576.                loaderContext = new LoaderContext();
  577.                loaderContext.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
  578.                loader.load(new URLRequest(String(classOrString)),loaderContext);
  579.             }
  580.          }
  581.       }
  582.       
  583.       private function hide() : void
  584.       {
  585.       }
  586.       
  587.       private function draw() : void
  588.       {
  589.          var _loc1_:Number = NaN;
  590.          if(_startedLoading)
  591.          {
  592.             if(!_startedInit)
  593.             {
  594.                _loc1_ = Math.round(getPercentLoaded(_value,_maximum) * DOWNLOAD_PERCENTAGE / 100);
  595.             }
  596.             else
  597.             {
  598.                _loc1_ = Math.round(getPercentLoaded(_value,_maximum) * (100 - DOWNLOAD_PERCENTAGE) / 100 + DOWNLOAD_PERCENTAGE);
  599.             }
  600.          }
  601.          else
  602.          {
  603.             _loc1_ = getPercentLoaded(_value,_maximum);
  604.          }
  605.          if(_labelObj)
  606.          {
  607.             _labelObj.text = _label;
  608.          }
  609.          if(_percentObj)
  610.          {
  611.             if(!_showPercentage)
  612.             {
  613.                _percentObj.visible = false;
  614.                _percentObj.text = "";
  615.             }
  616.             else
  617.             {
  618.                _percentObj.text = String(_loc1_) + "%";
  619.             }
  620.          }
  621.          if(Boolean(_barSprite) && Boolean(_barFrameSprite))
  622.          {
  623.             if(!_showProgressBar)
  624.             {
  625.                _barSprite.visible = false;
  626.                _barFrameSprite.visible = false;
  627.             }
  628.             else
  629.             {
  630.                drawProgressBar(_loc1_);
  631.             }
  632.          }
  633.       }
  634.       
  635.       protected function initProgressHandler(param1:Event) : void
  636.       {
  637.          var _loc2_:int = 0;
  638.          var _loc3_:Number = NaN;
  639.          _loc2_ = getTimer() - _startTime;
  640.          ++_initProgressCount;
  641.          if(!_showingDisplay && showDisplayForInit(_loc2_,_initProgressCount))
  642.          {
  643.             _displayStartCount = _initProgressCount;
  644.             show();
  645.          }
  646.          else if(_showingDisplay)
  647.          {
  648.             if(!_startedInit)
  649.             {
  650.                _startedInit = true;
  651.                label = initializingLabel;
  652.             }
  653.             _loc3_ = 100 * _initProgressCount / (_initProgressTotal - _displayStartCount);
  654.             setProgress(_loc3_,100);
  655.          }
  656.       }
  657.       
  658.       protected function get label() : String
  659.       {
  660.          return _label;
  661.       }
  662.       
  663.       protected function getPercentLoaded(param1:Number, param2:Number) : Number
  664.       {
  665.          var _loc3_:Number = NaN;
  666.          if(param1 == 0 || param2 == 0 || isNaN(param2) || isNaN(param1))
  667.          {
  668.             return 0;
  669.          }
  670.          _loc3_ = 100 * param1 / param2;
  671.          if(isNaN(_loc3_) || _loc3_ <= 0)
  672.          {
  673.             return 0;
  674.          }
  675.          if(_loc3_ > 99)
  676.          {
  677.             return 99;
  678.          }
  679.          return Math.round(_loc3_);
  680.       }
  681.       
  682.       protected function set downloadingLabel(param1:String) : void
  683.       {
  684.          _downloadingLabel = param1;
  685.       }
  686.       
  687.       public function get stageWidth() : Number
  688.       {
  689.          return _stageWidth;
  690.       }
  691.       
  692.       public function set stageHeight(param1:Number) : void
  693.       {
  694.          _stageHeight = param1;
  695.       }
  696.       
  697.       protected function get showPercentage() : Boolean
  698.       {
  699.          return _showPercentage;
  700.       }
  701.       
  702.       public function initialize() : void
  703.       {
  704.          _startTime = getTimer();
  705.          center(stageWidth,stageHeight);
  706.       }
  707.       
  708.       private function initBackgroundImage(param1:DisplayObject) : void
  709.       {
  710.          var _loc2_:Number = NaN;
  711.          var _loc3_:Number = NaN;
  712.          var _loc4_:Number = NaN;
  713.          var _loc5_:Number = NaN;
  714.          var _loc6_:Number = NaN;
  715.          var _loc7_:Number = NaN;
  716.          var _loc8_:Number = NaN;
  717.          var _loc9_:Number = NaN;
  718.          addChildAt(param1,0);
  719.          _loc2_ = param1.width;
  720.          _loc3_ = param1.height;
  721.          _loc4_ = calcBackgroundSize();
  722.          if(isNaN(_loc4_))
  723.          {
  724.             _loc7_ = 1;
  725.             _loc8_ = 1;
  726.          }
  727.          else
  728.          {
  729.             _loc7_ = (_loc9_ = _loc4_ * 0.01) * stageWidth / _loc2_;
  730.             _loc8_ = _loc9_ * stageHeight / _loc3_;
  731.          }
  732.          param1.scaleX = _loc7_;
  733.          param1.scaleY = _loc8_;
  734.          _loc5_ = Math.round(0.5 * (stageWidth - _loc2_ * _loc7_));
  735.          _loc6_ = Math.round(0.5 * (stageHeight - _loc3_ * _loc8_));
  736.          param1.x = _loc5_;
  737.          param1.y = _loc6_;
  738.          if(!isNaN(backgroundAlpha))
  739.          {
  740.             param1.alpha = backgroundAlpha;
  741.          }
  742.       }
  743.       
  744.       public function set backgroundImage(param1:Object) : void
  745.       {
  746.          _backgroundImage = param1;
  747.       }
  748.       
  749.       public function set backgroundAlpha(param1:Number) : void
  750.       {
  751.          _backgroundAlpha = param1;
  752.       }
  753.       
  754.       public function set backgroundColor(param1:uint) : void
  755.       {
  756.          _backgroundColor = param1;
  757.       }
  758.       
  759.       private function loader_completeHandler(param1:Event) : void
  760.       {
  761.          var _loc2_:DisplayObject = null;
  762.          _loc2_ = DisplayObject(LoaderInfo(param1.target).loader);
  763.          initBackgroundImage(_loc2_);
  764.       }
  765.       
  766.       public function get stageHeight() : Number
  767.       {
  768.          return _stageHeight;
  769.       }
  770.       
  771.       protected function get percentRect() : Rectangle
  772.       {
  773.          return new Rectangle(108,4,34,16);
  774.       }
  775.       
  776.       protected function completeHandler(param1:Event) : void
  777.       {
  778.       }
  779.       
  780.       protected function set label(param1:String) : void
  781.       {
  782.          if(!(param1 is Function))
  783.          {
  784.             _label = param1;
  785.          }
  786.          draw();
  787.       }
  788.       
  789.       protected function get showLabel() : Boolean
  790.       {
  791.          return _showLabel;
  792.       }
  793.    }
  794. }
  795.