Model

package bassta.model{
 
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.display.LoaderInfo;
	import flash.text.StyleSheet;
 
	import com.greensock.loading.LoaderMax;
	import com.greensock.loading.ImageLoader;
	import com.greensock.loading.XMLLoader;
	import com.greensock.loading.CSSLoader;
 
	import com.greensock.events.LoaderEvent;
	import bassta.events.ModelEvent;	
	import bassta.events.PageEvent;
 
	import bassta.routing.Router;
	import bassta.structure.Initializer;
	import bassta.utils.Hash;	
	import flash.net.URLRequest;
	import flash.external.ExternalInterface;
 
	public class Model{
 
		private const SINGLETON_MSG:String = 'Model singleton already constructed!';
 
		private static var _instance:Model;
 
		private var _loader:LoaderMax;
		private var _xmlInitialLoader:LoaderMax;
 
		private var _process:Function;
		private var hasProcessingFunction:Boolean = false;
 
		private var _data:XML;
		private var _dispatcher:EventDispatcher = new EventDispatcher();
 
		public static var useSWFAddress:Boolean = true;
		private var _embededVariables:Hash = new Hash();
 
		public function Model(se:SingletonEnforcer) {
			if (_instance != null){
				throw new Error(SINGLETON_MSG);
			}
			_instance = this;
			initModel();
		}
 
		public static function getInstance():Model {
			if (_instance == null){
				_instance = new Model(new SingletonEnforcer());
			}
			return _instance;
		}
 
		private function initModel():void{
			var variables:Object = LoaderInfo(Initializer.instance.root.loaderInfo).parameters;
			for (var name:String in variables){
				_embededVariables[name] = variables[name];
			}			
			LoaderMax.activate([XMLLoader, ImageLoader, CSSLoader]);
		}
 
		/*
		Call this function to load external xml, 
		@_xmlPath - url to the XML file
		@process - function to be executed when the XML is loaded, probably load some pictures
		using the "addInternalImageLoader" method
		*/
		public function loadInitialXML(_xmlPath:String, process:Function = null):void{
			_process = process;
			if(_process != null){
				hasProcessingFunction = true;
			}
 
			_xmlInitialLoader = new LoaderMax();
			_xmlInitialLoader.append(new XMLLoader(_xmlPath, {name:"XMLData", noCache:true}));
			_xmlInitialLoader.addEventListener(LoaderEvent.PROGRESS, onXMLLoadingProgress);
			_xmlInitialLoader.addEventListener(LoaderEvent.COMPLETE, onXMLLoadingComplete);
			_xmlInitialLoader.addEventListener(LoaderEvent.ERROR, onXMLLoadingError);
			_xmlInitialLoader.load(false);
		}
 
		private function onXMLLoadingProgress(event:LoaderEvent):void{
			var xmlPercentLoaded:Number = Math.ceil(event.target.progress*100);
 
			if(hasProcessingFunction){
				_dispatcher.dispatchEvent(new ModelEvent(ModelEvent.PROGRESS, Number(xmlPercentLoaded*0.1)));
			} else  {
				_dispatcher.dispatchEvent(new ModelEvent(ModelEvent.PROGRESS, Number(xmlPercentLoaded)));
			}
		}
 
		private function onXMLLoadingError(event:LoaderEvent):void{
			trace("[Model]:: ERROR :: onXMLLoadingError function");
		}
 
		private function onXMLLoadingComplete(event:LoaderEvent):void{
			_data = new XML(_xmlInitialLoader.getContent("XMLData"));
			_xmlInitialLoader.removeEventListener(LoaderEvent.PROGRESS, onXMLLoadingProgress);
			_xmlInitialLoader.removeEventListener(LoaderEvent.COMPLETE, onXMLLoadingComplete);
			_xmlInitialLoader.removeEventListener(LoaderEvent.ERROR, onXMLLoadingError);
			_xmlInitialLoader.unload();
			_xmlInitialLoader.dispose(true);
			_dispatcher.dispatchEvent(new ModelEvent(ModelEvent.XML_ASSIGNED));
			_dispatcher.dispatchEvent(new ModelEvent(ModelEvent.XML_COMPLETE));
 
			if(hasProcessingFunction){
				_loader = new LoaderMax();
				_loader.addEventListener(LoaderEvent.PROGRESS, onExternallProgress);
				_loader.addEventListener(LoaderEvent.ERROR, onExternallError);
				_loader.addEventListener(LoaderEvent.COMPLETE, onAllComplete);
				_process.call(this);
				_loader.load();
			} else  {
				dispatchAllComplete();
			}
		}
 
		public function dispatchAllComplete():void{
 
			if(ExternalInterface.available){
				ExternalInterface.call("switchColors");
			}
 
			if(Model.useSWFAddress){
				//little trick, wait for SWFAddress Event, so the new page is recognised, than dispatch event
				Router.addEventListener(PageEvent.CHANGE, function():void{
					_dispatcher.dispatchEvent(new ModelEvent(ModelEvent.ALL_COMPLETE));
				});
				Router.init();
			} else {
				_dispatcher.dispatchEvent(new ModelEvent(ModelEvent.ALL_COMPLETE));
			}
		}
 
		public function onExternallProgress(event:LoaderEvent):void{
			var allPercentLoaded:Number = 10 + (Math.ceil(event.target.progress*100)*0.9);
			_dispatcher.dispatchEvent(new ModelEvent(ModelEvent.PROGRESS, allPercentLoaded));
		}
 
		public function onExternallError(event:LoaderEvent):void{
			trace("[Model]:: ERROR :: onExternallError function");
		}
 
		public function onAllComplete(event:LoaderEvent):void{
			_loader.removeEventListener(LoaderEvent.PROGRESS, onExternallProgress);
			_loader.removeEventListener(LoaderEvent.ERROR, onExternallError);
			_loader.removeEventListener(LoaderEvent.COMPLETE, onAllComplete);
 
			dispatchAllComplete();
		}
 
		//////////// Addng external images, retriving content from the loader /////////////
 
		/*
		Add image to be loaded, simplifies loading images that will be needed in the whole project
		*/
		public function addInternalImageLoader(url:String, parameters:Object = null):void{
			_loader.append(new ImageLoader(url, parameters));
		}
 
		/*
		@nameOrURL - url of loaded image or "name" if set
		*/
		public function getLoaderBitmap(nameOrURL:String):Bitmap{
			return (getContent(nameOrURL).rawContent as Bitmap);
		}
 
		/*
		Same as getLoaderBitmap, but returns the BitmapData
		*/
		public function getLoaderBitmapData(nameOrURL:String):BitmapData{
			return (getContent(nameOrURL).rawContent as Bitmap).bitmapData;
		}
 
		/*
		Returns XML if any was added in the process function
		*/
		public function getLoaderXML(nameOrURL:String):XML{
			return new XML(_loader.getLoader(nameOrURL).content);
		}
 
		/*
		Retrives any loader that was added
		*/
		public function getInternalLoader(nameOrURL:String):*{
			return _loader.getLoader(nameOrURL);
		}
 
		/*
		Retrives any conted that was added
		*/
		public function getContent(nameOrURL:String):*{
			return _loader.getContent(nameOrURL);
		}
 
		public function addInternalCSS(url:String, parameters:Object = null):void{
			_loader.append(new CSSLoader(url, parameters));
		}
 
		public function getLoaderCSS(nameOrURL:String):StyleSheet{
			return LoaderMax.getContent(nameOrURL) as StyleSheet
		}
 
		///////////////////////////////////////// IEventDispatcher ///////////////////////////////////////////////////
 
		public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeak:Boolean = true):void { 
			_dispatcher.addEventListener(type, listener, useCapture, priority, useWeak); 
		}
 
		public function removeEventListener(type:String, listener:Function):void { 
			_dispatcher.removeEventListener(type, listener); 
		}
 
		public function dispatchEvent(event:Event):void { 
			_dispatcher.dispatchEvent(event); 
		}
 
		//////////////////////////////////////// Culture /////////////////////////////////////////////////////////////
 
		public function i18nContent(xml_list:*, culture:String = null):String{
			if(!culture){
				culture = Router.language;
			}
			if (xml_list is XMLList){
				xml_list = xml_list.(@lang == culture);
				return xml_list && xml_list.length() ? xml_list[0] : 'not translated'
			}
			return xml_list;
		}
 
		//////////////// USEFULL XML FUNCTIONS ////////////////////////////////////////////////////////////////////
 
		/*
		Easy function to get any XMLList, just pass the nodename
		*/
		public function list(nodeName:String):XMLList{
			return xmlData..*.(name() == nodeName);
		}
 
		/*
		Easy get any XML
		@nodeName - name of the node
		@id - the id tag of the node, must have
		@offset - offset of the node, 1 will return the next node, -1 - the previous
		*/
		public function element(nodeName:String, id:String = null, offset:int = 0):XML {
			var xml:XML = xmlData..*.(name() == nodeName && attribute("id") == id)[0];
			if (offset == 0) {
				return xml;
			} else {
				var offset_xml:* = xml.parent().children()[xml.childIndex() + offset];
				return (offset_xml && offset_xml is XML && offset_xml.name() == nodeName) ? offset_xml : null;
			}
		}
 
		/*
		Dictionary - returns XMLList in special "dictionary" node in the XML
		*/
		public function dictionary(word:String):* {
			var dict_lsit:XMLList = xmlData.dictionary..*.(name() == word);
			if (dict_lsit.length == 1){
				return dict_lsit[0];
			}else{
				return dict_lsit;
			}
		}
 
		//////////////////////////// SOME SETTERS ///////////////////////////////////////////
 
		//////////////////////////// GETTER FUNCTIONS ///////////////////////////////////////
 
		/*
		get the loaded initial XML
		*/
		public function get xmlData():XML{ 
			return  _data; 
		}
 
		/*
		get the LoaderMax that loads the images from the process function
		*/
		public function get loader():LoaderMax { 
			return _loader;
		}
 
		/*
		get the model EventDispatcher
		*/
		public function get dispatcher():EventDispatcher{
			return _dispatcher;
		}
 
		/*
		Returns embeded variables, passed via swfobject
		*/
		public function get embededVariables():Hash{
			return _embededVariables;
		}
 
 
	}//end class
}
 
internal class SingletonEnforcer { }