FlashImp Flash Implosion new generation

[Frame(factoryClass="ru.kozlovskij.preload.Preloader")]

[App(className='ИмяГлавногоКласса')]

package {
	import flash.display.FrameLabel;
	import flash.display.MovieClip;
	import flash.events.Event;
	import flash.utils.*;
 
	import ru.kozlovskij.core.Application;
	import ru.kozlovskij.preload.Preloader;
 
	/**
	* SWF metadata
	*/
	[SWF(backgroundColor='0xFFCC00', width='500', height='500')]
 
	/**
	* The frameworks must be initialized by SystemManager.
	* This factoryClass will be automatically subclassed by any
	* MXML applications that don't explicitly specify a different
	* factoryClass.
	*
	* NOTE: Minimize the non-Flash classes you import here.
	* Any dependencies of SystemManager have to load in frame 1,
	* before the preloader, or anything else, can be displayed.
	*/
	[Frame(factoryClass='ru.kozlovskij.preload.Preloader')]
	//[Frame(factoryClass='exampleClasses.MyPreloader')]
 
	/**
	* Custom metadata tags
	*/
	[App(type='module', className='Main')]
	[copyrights(firstName='Aleksandr', lastName='Kozlovskij', url='http://Kozlovskij.ru', blog='http://FlashImp.ru')]
	public class Main extends Application
	{
		public function Main()
		{
			super();
			addEventListener(Preloader.PRELOADER_DONE, preloaderDoneHandler);
		}
 
		private function preloaderDoneHandler(e:Event):void
		{
			//initialize...
			for(var i:int; i < (parent as MovieClip).currentLabels.length; ++i)
				trace('FrameLabel:', '[', FrameLabel((parent as MovieClip).currentLabels[i]).name,
					  ',', FrameLabel((parent as MovieClip).currentLabels[i]).frame, ']');
			(parent as MovieClip).nextFrame();
			parent.addChild(new (flash.utils.getDefinitionByName('exampleClasses.CustomFrame') as Class)());
		}
	}
}

