home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / modules / ModuleManager.as < prev    next >
Text File  |  2008-09-02  |  15KB  |  579 lines
  1. package mx.modules
  2. {
  3.    import mx.core.IFlexModuleFactory;
  4.    import mx.core.mx_internal;
  5.    
  6.    use namespace mx_internal;
  7.    
  8.    public class ModuleManager
  9.    {
  10.       
  11.       mx_internal static const VERSION:String = "2.0.1.0";
  12.        
  13.       
  14.       public function ModuleManager()
  15.       {
  16.          super();
  17.       }
  18.       
  19.       public static function getModule(param1:String) : IModuleInfo
  20.       {
  21.          return getSingleton().getModule(param1);
  22.       }
  23.       
  24.       private static function getSingleton() : Object
  25.       {
  26.          if(!ModuleManagerGlobals.managerSingleton)
  27.          {
  28.             ModuleManagerGlobals.managerSingleton = new ModuleManagerImpl();
  29.          }
  30.          return ModuleManagerGlobals.managerSingleton;
  31.       }
  32.       
  33.       public static function getAssociatedFactory(param1:Object) : IFlexModuleFactory
  34.       {
  35.          return getSingleton().getAssociatedFactory(param1);
  36.       }
  37.    }
  38. }
  39.  
  40. import flash.events.EventDispatcher;
  41. import flash.system.ApplicationDomain;
  42. import flash.system.SecurityDomain;
  43. import mx.core.IFlexModuleFactory;
  44. import mx.events.ModuleEvent;
  45. import mx.modules.IModuleInfo;
  46.  
  47. class ModuleInfoProxy extends EventDispatcher implements IModuleInfo
  48. {
  49.     
  50.    
  51.    private var _data:Object;
  52.    
  53.    private var info:ModuleInfo;
  54.    
  55.    private var referenced:Boolean = false;
  56.    
  57.    function ModuleInfoProxy(param1:ModuleInfo)
  58.    {
  59.       referenced = false;
  60.       super();
  61.       this.info = param1;
  62.       param1.addEventListener(ModuleEvent.SETUP,moduleEventHandler);
  63.       param1.addEventListener(ModuleEvent.PROGRESS,moduleEventHandler);
  64.       param1.addEventListener(ModuleEvent.READY,moduleEventHandler);
  65.       param1.addEventListener(ModuleEvent.ERROR,moduleEventHandler);
  66.       param1.addEventListener(ModuleEvent.UNLOAD,moduleEventHandler);
  67.    }
  68.    
  69.    public function get loaded() : Boolean
  70.    {
  71.       return info.loaded;
  72.    }
  73.    
  74.    public function get error() : Boolean
  75.    {
  76.       return info.error;
  77.    }
  78.    
  79.    public function set data(param1:Object) : void
  80.    {
  81.       _data = param1;
  82.    }
  83.    
  84.    public function publish(param1:IFlexModuleFactory) : void
  85.    {
  86.       info.publish(param1);
  87.    }
  88.    
  89.    public function get factory() : IFlexModuleFactory
  90.    {
  91.       return info.factory;
  92.    }
  93.    
  94.    public function release() : void
  95.    {
  96.       if(referenced)
  97.       {
  98.          info.removeReference();
  99.          referenced = false;
  100.       }
  101.    }
  102.    
  103.    public function get ready() : Boolean
  104.    {
  105.       return info.ready;
  106.    }
  107.    
  108.    public function load(param1:ApplicationDomain = null, param2:SecurityDomain = null) : void
  109.    {
  110.       var _loc3_:ModuleEvent = null;
  111.       info.resurrect();
  112.       if(!referenced)
  113.       {
  114.          info.addReference();
  115.          referenced = true;
  116.       }
  117.       if(info.error)
  118.       {
  119.          dispatchEvent(new ModuleEvent(ModuleEvent.ERROR));
  120.       }
  121.       else if(info.loaded)
  122.       {
  123.          if(info.setup)
  124.          {
  125.             dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  126.             if(info.ready)
  127.             {
  128.                _loc3_ = new ModuleEvent(ModuleEvent.PROGRESS);
  129.                _loc3_.bytesLoaded = info.size;
  130.                _loc3_.bytesTotal = info.size;
  131.                dispatchEvent(_loc3_);
  132.                dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  133.             }
  134.          }
  135.       }
  136.       else
  137.       {
  138.          info.load(param1,param2);
  139.       }
  140.    }
  141.    
  142.    public function get data() : Object
  143.    {
  144.       return _data;
  145.    }
  146.    
  147.    private function moduleEventHandler(param1:ModuleEvent) : void
  148.    {
  149.       dispatchEvent(param1);
  150.    }
  151.    
  152.    public function get url() : String
  153.    {
  154.       return info.url;
  155.    }
  156.    
  157.    public function get setup() : Boolean
  158.    {
  159.       return info.setup;
  160.    }
  161.    
  162.    public function unload() : void
  163.    {
  164.       info.unload();
  165.       info.removeEventListener(ModuleEvent.SETUP,moduleEventHandler);
  166.       info.removeEventListener(ModuleEvent.PROGRESS,moduleEventHandler);
  167.       info.removeEventListener(ModuleEvent.READY,moduleEventHandler);
  168.       info.removeEventListener(ModuleEvent.ERROR,moduleEventHandler);
  169.       info.removeEventListener(ModuleEvent.UNLOAD,moduleEventHandler);
  170.    }
  171. }
  172.  
  173. import flash.events.EventDispatcher;
  174. import flash.system.ApplicationDomain;
  175. import flash.utils.getQualifiedClassName;
  176. import mx.core.IFlexModuleFactory;
  177. import mx.modules.IModuleInfo;
  178.  
  179. class ModuleManagerImpl extends EventDispatcher
  180. {
  181.     
  182.    
  183.    private var moduleList:Object;
  184.    
  185.    function ModuleManagerImpl()
  186.    {
  187.       moduleList = {};
  188.       super();
  189.    }
  190.    
  191.    public function getModule(param1:String) : IModuleInfo
  192.    {
  193.       var _loc2_:ModuleInfo = null;
  194.       _loc2_ = moduleList[param1] as ModuleInfo;
  195.       if(!_loc2_)
  196.       {
  197.          _loc2_ = new ModuleInfo(param1);
  198.          moduleList[param1] = _loc2_;
  199.       }
  200.       return new ModuleInfoProxy(_loc2_);
  201.    }
  202.    
  203.    public function getAssociatedFactory(param1:Object) : IFlexModuleFactory
  204.    {
  205.       var className:String = null;
  206.       var m:Object = null;
  207.       var info:ModuleInfo = null;
  208.       var domain:ApplicationDomain = null;
  209.       var cls:Class = null;
  210.       var object:Object = param1;
  211.       className = getQualifiedClassName(object);
  212.       for each(m in moduleList)
  213.       {
  214.          info = m as ModuleInfo;
  215.          if(info.ready)
  216.          {
  217.             domain = info.applicationDomain;
  218.             try
  219.             {
  220.                cls = Class(domain.getDefinition(className));
  221.                if(object is cls)
  222.                {
  223.                   return info.factory;
  224.                }
  225.             }
  226.             catch(error:Error)
  227.             {
  228.                continue;
  229.             }
  230.          }
  231.       }
  232.       return null;
  233.    }
  234. }
  235.  
  236. import flash.display.Loader;
  237. import flash.events.ErrorEvent;
  238. import flash.events.Event;
  239. import flash.events.EventDispatcher;
  240. import flash.events.IOErrorEvent;
  241. import flash.events.ProgressEvent;
  242. import flash.events.SecurityErrorEvent;
  243. import flash.net.URLRequest;
  244. import flash.system.ApplicationDomain;
  245. import flash.system.LoaderContext;
  246. import flash.system.Security;
  247. import flash.system.SecurityDomain;
  248. import flash.utils.Dictionary;
  249. import mx.core.IFlexModuleFactory;
  250. import mx.events.ModuleEvent;
  251.  
  252. class ModuleInfo extends EventDispatcher
  253. {
  254.     
  255.    
  256.    private var _error:Boolean = false;
  257.    
  258.    private var loader:Loader;
  259.    
  260.    private var _loaded:Boolean = false;
  261.    
  262.    private var _ready:Boolean = false;
  263.    
  264.    private var numReferences:int = 0;
  265.    
  266.    private var _url:String;
  267.    
  268.    private var factoryInfo:FactoryInfo;
  269.    
  270.    private var limbo:Dictionary;
  271.    
  272.    private var _setup:Boolean = false;
  273.    
  274.    function ModuleInfo(param1:String)
  275.    {
  276.       numReferences = 0;
  277.       _error = false;
  278.       _loaded = false;
  279.       _ready = false;
  280.       _setup = false;
  281.       super();
  282.       _url = param1;
  283.    }
  284.    
  285.    public function get loaded() : Boolean
  286.    {
  287.       return !limbo ? Boolean(_loaded) : false;
  288.    }
  289.    
  290.    public function get error() : Boolean
  291.    {
  292.       return !limbo ? Boolean(_error) : false;
  293.    }
  294.    
  295.    public function get factory() : IFlexModuleFactory
  296.    {
  297.       return !limbo && factoryInfo ? factoryInfo.factory : null;
  298.    }
  299.    
  300.    public function release() : void
  301.    {
  302.       if(_ready && !limbo)
  303.       {
  304.          limbo = new Dictionary(true);
  305.          limbo[factoryInfo] = 1;
  306.          factoryInfo = null;
  307.       }
  308.       else
  309.       {
  310.          unload();
  311.       }
  312.    }
  313.    
  314.    public function get size() : int
  315.    {
  316.       return !limbo && factoryInfo ? int(factoryInfo.bytesTotal) : 0;
  317.    }
  318.    
  319.    public function publish(param1:IFlexModuleFactory) : void
  320.    {
  321.       if(factoryInfo)
  322.       {
  323.          return;
  324.       }
  325.       if(_url.indexOf("published://") != 0)
  326.       {
  327.          return;
  328.       }
  329.       factoryInfo = new FactoryInfo();
  330.       factoryInfo.factory = param1;
  331.       _loaded = true;
  332.       _setup = true;
  333.       _ready = true;
  334.       _error = false;
  335.       dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  336.       dispatchEvent(new ModuleEvent(ModuleEvent.PROGRESS));
  337.       dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  338.    }
  339.    
  340.    public function initHandler(param1:Event) : void
  341.    {
  342.       var moduleEvent:ModuleEvent = null;
  343.       var event:Event = param1;
  344.       factoryInfo = new FactoryInfo();
  345.       try
  346.       {
  347.          factoryInfo.factory = loader.content as IFlexModuleFactory;
  348.       }
  349.       catch(error:Error)
  350.       {
  351.       }
  352.       if(!factoryInfo.factory)
  353.       {
  354.          moduleEvent = new ModuleEvent(ModuleEvent.ERROR,event.bubbles,event.cancelable);
  355.          moduleEvent.bytesLoaded = 0;
  356.          moduleEvent.bytesTotal = 0;
  357.          moduleEvent.errorText = "SWF is not a loadable module";
  358.          dispatchEvent(moduleEvent);
  359.          return;
  360.       }
  361.       loader.content.addEventListener("ready",readyHandler);
  362.       try
  363.       {
  364.          factoryInfo.applicationDomain = loader.contentLoaderInfo.applicationDomain;
  365.       }
  366.       catch(error:Error)
  367.       {
  368.       }
  369.       _setup = true;
  370.       dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  371.    }
  372.    
  373.    public function resurrect() : void
  374.    {
  375.       var _loc1_:* = null;
  376.       if(!factoryInfo && limbo)
  377.       {
  378.          var _loc2_:int = 0;
  379.          var _loc3_:* = limbo;
  380.          for(_loc1_ in _loc3_)
  381.          {
  382.             factoryInfo = _loc1_ as FactoryInfo;
  383.          }
  384.          limbo = null;
  385.       }
  386.       if(!factoryInfo)
  387.       {
  388.          if(_loaded)
  389.          {
  390.             dispatchEvent(new ModuleEvent(ModuleEvent.UNLOAD));
  391.          }
  392.          loader = null;
  393.          _loaded = false;
  394.          _setup = false;
  395.          _ready = false;
  396.          _error = false;
  397.       }
  398.    }
  399.    
  400.    public function errorHandler(param1:ErrorEvent) : void
  401.    {
  402.       var _loc2_:ModuleEvent = null;
  403.       _error = true;
  404.       _loc2_ = new ModuleEvent(ModuleEvent.ERROR,param1.bubbles,param1.cancelable);
  405.       _loc2_.bytesLoaded = 0;
  406.       _loc2_.bytesTotal = 0;
  407.       _loc2_.errorText = param1.text;
  408.       dispatchEvent(_loc2_);
  409.    }
  410.    
  411.    public function get ready() : Boolean
  412.    {
  413.       return !limbo ? Boolean(_ready) : false;
  414.    }
  415.    
  416.    public function removeReference() : void
  417.    {
  418.       --numReferences;
  419.       if(numReferences == 0)
  420.       {
  421.          release();
  422.       }
  423.    }
  424.    
  425.    public function addReference() : void
  426.    {
  427.       ++numReferences;
  428.    }
  429.    
  430.    public function get applicationDomain() : ApplicationDomain
  431.    {
  432.       return !limbo && factoryInfo ? factoryInfo.applicationDomain : null;
  433.    }
  434.    
  435.    public function readyHandler(param1:Event) : void
  436.    {
  437.       _ready = true;
  438.       factoryInfo.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  439.       clearLoader();
  440.       dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  441.    }
  442.    
  443.    private function clearLoader() : void
  444.    {
  445.       if(loader)
  446.       {
  447.          if(loader.contentLoaderInfo)
  448.          {
  449.             loader.contentLoaderInfo.removeEventListener(Event.INIT,initHandler);
  450.             loader.contentLoaderInfo.removeEventListener(Event.COMPLETE,completeHandler);
  451.             loader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS,progressHandler);
  452.             loader.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  453.             loader.contentLoaderInfo.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
  454.          }
  455.          try
  456.          {
  457.             if(loader.content)
  458.             {
  459.                loader.content.removeEventListener("ready",readyHandler);
  460.             }
  461.          }
  462.          catch(error:Error)
  463.          {
  464.          }
  465.          if(_loaded)
  466.          {
  467.             try
  468.             {
  469.                loader.close();
  470.             }
  471.             catch(error:Error)
  472.             {
  473.             }
  474.          }
  475.          try
  476.          {
  477.             loader.unload();
  478.          }
  479.          catch(error:Error)
  480.          {
  481.          }
  482.          loader = null;
  483.       }
  484.    }
  485.    
  486.    public function progressHandler(param1:ProgressEvent) : void
  487.    {
  488.       var _loc2_:ModuleEvent = null;
  489.       _loc2_ = new ModuleEvent(ModuleEvent.PROGRESS,param1.bubbles,param1.cancelable);
  490.       _loc2_.bytesLoaded = param1.bytesLoaded;
  491.       _loc2_.bytesTotal = param1.bytesTotal;
  492.       dispatchEvent(_loc2_);
  493.    }
  494.    
  495.    public function load(param1:ApplicationDomain = null, param2:SecurityDomain = null) : void
  496.    {
  497.       var _loc3_:URLRequest = null;
  498.       var _loc4_:LoaderContext = null;
  499.       if(_loaded)
  500.       {
  501.          return;
  502.       }
  503.       _loaded = true;
  504.       limbo = null;
  505.       if(_url.indexOf("published://") == 0)
  506.       {
  507.          return;
  508.       }
  509.       _loc3_ = new URLRequest(_url);
  510.       (_loc4_ = new LoaderContext()).applicationDomain = !!param1 ? param1 : new ApplicationDomain(ApplicationDomain.currentDomain);
  511.       _loc4_.securityDomain = param2;
  512.       if(param2 == null && Security.sandboxType == Security.REMOTE)
  513.       {
  514.          _loc4_.securityDomain = SecurityDomain.currentDomain;
  515.       }
  516.       loader = new Loader();
  517.       loader.contentLoaderInfo.addEventListener(Event.INIT,initHandler);
  518.       loader.contentLoaderInfo.addEventListener(Event.COMPLETE,completeHandler);
  519.       loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,progressHandler);
  520.       loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  521.       loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
  522.       loader.load(_loc3_,_loc4_);
  523.    }
  524.    
  525.    public function completeHandler(param1:Event) : void
  526.    {
  527.       var _loc2_:ModuleEvent = null;
  528.       _loc2_ = new ModuleEvent(ModuleEvent.PROGRESS,param1.bubbles,param1.cancelable);
  529.       _loc2_.bytesLoaded = loader.contentLoaderInfo.bytesLoaded;
  530.       _loc2_.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  531.       dispatchEvent(_loc2_);
  532.    }
  533.    
  534.    public function get url() : String
  535.    {
  536.       return _url;
  537.    }
  538.    
  539.    public function get setup() : Boolean
  540.    {
  541.       return !limbo ? Boolean(_setup) : false;
  542.    }
  543.    
  544.    public function unload() : void
  545.    {
  546.       clearLoader();
  547.       if(_loaded)
  548.       {
  549.          dispatchEvent(new ModuleEvent(ModuleEvent.UNLOAD));
  550.       }
  551.       limbo = null;
  552.       factoryInfo = null;
  553.       _loaded = false;
  554.       _setup = false;
  555.       _ready = false;
  556.       _error = false;
  557.    }
  558. }
  559.  
  560. import flash.system.ApplicationDomain;
  561. import mx.core.IFlexModuleFactory;
  562.  
  563. class FactoryInfo
  564. {
  565.     
  566.    
  567.    public var bytesTotal:int = 0;
  568.    
  569.    public var factory:IFlexModuleFactory;
  570.    
  571.    public var applicationDomain:ApplicationDomain;
  572.    
  573.    function FactoryInfo()
  574.    {
  575.       bytesTotal = 0;
  576.       super();
  577.    }
  578. }
  579.