| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one or more |
| // contributor license agreements. See the NOTICE file distributed with |
| // this work for additional information regarding copyright ownership. |
| // The ASF licenses this file to You under the Apache License, Version 2.0 |
| // (the "License"); you may not use this file except in compliance with |
| // the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| package mx.preloaders |
| { |
| |
| import flash.display.DisplayObject; |
| import flash.display.Graphics; |
| import flash.display.Loader; |
| import flash.display.LoaderInfo; |
| import flash.display.Sprite; |
| import flash.events.Event; |
| import flash.events.IOErrorEvent; |
| import flash.events.ProgressEvent; |
| import flash.geom.ColorTransform; |
| import flash.geom.Matrix; |
| import flash.net.URLRequest; |
| import flash.system.ApplicationDomain; |
| import flash.system.LoaderContext; |
| import flash.text.TextField; |
| import flash.text.TextFormat; |
| import flash.utils.getDefinitionByName; |
| import flash.utils.getTimer; |
| |
| import mx.events.FlexEvent; |
| import mx.events.RSLEvent; |
| import mx.graphics.RectangularDropShadow; |
| import mx.managers.ISystemManager; |
| |
| /** |
| * The SparkDownloadProgressBar class displays download progress. |
| * It is used by the Preloader control to provide user feedback |
| * while the application is downloading and loading. |
| * |
| * <p>The download progress bar displays information about |
| * two different phases of the application: |
| * the download phase and the initialization phase. </p> |
| * |
| * <p>In the Application container, use the |
| * the <code>preloader</code> property to specify the name of your subclass.</p> |
| * |
| * <p>You can implement a custom download progress bar component |
| * by creating a subclass of the SparkDownloadProgressBar class. |
| * Do not implement a download progress bar as an MXML component |
| * because it loads too slowly.</p> |
| * |
| * @see mx.core.Application |
| * @see mx.preloaders.IPreloaderDisplay |
| * @see mx.preloaders.Preloader |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| public class SparkDownloadProgressBar extends Sprite implements IPreloaderDisplay |
| { |
| include "../core/Version.as"; |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Constructor |
| // |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * Constructor. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| public function SparkDownloadProgressBar() |
| { |
| super(); |
| } |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Variables |
| // |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * @private |
| */ |
| private var _barWidth:Number; |
| |
| /** |
| * @private |
| */ |
| private var _bgSprite:Sprite; |
| |
| /** |
| * @private |
| */ |
| private var _barSprite:Sprite; |
| |
| /** |
| * @private |
| */ |
| private var _barFrameSprite:Sprite; |
| |
| /** |
| * @private |
| */ |
| private var _startTime:int; |
| |
| /** |
| * @private |
| */ |
| private var _showingDisplay:Boolean = false; |
| |
| /** |
| * @private |
| */ |
| private var _downloadComplete:Boolean = false; |
| |
| /** |
| * @private |
| */ |
| private var _displayStartCount:uint = 0; |
| |
| /** |
| * @private |
| */ |
| private var _initProgressCount:uint = 0; |
| |
| /** |
| * The total number of validation events you expect to get |
| * in the initializing phase. This should be an integer |
| * greater or equal to 4 (and note that if it is greater than 4 |
| * you might have an inefficiency in your initialization code) |
| * |
| * @default 6 |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected var initProgressTotal:uint = 6; |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Overridden properties |
| // |
| //-------------------------------------------------------------------------- |
| |
| //---------------------------------- |
| // visible |
| //---------------------------------- |
| |
| /** |
| * @private |
| * Storage for the visible property. |
| */ |
| private var _visible:Boolean = false; |
| |
| /** |
| * Specifies whether the download progress bar is visible. |
| * |
| * <p>When the Preloader control determines that the progress bar should be displayed, |
| * it sets this value to <code>true</code>. When the Preloader control determines that |
| * the progress bar should be hidden, it sets the value to <code>false</code>.</p> |
| * |
| * <p>A subclass of the SparkDownloadProgressBar class should never modify this property. |
| * Instead, you can override the setter method to recognize when |
| * the Preloader control modifies it, and perform any necessary actions. </p> |
| * |
| * @default false |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| override public function get visible():Boolean |
| { |
| return _visible; |
| } |
| |
| /** |
| * @private |
| */ |
| override public function set visible(value:Boolean):void |
| { |
| if (!_visible && value) |
| show(); |
| |
| else if (_visible && !value ) |
| hide(); |
| |
| _visible = value; |
| } |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Properties: IPreloaderDisplay |
| // |
| //-------------------------------------------------------------------------- |
| |
| //---------------------------------- |
| // backgroundAlpha |
| //---------------------------------- |
| |
| /** |
| * @private |
| * Storage for the backgroundAlpha property. |
| */ |
| private var _backgroundAlpha:Number = 1; |
| |
| /** |
| * Alpha level of the SWF file or image defined by |
| * the <code>backgroundImage</code> property, or the color defined by |
| * the <code>backgroundColor</code> property. |
| * Valid values range from 0 to 1.0. |
| * Override this property to set your own value in a custom class. |
| * |
| * <p>You can specify either a <code>backgroundColor</code> |
| * or a <code>backgroundImage</code>, but not both.</p> |
| * |
| * @default 1.0 |
| * |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| public function get backgroundAlpha():Number |
| { |
| if (!isNaN(_backgroundAlpha)) |
| return _backgroundAlpha; |
| else |
| return 1; |
| } |
| |
| /** |
| * @private |
| */ |
| public function set backgroundAlpha(value:Number):void |
| { |
| _backgroundAlpha = value; |
| } |
| |
| //---------------------------------- |
| // backgroundColor |
| //---------------------------------- |
| |
| /** |
| * @private |
| * Storage for the backgroundColor property. |
| */ |
| private var _backgroundColor:uint; |
| |
| /** |
| * Background color of a download progress bar. |
| * Override this property to set your own value in a custom class. |
| * |
| * <p>You can specify either a <code>backgroundColor</code> |
| * or a <code>backgroundImage</code>, but not both.</p> |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| public function get backgroundColor():uint |
| { |
| return _backgroundColor; |
| } |
| |
| /** |
| * @private |
| */ |
| public function set backgroundColor(value:uint):void |
| { |
| _backgroundColor = value; |
| } |
| |
| //---------------------------------- |
| // backgroundImage |
| //---------------------------------- |
| |
| /** |
| * @private |
| * Storage for the backgroundImage property. |
| */ |
| private var _backgroundImage:Object; |
| |
| /** |
| * The background image of the application, |
| * which is passed in by the preloader. |
| * Override this property to set your own value in a custom class. |
| * |
| * <p>You can specify either a <code>backgroundColor</code> |
| * or a <code>backgroundImage</code>, but not both.</p> |
| * |
| * <p>A value of null means "not set". |
| * If this style and the <code>backgroundColor</code> style are undefined, |
| * the component has a transparent background.</p> |
| * |
| * <p>The preloader does not display embedded images. |
| * You can only use images loaded at runtime.</p> |
| * |
| * @default null |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| public function get backgroundImage():Object |
| { |
| return _backgroundImage; |
| } |
| |
| /** |
| * @private |
| */ |
| public function set backgroundImage(value:Object):void |
| { |
| _backgroundImage = value; |
| } |
| |
| //---------------------------------- |
| // backgroundSize |
| //---------------------------------- |
| |
| /** |
| * @private |
| * Storage for the backgroundSize property. |
| */ |
| private var _backgroundSize:String = ""; |
| |
| /** |
| * Scales the image specified by <code>backgroundImage</code> |
| * to different percentage sizes. |
| * A value of <code>"100%"</code> stretches the image |
| * to fit the entire component. |
| * To specify a percentage value, you must include the percent sign (%). |
| * A value of <code>"auto"</code>, maintains |
| * the original size of the image. |
| * |
| * @default "auto" |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| public function get backgroundSize():String |
| { |
| return _backgroundSize; |
| } |
| |
| /** |
| * @private |
| */ |
| public function set backgroundSize(value:String):void |
| { |
| _backgroundSize = value; |
| } |
| |
| //---------------------------------- |
| // preloader |
| //---------------------------------- |
| |
| /** |
| * @private |
| * Storage for the preloader property. |
| */ |
| private var _preloader:Sprite; |
| |
| /** |
| * The Preloader class passes in a reference to itself to the display class |
| * so that it can listen for events from the preloader. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| public function set preloader(value:Sprite):void |
| { |
| _preloader = value; |
| |
| value.addEventListener(ProgressEvent.PROGRESS, progressHandler); |
| value.addEventListener(Event.COMPLETE, completeHandler); |
| |
| value.addEventListener(RSLEvent.RSL_PROGRESS, rslProgressHandler); |
| value.addEventListener(RSLEvent.RSL_COMPLETE, rslCompleteHandler); |
| value.addEventListener(RSLEvent.RSL_ERROR, rslErrorHandler); |
| |
| value.addEventListener(FlexEvent.INIT_PROGRESS, initProgressHandler); |
| value.addEventListener(FlexEvent.INIT_COMPLETE, initCompleteHandler); |
| } |
| |
| //---------------------------------- |
| // stageHeight |
| //---------------------------------- |
| |
| /** |
| * @private |
| * Storage for the stageHeight property. |
| */ |
| private var _stageHeight:Number = 375; |
| |
| /** |
| * The height of the stage, |
| * which is passed in by the Preloader class. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| public function get stageHeight():Number |
| { |
| return _stageHeight; |
| } |
| |
| /** |
| * @private |
| */ |
| public function set stageHeight(value:Number):void |
| { |
| _stageHeight = value; |
| } |
| |
| //---------------------------------- |
| // stageWidth |
| //---------------------------------- |
| |
| /** |
| * @private |
| * Storage for the stageHeight property. |
| */ |
| private var _stageWidth:Number = 500; |
| |
| /** |
| * The width of the stage, |
| * which is passed in by the Preloader class. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| public function get stageWidth():Number |
| { |
| return _stageWidth; |
| } |
| |
| /** |
| * @private |
| */ |
| public function set stageWidth(value:Number):void |
| { |
| _stageWidth = value; |
| } |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Methods:IPreloaderDisplay |
| // |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * Called by the Preloader after the download progress bar |
| * has been added as a child of the Preloader. |
| * This should be the starting point for configuring your download progress bar. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| public function initialize():void |
| { |
| _startTime = getTimer(); |
| } |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Methods |
| // |
| //-------------------------------------------------------------------------- |
| |
| |
| /** |
| * Creates the subcomponents of the display. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function createChildren():void |
| { |
| var g:Graphics = graphics; |
| |
| // Draw the background first |
| // Same value as StyleManager.NOT_A_COLOR. However, we don't want to bring in StyleManager at this point. |
| if (backgroundColor != 0xFFFFFFFF) |
| { |
| g.beginFill(backgroundColor, backgroundAlpha); |
| g.drawRect(0, 0, stageWidth, stageHeight); |
| } |
| |
| if (backgroundImage != null) |
| loadBackgroundImage(backgroundImage); |
| |
| // Determine the size |
| var totalWidth:Number = Math.min(stageWidth - 10, 207); |
| var totalHeight:Number = 19; |
| var startX:Number = Math.round((stageWidth - totalWidth) / 2); |
| var startY:Number = Math.round((stageHeight - totalHeight) / 2); |
| |
| _barWidth = totalWidth - 10; |
| |
| _bgSprite = new Sprite(); |
| _barFrameSprite = new Sprite(); |
| _barSprite = new Sprite(); |
| |
| addChild(_bgSprite); |
| addChild(_barFrameSprite); |
| addChild(_barSprite); |
| |
| _barFrameSprite.x = _barSprite.x = startX + 5; |
| _barFrameSprite.y = _barSprite.y = startY + 5; |
| |
| // Draw the background/shadow |
| g = _bgSprite.graphics; |
| g.lineStyle(1, 0x636363); |
| g.beginFill(0xE8E8E8); |
| g.drawRect(startX, startY, totalWidth, totalHeight); |
| g.endFill(); |
| g.lineStyle(); |
| |
| g = graphics; |
| var ds:RectangularDropShadow = new RectangularDropShadow(); |
| ds.color = 0x000000; |
| ds.angle = 90; |
| ds.alpha = .6; |
| ds.distance = 2; |
| ds.drawShadow(g, |
| startX, |
| startY, |
| totalWidth, |
| totalHeight); |
| |
| var chromeColor:uint = getPreloaderChromeColor(); |
| if (chromeColor != DEFAULT_COLOR) |
| { |
| var colorTransform:ColorTransform = new ColorTransform(); |
| |
| colorTransform.redOffset = ((chromeColor & (0xFF << 16)) >> 16) - DEFAULT_COLOR_VALUE; |
| colorTransform.greenOffset = ((chromeColor & (0xFF << 8)) >> 8) - DEFAULT_COLOR_VALUE; |
| colorTransform.blueOffset = (chromeColor & 0xFF) - DEFAULT_COLOR_VALUE; |
| |
| _bgSprite.transform.colorTransform = colorTransform; |
| _barFrameSprite.transform.colorTransform = colorTransform; |
| _barSprite.transform.colorTransform = colorTransform; |
| } |
| } |
| |
| private static const DEFAULT_COLOR:uint = 0xCCCCCC; |
| private static const DEFAULT_COLOR_VALUE:uint = 0xCC; |
| |
| /** |
| * @private |
| * We don't have a reliable way to get the system manager for the currently |
| * loading application. During normal progres bar instantiation, the parent.parent |
| * is the system manager loading the app, so that is what we'll use. |
| * This is only needed to grab the "preloaderChromeColor" property from the info() |
| * structure. |
| */ |
| private function getPreloaderChromeColor():uint |
| { |
| const sm:ISystemManager = parent.parent as ISystemManager; |
| const valueObject:Object = (sm) ? sm.info()["preloaderChromeColor"] : null; |
| |
| var valueString:String = valueObject as String; |
| if (valueString && (valueString.charAt(0) == "#")) |
| valueString = "0x" + valueString.substring(1); |
| |
| return (valueString) ? uint(valueString) : DEFAULT_COLOR; |
| } |
| |
| private var lastBarWidth:Number = 0; |
| |
| /** |
| * Updates the outer portion of the download progress bar to |
| * indicate download progress. |
| * |
| * @param completed Number of bytes of the application SWF file |
| * that have been downloaded. |
| * |
| * @param total Size of the application SWF file in bytes. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function setDownloadProgress(completed:Number, total:Number):void |
| { |
| if (!_barFrameSprite) |
| return; |
| |
| const outerHighlightColors:Array = [0xFFFFFF, 0xFFFFFF]; |
| const outerHighlightAlphas:Array = [0.12, 0.80]; |
| const fillColors:Array = [0xA9A9A9, 0xBDBDBD]; |
| const fillAlphas:Array = [1, 1]; |
| const ratios:Array = [0, 255]; |
| |
| var w:Number = Math.round(_barWidth * Math.min(completed / total, 1)); |
| var h:Number = 9; |
| var g:Graphics = _barFrameSprite.graphics; |
| var m:Matrix = new Matrix(); |
| |
| // Make sure the download progress bar never regresses in size. |
| w = Math.max(w, lastBarWidth); |
| lastBarWidth = w; |
| |
| m.createGradientBox(w, h, 90); |
| |
| g.clear(); |
| |
| // Outer highlight |
| g.lineStyle(1); |
| g.lineGradientStyle("linear", outerHighlightColors, outerHighlightAlphas, ratios, m); |
| g.drawRect(0, 0, w, h); |
| |
| // border/fill |
| g.lineStyle(1, 0x636363); |
| g.beginGradientFill("linear", fillColors, fillAlphas, ratios, m); |
| g.drawRect(1, 1, w - 2, h - 2); |
| g.endFill(); |
| |
| // highlight |
| g.lineStyle(1, 0, 0.12); |
| g.moveTo(2, h - 1); |
| g.lineTo(2, 2); |
| g.lineTo(w - 2, 2); |
| g.lineTo(w - 2, h - 1); |
| |
| if (completed == total) |
| _downloadComplete = true |
| } |
| |
| |
| /** |
| * Updates the inner portion of the download progress bar to |
| * indicate initialization progress. |
| * |
| * @param completed Number of initialization steps that |
| * have been completed |
| * |
| * @param total Total number of initialization steps |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function setInitProgress(completed:Number, total:Number):void |
| { |
| const highlightColors:Array = [0xFFFFFF, 0xEAEAEA]; |
| const fillColors:Array = [0xFFFFFF, 0xD8D8D8]; |
| const alphas:Array = [1, 1]; |
| const ratios:Array = [0, 255]; |
| |
| var w:Number = Math.round(_barWidth * Math.min(completed / total, 1)); |
| var h:Number = 9; |
| var g:Graphics = _barSprite.graphics; |
| var m:Matrix = new Matrix(); |
| |
| m.createGradientBox(w - 6, h - 2, 90, 2, 2); |
| |
| g.clear(); |
| |
| // highlight/fill |
| g.lineStyle(1); |
| g.lineGradientStyle("linear", highlightColors, alphas, ratios, m); |
| g.beginGradientFill("linear", fillColors, alphas, ratios, m); |
| g.drawRect(2, 2, w - 4, h - 4); |
| g.endFill(); |
| |
| // divider line |
| g.lineStyle(1, 0, 0.55); |
| g.moveTo(w - 1, 2); |
| g.lineTo(w - 1, h - 1); |
| } |
| |
| /** |
| * @private |
| * Make the display class visible. |
| */ |
| private function show():void |
| { |
| // swfobject reports 0 sometimes at startup |
| // if we get zero, wait and try on next attempt |
| if (stageWidth == 0 && stageHeight == 0) |
| { |
| try |
| { |
| stageWidth = stage.stageWidth; |
| stageHeight = stage.stageHeight |
| } |
| catch (e:Error) |
| { |
| stageWidth = loaderInfo.width; |
| stageHeight = loaderInfo.height; |
| } |
| if (stageWidth == 0 && stageHeight == 0) |
| return; |
| } |
| |
| _showingDisplay = true; |
| createChildren(); |
| } |
| |
| /** |
| * @private |
| */ |
| private function hide():void |
| { |
| } |
| |
| /** |
| * Defines the algorithm for determining whether to show |
| * the download progress bar while in the download phase. |
| * |
| * @param elapsedTime Number of milliseconds that have elapsed |
| * since the start of the download phase. |
| * |
| * @param event The ProgressEvent object that contains |
| * the <code>bytesLoaded</code> and <code>bytesTotal</code> properties. |
| * |
| * @return If the return value is <code>true</code>, then show the |
| * download progress bar. |
| * The default behavior is to show the download progress bar |
| * if more than 700 milliseconds have elapsed |
| * and if Flex has downloaded less than half of the bytes of the SWF file. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function showDisplayForDownloading(elapsedTime:int, |
| event:ProgressEvent):Boolean |
| { |
| // trace("showDisplayForDownloading: elapsedTime = " + elapsedTime); |
| // trace("showDisplayForDownloading:" + event.bytesLoaded + " " + event.bytesTotal + " " + (event.bytesLoaded < event.bytesTotal / 2)); |
| return elapsedTime > 700 && |
| event.bytesLoaded < event.bytesTotal / 2; |
| } |
| |
| /** |
| * Defines the algorithm for determining whether to show the download progress bar |
| * while in the initialization phase, assuming that the display |
| * is not currently visible. |
| * |
| * @param elapsedTime Number of milliseconds that have elapsed |
| * since the start of the download phase. |
| * |
| * @param count number of times that the <code>initProgress</code> event |
| * has been received from the application. |
| * |
| * @return If <code>true</code>, then show the download progress bar. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function showDisplayForInit(elapsedTime:int, count:int):Boolean |
| { |
| // trace("showDisplayForInit: elapsedTime = " + elapsedTime + " count = " + count); |
| return elapsedTime > 300 && count == 2; |
| } |
| |
| |
| /** |
| * @private |
| */ |
| private function loadBackgroundImage(classOrString:Object):void |
| { |
| var cls:Class; |
| |
| // The "as" operator checks to see if classOrString |
| // can be coerced to a Class |
| if (classOrString && classOrString as Class) |
| { |
| // Load background image given a class pointer |
| cls = Class(classOrString); |
| initBackgroundImage(new cls()); |
| } |
| else if (classOrString && classOrString is String) |
| { |
| try |
| { |
| cls = Class(getDefinitionByName(String(classOrString))); |
| } |
| catch(e:Error) |
| { |
| // ignore |
| } |
| |
| if (cls) |
| { |
| var newStyleObj:DisplayObject = new cls(); |
| initBackgroundImage(newStyleObj); |
| } |
| else |
| { |
| // Loading the image is slightly different |
| // than in Loader.loadContent()... is this on purpose? |
| |
| // Load background image from external URL |
| var loader:Loader = new Loader(); |
| loader.contentLoaderInfo.addEventListener( |
| Event.COMPLETE, loader_completeHandler); |
| loader.contentLoaderInfo.addEventListener( |
| IOErrorEvent.IO_ERROR, loader_ioErrorHandler); |
| var loaderContext:LoaderContext = new LoaderContext(); |
| loaderContext.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain); |
| loader.load(new URLRequest(String(classOrString)), loaderContext); |
| } |
| } |
| } |
| |
| /** |
| * @private |
| */ |
| private function initBackgroundImage(image:DisplayObject):void |
| { |
| addChildAt(image,0); |
| |
| var backgroundImageWidth:Number = image.width; |
| var backgroundImageHeight:Number = image.height; |
| |
| // Scale according to backgroundSize |
| var percentage:Number = calcBackgroundSize(); |
| if (isNaN(percentage)) |
| { |
| var sX:Number = 1.0; |
| var sY:Number = 1.0; |
| } |
| else |
| { |
| var scale:Number = percentage * 0.01; |
| sX = scale * stageWidth / backgroundImageWidth; |
| sY = scale * stageHeight / backgroundImageHeight; |
| } |
| |
| image.scaleX = sX; |
| image.scaleY = sY; |
| |
| // Center everything. |
| // Use a scrollRect to position and clip the image. |
| var offsetX:Number = |
| Math.round(0.5 * (stageWidth - backgroundImageWidth * sX)); |
| var offsetY:Number = |
| Math.round(0.5 * (stageHeight - backgroundImageHeight * sY)); |
| |
| image.x = offsetX; |
| image.y = offsetY; |
| |
| // Adjust alpha to match backgroundAlpha |
| if (!isNaN(backgroundAlpha)) |
| image.alpha = backgroundAlpha; |
| } |
| |
| /** |
| * @private |
| */ |
| private function calcBackgroundSize():Number |
| { |
| var percentage:Number = NaN; |
| |
| if (backgroundSize) |
| { |
| var index:int = backgroundSize.indexOf("%"); |
| if (index != -1) |
| percentage = Number(backgroundSize.substr(0, index)); |
| } |
| |
| return percentage; |
| } |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Event handlers |
| // |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * Event listener for the <code>ProgressEvent.PROGRESS</code> event. |
| * This implementation updates the progress bar |
| * with the percentage of bytes downloaded. |
| * |
| * @param event The event object. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function progressHandler(event:ProgressEvent):void |
| { |
| var loaded:uint = event.bytesLoaded; |
| var total:uint = event.bytesTotal; |
| |
| var elapsedTime:int = getTimer() - _startTime; |
| |
| // Only show the Loading phase if it will appear for awhile. |
| if (!_showingDisplay && showDisplayForDownloading(elapsedTime, event)) |
| show(); |
| |
| if (_showingDisplay) |
| setDownloadProgress(event.bytesLoaded, event.bytesTotal); |
| } |
| |
| /** |
| * Event listener for the <code>Event.COMPLETE</code> event. |
| * The default implementation does nothing. |
| * |
| * @param event The event object. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function completeHandler(event:Event):void |
| { |
| } |
| |
| /** |
| * Event listener for the <code>RSLEvent.RSL_PROGRESS</code> event. |
| * The default implementation does nothing. |
| * |
| * @param event The event object. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function rslProgressHandler(event:RSLEvent):void |
| { |
| } |
| |
| /** |
| * Event listener for the <code>RSLEvent.RSL_COMPLETE</code> event. |
| * |
| * @param event The event object. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function rslCompleteHandler(event:RSLEvent):void |
| { |
| //trace("rsl " + event.rslIndex + " of " + event.rslTotal); |
| } |
| |
| /** |
| * Event listener for the <code>RSLEvent.RSL_ERROR</code> event. |
| * This event listner handles any errors detected when downloading an RSL. |
| * |
| * @param event The event object. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function rslErrorHandler(event:RSLEvent):void |
| { |
| _preloader.removeEventListener(ProgressEvent.PROGRESS, |
| progressHandler); |
| |
| _preloader.removeEventListener(Event.COMPLETE, |
| completeHandler); |
| |
| _preloader.removeEventListener(RSLEvent.RSL_PROGRESS, |
| rslProgressHandler); |
| |
| _preloader.removeEventListener(RSLEvent.RSL_COMPLETE, |
| rslCompleteHandler); |
| |
| _preloader.removeEventListener(RSLEvent.RSL_ERROR, |
| rslErrorHandler); |
| |
| _preloader.removeEventListener(FlexEvent.INIT_PROGRESS, |
| initProgressHandler); |
| |
| _preloader.removeEventListener(FlexEvent.INIT_COMPLETE, |
| initCompleteHandler); |
| |
| if (!_showingDisplay) |
| { |
| show(); |
| // Call setDownloadProgress here to draw |
| // the progress bar background. |
| setDownloadProgress(100, 100); |
| } |
| |
| var errorField:ErrorField = new ErrorField(this); |
| errorField.show(event.errorText); |
| } |
| |
| /** |
| * Event listener for the <code>FlexEvent.INIT_PROGRESS</code> event. |
| * This implementation updates the progress bar |
| * each time the event is dispatched. |
| * |
| * @param event The event object. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function initProgressHandler(event:Event):void |
| { |
| // make elapsed time relative the time we started init. |
| if (_initProgressCount == 0) |
| _startTime = getTimer(); |
| |
| var elapsedTime:int = getTimer() - _startTime; |
| |
| _initProgressCount++; |
| |
| if (!_showingDisplay && |
| showDisplayForInit(elapsedTime, _initProgressCount)) |
| { |
| _displayStartCount = _initProgressCount; |
| show(); |
| |
| // If we are showing the progress for the first |
| // time here, we need to call setDownloadProgress() once to draw |
| // the progress bar background. |
| setDownloadProgress(100, 100); |
| } |
| |
| if (_showingDisplay) |
| { |
| // if show() did not actually show because of SWFObject bug |
| // then we may need to draw the download bar background here |
| if (!_downloadComplete) |
| setDownloadProgress(100, 100); |
| |
| setInitProgress(_initProgressCount, initProgressTotal); |
| } |
| } |
| |
| /** |
| * Event listener for the <code>FlexEvent.INIT_COMPLETE</code> event. |
| * This implementation dispatches a <code>Event.COMPLETE</code> event. |
| * |
| * @param event The event object |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 10 |
| * @playerversion AIR 1.5 |
| * @productversion Flex 4 |
| */ |
| protected function initCompleteHandler(event:Event):void |
| { |
| dispatchEvent(new Event(Event.COMPLETE)); |
| } |
| |
| /** |
| * @private |
| */ |
| private function loader_completeHandler(event:Event):void |
| { |
| var target:DisplayObject = DisplayObject(LoaderInfo(event.target).loader); |
| |
| initBackgroundImage(target); |
| } |
| |
| /** |
| * @private |
| */ |
| private function loader_ioErrorHandler(event:IOErrorEvent):void |
| { |
| // Swallow the error |
| } |
| |
| } |
| |
| } |
| |
| import flash.display.DisplayObject; |
| import flash.display.Sprite; |
| import flash.text.TextField; |
| import flash.text.TextFormat; |
| import flash.system.Capabilities; |
| import flash.text.TextFieldAutoSize; |
| import flash.display.DisplayObjectContainer; |
| import flash.display.Stage; |
| import mx.preloaders.SparkDownloadProgressBar; |
| |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Constructor |
| // |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * @private |
| * |
| * Area to display error messages to help debug startup problems. |
| * |
| */ |
| class ErrorField extends Sprite |
| { |
| private var downloadProgressBar:SparkDownloadProgressBar; |
| private const MIN_WIDTH_INCHES:int = 2; // min width of error message in inches |
| private const MAX_WIDTH_INCHES:int = 6; // max width of error message in inches |
| private const TEXT_MARGIN_PX:int = 10; |
| |
| |
| //---------------------------------- |
| // labelFormat |
| //---------------------------------- |
| |
| /** |
| * The TextFormat object of the TextField component of the label. |
| * This is a read-only property which you must override |
| * if you need to change it. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 9 |
| * @playerversion AIR 1.1 |
| * @productversion Flex 3 |
| */ |
| protected function get labelFormat():TextFormat |
| { |
| var tf:TextFormat = new TextFormat(); |
| tf.color = 0x000000; |
| |
| tf.font = "Arial"; |
| tf.size = 12; |
| return tf; |
| } |
| |
| |
| /** |
| * @private |
| * |
| * @param - parent - parent of the error field. |
| */ |
| public function ErrorField(downloadProgressBar:SparkDownloadProgressBar) |
| { |
| super(); |
| this.downloadProgressBar = downloadProgressBar; |
| } |
| |
| |
| /** |
| * Create and show the error message. |
| * |
| * @param errorText - text for error message. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 9 |
| * @playerversion AIR 1.1 |
| * @productversion Flex 3 |
| */ |
| public function show(errorText:String):void |
| { |
| if (errorText == null || errorText.length == 0) |
| return; |
| |
| var screenWidth:Number = downloadProgressBar.stageWidth; |
| var screenHeight:Number = downloadProgressBar.stageHeight; |
| |
| // create the text field for the message and |
| // add it to the parent. |
| var textField:TextField = new TextField(); |
| |
| textField.autoSize = TextFieldAutoSize.LEFT; |
| textField.multiline = true; |
| textField.wordWrap = true; |
| textField.background = true; |
| textField.defaultTextFormat = labelFormat; |
| textField.text = errorText; |
| |
| textField.width = Math.max(MIN_WIDTH_INCHES * Capabilities.screenDPI, screenWidth - (TEXT_MARGIN_PX * 2)); |
| textField.width = Math.min(MAX_WIDTH_INCHES * Capabilities.screenDPI, textField.width); |
| textField.y = Math.max(0, screenHeight - TEXT_MARGIN_PX - textField.height); |
| |
| // center field horizontally |
| textField.x = (screenWidth - textField.width) / 2; |
| |
| downloadProgressBar.parent.addChild(this); |
| this.addChild(textField); |
| |
| } |
| } |
