home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / managers / HistoryManagerImpl.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  11.2 KB  |  396 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.LoaderInfo;
  5.    import flash.utils.Dictionary;
  6.    import mx.core.ApplicationGlobals;
  7.    import mx.core.mx_internal;
  8.    import mx.events.BrowserChangeEvent;
  9.    
  10.    use namespace mx_internal;
  11.    
  12.    public class HistoryManagerImpl implements IHistoryManager
  13.    {
  14.       private static var instance:IHistoryManager;
  15.       
  16.       private static var appID:String;
  17.       
  18.       private static var historyURL:String;
  19.       
  20.       private static var systemManager:ISystemManager;
  21.       
  22.       mx_internal static const VERSION:String = "3.5.0.12683";
  23.       
  24.       private static const HANDSHAKE_INTERVAL:int = 500;
  25.       
  26.       private static const MAX_HANDSHAKE_TRIES:int = 100;
  27.       
  28.       private static const ID_NAME_SEPARATOR:String = "-";
  29.       
  30.       private static const NAME_VALUE_SEPARATOR:String = "=";
  31.       
  32.       private static const PROPERTY_SEPARATOR:String = "&";
  33.       
  34.       private var registeredObjects:Array;
  35.       
  36.       private var pendingQueryString:String;
  37.       
  38.       private var pendingStates:Object;
  39.       
  40.       private var registrationMap:Dictionary;
  41.       
  42.       public function HistoryManagerImpl()
  43.       {
  44.          var _loc1_:LoaderInfo = null;
  45.          var _loc2_:String = null;
  46.          registeredObjects = [];
  47.          pendingStates = {};
  48.          super();
  49.          if(instance)
  50.          {
  51.             throw new Error("Instance already exists.");
  52.          }
  53.          if(appID)
  54.          {
  55.             return;
  56.          }
  57.          if(!ApplicationGlobals.application.historyManagementEnabled)
  58.          {
  59.             return;
  60.          }
  61.          if(HistoryManagerGlobals.loaderInfo)
  62.          {
  63.             _loc1_ = HistoryManagerGlobals.loaderInfo;
  64.          }
  65.          else
  66.          {
  67.             _loc1_ = DisplayObject(systemManager).loaderInfo;
  68.          }
  69.          if(HistoryManagerGlobals.loaderInfo)
  70.          {
  71.             _loc2_ = HistoryManagerGlobals.loaderInfo.url;
  72.          }
  73.          else
  74.          {
  75.             _loc2_ = DisplayObject(systemManager).loaderInfo.url;
  76.          }
  77.          appID = calcCRC(_loc2_);
  78.          BrowserManager.getInstance().addEventListener(BrowserChangeEvent.BROWSER_URL_CHANGE,browserURLChangeHandler);
  79.          BrowserManager.getInstance().initForHistoryManager();
  80.       }
  81.       
  82.       public static function getInstance() : IHistoryManager
  83.       {
  84.          if(!instance)
  85.          {
  86.             systemManager = SystemManagerGlobals.topLevelSystemManagers[0];
  87.             instance = new HistoryManagerImpl();
  88.          }
  89.          return instance;
  90.       }
  91.       
  92.       public function registered() : void
  93.       {
  94.       }
  95.       
  96.       public function unregister(param1:IHistoryManagerClient) : void
  97.       {
  98.          if(!ApplicationGlobals.application.historyManagementEnabled)
  99.          {
  100.             return;
  101.          }
  102.          var _loc2_:int = -1;
  103.          var _loc3_:int = int(registeredObjects.length);
  104.          var _loc4_:int = 0;
  105.          while(_loc4_ < _loc3_)
  106.          {
  107.             if(registeredObjects[_loc4_] == param1)
  108.             {
  109.                _loc2_ = _loc4_;
  110.                break;
  111.             }
  112.             _loc4_++;
  113.          }
  114.          if(_loc2_ >= 0)
  115.          {
  116.             registeredObjects.splice(_loc2_,1);
  117.          }
  118.          if(Boolean(param1) && Boolean(registrationMap))
  119.          {
  120.             delete registrationMap[param1];
  121.          }
  122.       }
  123.       
  124.       private function updateCRC(param1:uint, param2:uint) : uint
  125.       {
  126.          var _loc6_:* = false;
  127.          var _loc3_:uint = 4129;
  128.          var _loc4_:uint = 128;
  129.          var _loc5_:int = 0;
  130.          while(_loc5_ < 8)
  131.          {
  132.             _loc6_ = (param1 & 0x8000) != 0;
  133.             param1 <<= 1;
  134.             param1 &= 65535;
  135.             if((param2 & _loc4_) != 0)
  136.             {
  137.                param1++;
  138.             }
  139.             if(_loc6_)
  140.             {
  141.                param1 ^= _loc3_;
  142.             }
  143.             _loc4_ >>= 1;
  144.             _loc5_++;
  145.          }
  146.          return param1;
  147.       }
  148.       
  149.       private function submitQuery() : void
  150.       {
  151.          if(pendingQueryString)
  152.          {
  153.             BrowserManager.getInstance().setFragment(pendingQueryString);
  154.             pendingQueryString = null;
  155.             ApplicationGlobals.application.resetHistory = true;
  156.          }
  157.       }
  158.       
  159.       public function browserURLChangeHandler(param1:BrowserChangeEvent) : void
  160.       {
  161.          var _loc2_:String = null;
  162.          var _loc3_:String = null;
  163.          var _loc9_:Array = null;
  164.          var _loc10_:int = 0;
  165.          var _loc11_:String = null;
  166.          var _loc12_:Object = null;
  167.          var _loc13_:IHistoryManagerClient = null;
  168.          if(!ApplicationGlobals.application.historyManagementEnabled)
  169.          {
  170.             return;
  171.          }
  172.          var _loc4_:Array = param1.url.split(PROPERTY_SEPARATOR);
  173.          var _loc5_:Object = {};
  174.          var _loc6_:int = int(_loc4_.length);
  175.          var _loc7_:int = 0;
  176.          while(_loc7_ < _loc6_)
  177.          {
  178.             _loc9_ = _loc4_[_loc7_].split(NAME_VALUE_SEPARATOR);
  179.             _loc5_[_loc9_[0]] = parseString(_loc9_[1]);
  180.             _loc7_++;
  181.          }
  182.          var _loc8_:Object = {};
  183.          for(_loc2_ in _loc5_)
  184.          {
  185.             _loc10_ = int(_loc2_.indexOf(ID_NAME_SEPARATOR));
  186.             if(_loc10_ > -1)
  187.             {
  188.                _loc3_ = _loc2_.substr(0,_loc10_);
  189.                _loc11_ = _loc2_.substr(_loc10_ + 1,_loc2_.length);
  190.                _loc12_ = _loc5_[_loc2_];
  191.                if(!_loc8_[_loc3_])
  192.                {
  193.                   _loc8_[_loc3_] = {};
  194.                }
  195.                _loc8_[_loc3_][_loc11_] = _loc12_;
  196.             }
  197.          }
  198.          _loc6_ = int(registeredObjects.length);
  199.          _loc7_ = 0;
  200.          while(_loc7_ < _loc6_)
  201.          {
  202.             _loc13_ = registeredObjects[_loc7_];
  203.             _loc3_ = getRegistrationInfo(_loc13_).crc;
  204.             _loc13_.loadState(_loc8_[_loc3_]);
  205.             delete _loc8_[_loc3_];
  206.             _loc7_++;
  207.          }
  208.          for(_loc2_ in _loc8_)
  209.          {
  210.             pendingStates[_loc2_] = _loc8_[_loc2_];
  211.          }
  212.       }
  213.       
  214.       public function registerHandshake() : void
  215.       {
  216.       }
  217.       
  218.       private function getRegistrationInfo(param1:IHistoryManagerClient) : RegistrationInfo
  219.       {
  220.          return !!registrationMap ? registrationMap[param1] : null;
  221.       }
  222.       
  223.       private function getPath(param1:IHistoryManagerClient) : String
  224.       {
  225.          return param1.toString();
  226.       }
  227.       
  228.       public function load(param1:Object) : void
  229.       {
  230.       }
  231.       
  232.       private function depthCompare(param1:Object, param2:Object) : int
  233.       {
  234.          var _loc3_:RegistrationInfo = getRegistrationInfo(IHistoryManagerClient(param1));
  235.          var _loc4_:RegistrationInfo = getRegistrationInfo(IHistoryManagerClient(param2));
  236.          if(!_loc3_ || !_loc4_)
  237.          {
  238.             return 0;
  239.          }
  240.          if(_loc3_.depth > _loc4_.depth)
  241.          {
  242.             return 1;
  243.          }
  244.          if(_loc3_.depth < _loc4_.depth)
  245.          {
  246.             return -1;
  247.          }
  248.          return 0;
  249.       }
  250.       
  251.       public function register(param1:IHistoryManagerClient) : void
  252.       {
  253.          if(!ApplicationGlobals.application.historyManagementEnabled)
  254.          {
  255.             return;
  256.          }
  257.          unregister(param1);
  258.          registeredObjects.push(param1);
  259.          var _loc2_:String = getPath(param1);
  260.          var _loc3_:String = calcCRC(_loc2_);
  261.          var _loc4_:int = calcDepth(_loc2_);
  262.          if(!registrationMap)
  263.          {
  264.             registrationMap = new Dictionary(true);
  265.          }
  266.          registrationMap[param1] = new RegistrationInfo(_loc3_,_loc4_);
  267.          registeredObjects.sort(depthCompare);
  268.          if(pendingStates[_loc3_])
  269.          {
  270.             param1.loadState(pendingStates[_loc3_]);
  271.             delete pendingStates[_loc3_];
  272.          }
  273.       }
  274.       
  275.       private function parseString(param1:String) : Object
  276.       {
  277.          if(param1 == "true")
  278.          {
  279.             return true;
  280.          }
  281.          if(param1 == "false")
  282.          {
  283.             return false;
  284.          }
  285.          var _loc2_:int = parseInt(param1);
  286.          if(_loc2_.toString() == param1)
  287.          {
  288.             return _loc2_;
  289.          }
  290.          var _loc3_:Number = parseFloat(param1);
  291.          if(_loc3_.toString() == param1)
  292.          {
  293.             return _loc3_;
  294.          }
  295.          return param1;
  296.       }
  297.       
  298.       private function calcDepth(param1:String) : int
  299.       {
  300.          return param1.split(".").length;
  301.       }
  302.       
  303.       public function loadInitialState() : void
  304.       {
  305.       }
  306.       
  307.       public function save() : void
  308.       {
  309.          var _loc5_:IHistoryManagerClient = null;
  310.          var _loc6_:Object = null;
  311.          var _loc7_:String = null;
  312.          var _loc8_:String = null;
  313.          var _loc9_:Object = null;
  314.          if(!ApplicationGlobals.application.historyManagementEnabled)
  315.          {
  316.             return;
  317.          }
  318.          var _loc1_:Boolean = false;
  319.          var _loc2_:String = "app=" + appID;
  320.          var _loc3_:int = int(registeredObjects.length);
  321.          var _loc4_:int = 0;
  322.          while(_loc4_ < _loc3_)
  323.          {
  324.             _loc5_ = registeredObjects[_loc4_];
  325.             _loc6_ = _loc5_.saveState();
  326.             _loc7_ = getRegistrationInfo(_loc5_).crc;
  327.             for(_loc8_ in _loc6_)
  328.             {
  329.                _loc9_ = _loc6_[_loc8_];
  330.                if(_loc2_.length > 0)
  331.                {
  332.                   _loc2_ += PROPERTY_SEPARATOR;
  333.                }
  334.                _loc2_ += _loc7_;
  335.                _loc2_ += ID_NAME_SEPARATOR;
  336.                _loc2_ += escape(_loc8_);
  337.                _loc2_ += NAME_VALUE_SEPARATOR;
  338.                _loc2_ += escape(_loc9_.toString());
  339.                _loc1_ = true;
  340.             }
  341.             _loc4_++;
  342.          }
  343.          if(_loc1_)
  344.          {
  345.             pendingQueryString = _loc2_;
  346.             ApplicationGlobals.application.callLater(this.submitQuery);
  347.          }
  348.       }
  349.       
  350.       private function calcCRC(param1:String) : String
  351.       {
  352.          var _loc5_:uint = 0;
  353.          var _loc6_:uint = 0;
  354.          var _loc7_:uint = 0;
  355.          var _loc2_:uint = 65535;
  356.          var _loc3_:int = param1.length;
  357.          var _loc4_:int = 0;
  358.          while(_loc4_ < _loc3_)
  359.          {
  360.             _loc5_ = uint(param1.charCodeAt(_loc4_));
  361.             _loc6_ = uint(_loc5_ & 0xFF);
  362.             _loc7_ = uint(_loc5_ >> 8);
  363.             if(_loc7_ != 0)
  364.             {
  365.                _loc2_ = updateCRC(_loc2_,_loc7_);
  366.             }
  367.             _loc2_ = updateCRC(_loc2_,_loc6_);
  368.             _loc4_++;
  369.          }
  370.          _loc2_ = updateCRC(_loc2_,0);
  371.          _loc2_ = updateCRC(_loc2_,0);
  372.          return _loc2_.toString(16);
  373.       }
  374.    }
  375. }
  376.  
  377. import mx.core.mx_internal;
  378.  
  379. use namespace mx_internal;
  380.  
  381. class RegistrationInfo
  382. {
  383.    mx_internal static const VERSION:String = "3.5.0.12683";
  384.    
  385.    public var depth:int;
  386.    
  387.    public var crc:String;
  388.    
  389.    public function RegistrationInfo(param1:String, param2:int)
  390.    {
  391.       super();
  392.       this.crc = param1;
  393.       this.depth = param2;
  394.    }
  395. }
  396.