package ru.kozlovskij.preload
{
	import flash.display.DisplayObject;
	import flash.display.MovieClip;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.system.ApplicationDomain;
	import flash.utils.ByteArray;
 
	import ru.etcs.utils.ClassExplorer;
 
	[Event(name="preloaderDone", type="ru.kozlovskij.preload.Preloader")]
	public class Preloader extends MovieClip
	{
		public static const PRELOADER_DONE:String = 'preloaderDone';
 
		protected var MAINCLASS_NAME:String;
 
		protected var preloaderGraphics:IPreloaderGraphics;
 
		private var Main:Class;
		private var main:DisplayObject;
 
		protected var _standalone:Boolean = true;
		protected function get standalone():Boolean
		{return _standalone;}
 
		public function Preloader(preloaderGraphics:IPreloaderGraphics = null)
		{
			stop();
 
			this.preloaderGraphics = preloaderGraphics ? preloaderGraphics : new PreloaderGraphics();
 
			if(stage)
				stage.scaleMode = StageScaleMode.NO_SCALE,
				stage.align = StageAlign.TOP_LEFT,
				stage.frameRate = 31,
				createGraphics(),
				stage.addEventListener(Event.RESIZE, resizeHandler);
			else
				_standalone = false;
 
			addEventListener(Event.ENTER_FRAME, enterFrameHandler);
 
			resizeHandler();
		}
 
		protected function createGraphics():void
		{
			addChild(preloaderGraphics as DisplayObject);
		}
 
		private function enterFrameHandler(e:Event):void
		{
			//percent = current / total
			var percent:Number = root.loaderInfo.bytesLoaded / root.loaderInfo.bytesTotal;
			preloaderGraphics.percent = percent * 100;
 
			//trace(Math.round(100 * percent) + '%');
 
			if(framesLoaded == totalFrames)
			{
				removeEventListener(Event.ENTER_FRAME, enterFrameHandler);
 
				//Move to the next frame when we're done
				//Moving to frame 1(!)
				nextFrame();
 
				preinit();
			}
		}
 
		protected function resizeHandler(e:Event = null):void
		{
			preloaderGraphics.x = stage ? stage.stageWidth / 2 : root.width / 2,
			preloaderGraphics.y = stage ? stage.stageHeight / 2 : root.height / 2;
		}
 
		private function preinit(mainclass_name_from_metadata:String = null):void
		{
			var needThrow:Boolean = true;
			MAINCLASS_NAME = mainclass_name_from_metadata ? mainclass_name_from_metadata :
							 MAINCLASS_NAME ? MAINCLASS_NAME : null;
			MAINCLASS_NAME ? null : (needThrow = false, getMETAMainClassName());
			if(needThrow && !MAINCLASS_NAME)
			{
				clear();
				throw new Error(this.toString() + ': Main Class Definition eq null');
			}
 
			var has:Boolean = ApplicationDomain.currentDomain.hasDefinition(MAINCLASS_NAME);
			if(has)//if main app
				Main = ApplicationDomain.currentDomain.getDefinition(MAINCLASS_NAME) as Class;
			else
			{
				has = loaderInfo.applicationDomain.hasDefinition(MAINCLASS_NAME);
				if(has)//if module app
					Main = loaderInfo.applicationDomain.getDefinition(MAINCLASS_NAME) as Class;
			}
 
			if(has)
			{
				//and instantiate our Main class
				main = new Main();
 
				//get urls, whot need to additional preloading before starting application (in next post..)
 
				init();
				clear();
			}
			else
			if(needThrow)
			{
				clear();
				throw new Error(this.toString() + ': Main Class Definition NOT FOUND');
			}
		}
 
		private function init():void
		{
			//finally we add main class to the DisplayList and dispatching event
			addChild(main as DisplayObject).dispatchEvent(new Event(PRELOADER_DONE));
 
			//stage.addChild(main as DisplayObject) - only if we make a standalone app.
		}
 
		public function clear():void
		{
			//killing & clearing preloaderGraphics :)
			IPreloaderGraphics(removeChild(preloaderGraphics as DisplayObject)).clear();
 
			standalone ? (stage.removeEventListener(Event.RESIZE, resizeHandler), stage.removeChild(this)) : null;
		}
 
		//-----------------------------------------------------//
		private function getMETAMainClassName():void
		{
			var bytes:ByteArray = new ByteArray();
				bytes.objectEncoding = 3;
				bytes.writeBytes(loaderInfo.bytes);
				bytes.position = 0;
			var explorer:ClassExplorer = new ClassExplorer();
				explorer.loadBytes(bytes);
				explorer.addEventListener(Event.COMPLETE, explorerWorkCompleteHandler);
		}
 
		private function explorerWorkCompleteHandler(e:Event):void
		{
			var explorer:ClassExplorer = e.target as ClassExplorer;
			var xml:XML = explorer.getDefinitionInfo();
			//trace(xml.toXMLString());
			var className:String;
			className = xml.definition/*.(@name == 'frame2')*/.script.classTrait.metadata.(@name == 'App').arg.(@key == 'className').@value.toString();
			preinit(className);
		}
	}
}

package ru.kozlovskij.preload
{
	import flash.display.Sprite;
	import flash.text.TextField;
	import flash.text.TextFormat;
	import flash.text.TextFormatAlign;
 
	public class PreloaderGraphics extends Sprite implements IPreloaderGraphics
	{
		private var text:TextField = new TextField();
 
		public function PreloaderGraphics()
		{
			super();
 
			addChild(text);
 
			text.defaultTextFormat = new TextFormat('Tahoma');
			text.defaultTextFormat.align = TextFormatAlign.CENTER,
			text.defaultTextFormat.size = 13,
			text.defaultTextFormat.letterSpacing = 1,
			text.defaultTextFormat.bold = true;
 
			text.borderColor = text.textColor = 0x0,
			text.selectable = !(text.border = true),
			text.width = 100,
			text.height = 50;
 
			percent = 0;
		}
 
		private var _percent:Number = 0;
		public function set percent(value:Number):void
		{
			_percent = value;
			text.text = 'Loading...\n' + uint(value) + '%';
		}
 
		public function get percent():Number
		{
			return _percent;
		}
 
		public function clear():void
		{
			removeChild(text);
		}
	}
}