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