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