object..method(args)

// magic = MagicObject instance
// magic[keyA] = Renderer instance
// magic[keyB] = Renderer instance
// magic[keyB][keyC] = Renderer instance - sub-renderer
// magic.subMagic.[keyD] = Renderer instance - sub-renderer
(magic..update)();
// или так:
(magic..update)(magic.changes);

const result:Object = magic..update;
// можно вызвать:
result(); // or result(args);
// можно получить определённый элемент:
for(var key:String in magic)
	trace('in', magic, ':', key, '=', magic[key]),
	// или вызвать:
	magic[key] is Function && magic[key]();

const magic:MagicObject = new MagicObject();
magic.x = 0;
magic.x = 1;
 
// вернёт все изменения на первом уровней вложенности:
trace(magic.changes); // :Vector.
 
// вернёт все изменения на всех уровнях вложенности:
trace(magic..changes); // [:Vector.,..] или Vector. если элемент один.
 
// чистим историю изменений:
magic.clearChanges();
// or magic..clearChanges();

 const magic:MagicObject = new MagicObject();

magic.notificationCallback = function():void
	{
		trace('new changes:', magic.changes);
	}

magic.notificationCallback = function(changes:Vector.):void
	{
		trace('new changes:', changes);
	}

 magic.x = 0;
magic.x = 1;

package ru.kozlovskij.game.objects.data
{
	import ru.kozlovskij.utils.data.MagicNode;
	import ru.kozlovskij.utils.data.MagicObject;
 
	/**
	 * @author Aleksandr Kozlovskij (created: Dec 27, 2011)
	 */
	public dynamic class GameObjectData extends MagicObject
	{
		protected static const PRIVATE_ACCESSOR_PREFIX:String = '_';
 
		private var _notificationCallback:Function;
 
		//------------ constructor ------------//
 
		public function GameObjectData()
		{
			super();
			super.notificationCallback = __notificationCallback;
		}
 
		//------------ initialize ------------//
 
		//--------------- ctrl ---------------//
 
		//------------ get / set -------------//
 
		public function get selected():Boolean
		{
			return this._selected;
		}
 
		public function set selected(value:Boolean):void
		{
			this._selected = value;
		}
 
 
		override public function get notificationCallback():Function
		{
			return _notificationCallback;
		}
 
		override public function set notificationCallback(value:Function):void
		{
			_notificationCallback = value;
		}
 
		//------- handlers / callbacks -------//
 
		protected function __notificationCallback(changes:Vector.):void
		{
			const ns:Namespace = nodeResetNS;
			for each(var node:MagicNode in changes)
			{
				const property:String = node.public::property;
				if(property.charAt() == PRIVATE_ACCESSOR_PREFIX)
					node.ns::property = property.substr(1);
			}
 
			// finally:
			_notificationCallback && (_notificationCallback.length ? _notificationCallback(changes) : _notificationCallback());
		}
	}
}

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

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

<flex-config>
	<compiler>
	<keep-as3-metadata>
	<name>App</name>
	</keep-as3-metadata>
	</compiler>
</flex-config>

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);
		}
	}
}

<flex-config>
	<compiler>
		<keep-as3-metadata>
			<name>App</name>
		</keep-as3-metadata>
	</compiler>
	<frames>
		<frame>
			<label>newFrameName</label>
			<classname>exampleClasses.CustomFrame</classname>
		</frame>
	</frames>
</flex-config>