home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / styles / CSSStyleDeclaration.as next >
Encoding:
Text File  |  2010-06-23  |  9.2 KB  |  335 lines
  1. package mx.styles
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.Dictionary;
  6.    import mx.core.Singleton;
  7.    import mx.core.mx_internal;
  8.    import mx.managers.SystemManagerGlobals;
  9.    
  10.    use namespace mx_internal;
  11.    
  12.    public class CSSStyleDeclaration extends EventDispatcher
  13.    {
  14.       mx_internal static const VERSION:String = "3.5.0.12683";
  15.       
  16.       private static const NOT_A_COLOR:uint = 4294967295;
  17.       
  18.       private static const FILTERMAP_PROP:String = "__reserved__filterMap";
  19.       
  20.       mx_internal var effects:Array;
  21.       
  22.       protected var overrides:Object;
  23.       
  24.       public var defaultFactory:Function;
  25.       
  26.       public var factory:Function;
  27.       
  28.       mx_internal var selectorRefCount:int = 0;
  29.       
  30.       private var styleManager:IStyleManager2;
  31.       
  32.       private var clones:Dictionary = new Dictionary(true);
  33.       
  34.       public function CSSStyleDeclaration(param1:String = null)
  35.       {
  36.          super();
  37.          if(param1)
  38.          {
  39.             styleManager = Singleton.getInstance("mx.styles::IStyleManager2") as IStyleManager2;
  40.             styleManager.setStyleDeclaration(param1,this,false);
  41.          }
  42.       }
  43.       
  44.       mx_internal function addStyleToProtoChain(param1:Object, param2:DisplayObject, param3:Object = null) : Object
  45.       {
  46.          var p:String = null;
  47.          var emptyObjectFactory:Function = null;
  48.          var filteredChain:Object = null;
  49.          var filterObjectFactory:Function = null;
  50.          var i:String = null;
  51.          var chain:Object = param1;
  52.          var target:DisplayObject = param2;
  53.          var filterMap:Object = param3;
  54.          var nodeAddedToChain:Boolean = false;
  55.          var originalChain:Object = chain;
  56.          if(filterMap)
  57.          {
  58.             chain = {};
  59.          }
  60.          if(defaultFactory != null)
  61.          {
  62.             defaultFactory.prototype = chain;
  63.             chain = new defaultFactory();
  64.             nodeAddedToChain = true;
  65.          }
  66.          if(factory != null)
  67.          {
  68.             factory.prototype = chain;
  69.             chain = new factory();
  70.             nodeAddedToChain = true;
  71.          }
  72.          if(overrides)
  73.          {
  74.             if(defaultFactory == null && factory == null)
  75.             {
  76.                emptyObjectFactory = function():void
  77.                {
  78.                };
  79.                emptyObjectFactory.prototype = chain;
  80.                chain = new emptyObjectFactory();
  81.                nodeAddedToChain = true;
  82.             }
  83.             for(p in overrides)
  84.             {
  85.                if(overrides[p] === undefined)
  86.                {
  87.                   delete chain[p];
  88.                }
  89.                else
  90.                {
  91.                   chain[p] = overrides[p];
  92.                }
  93.             }
  94.          }
  95.          if(filterMap)
  96.          {
  97.             if(nodeAddedToChain)
  98.             {
  99.                filteredChain = {};
  100.                filterObjectFactory = function():void
  101.                {
  102.                };
  103.                filterObjectFactory.prototype = originalChain;
  104.                filteredChain = new filterObjectFactory();
  105.                for(i in chain)
  106.                {
  107.                   if(filterMap[i] != null)
  108.                   {
  109.                      filteredChain[filterMap[i]] = chain[i];
  110.                   }
  111.                }
  112.                chain = filteredChain;
  113.                chain[FILTERMAP_PROP] = filterMap;
  114.             }
  115.             else
  116.             {
  117.                chain = originalChain;
  118.             }
  119.          }
  120.          if(nodeAddedToChain)
  121.          {
  122.             clones[chain] = 1;
  123.          }
  124.          return chain;
  125.       }
  126.       
  127.       public function getStyle(param1:String) : *
  128.       {
  129.          var _loc2_:* = undefined;
  130.          var _loc3_:* = undefined;
  131.          if(overrides)
  132.          {
  133.             if(param1 in overrides && overrides[param1] === undefined)
  134.             {
  135.                return undefined;
  136.             }
  137.             _loc3_ = overrides[param1];
  138.             if(_loc3_ !== undefined)
  139.             {
  140.                return _loc3_;
  141.             }
  142.          }
  143.          if(factory != null)
  144.          {
  145.             factory.prototype = {};
  146.             _loc2_ = new factory();
  147.             _loc3_ = _loc2_[param1];
  148.             if(_loc3_ !== undefined)
  149.             {
  150.                return _loc3_;
  151.             }
  152.          }
  153.          if(defaultFactory != null)
  154.          {
  155.             defaultFactory.prototype = {};
  156.             _loc2_ = new defaultFactory();
  157.             _loc3_ = _loc2_[param1];
  158.             if(_loc3_ !== undefined)
  159.             {
  160.                return _loc3_;
  161.             }
  162.          }
  163.          return undefined;
  164.       }
  165.       
  166.       public function clearStyle(param1:String) : void
  167.       {
  168.          setStyle(param1,undefined);
  169.       }
  170.       
  171.       public function setStyle(param1:String, param2:*) : void
  172.       {
  173.          var _loc7_:int = 0;
  174.          var _loc8_:Object = null;
  175.          var _loc3_:Object = getStyle(param1);
  176.          var _loc4_:Boolean = false;
  177.          if(mx_internal::selectorRefCount > 0 && factory == null && defaultFactory == null && !overrides && _loc3_ !== param2)
  178.          {
  179.             _loc4_ = true;
  180.          }
  181.          if(param2 !== undefined)
  182.          {
  183.             mx_internal::setStyle(param1,param2);
  184.          }
  185.          else
  186.          {
  187.             if(param2 == _loc3_)
  188.             {
  189.                return;
  190.             }
  191.             mx_internal::setStyle(param1,param2);
  192.          }
  193.          var _loc5_:Array = SystemManagerGlobals.topLevelSystemManagers;
  194.          var _loc6_:int = int(_loc5_.length);
  195.          if(_loc4_)
  196.          {
  197.             _loc7_ = 0;
  198.             while(_loc7_ < _loc6_)
  199.             {
  200.                _loc8_ = _loc5_[_loc7_];
  201.                _loc8_.regenerateStyleCache(true);
  202.                _loc7_++;
  203.             }
  204.          }
  205.          _loc7_ = 0;
  206.          while(_loc7_ < _loc6_)
  207.          {
  208.             _loc8_ = _loc5_[_loc7_];
  209.             _loc8_.notifyStyleChangeInChildren(param1,true);
  210.             _loc7_++;
  211.          }
  212.       }
  213.       
  214.       private function clearStyleAttr(param1:String) : void
  215.       {
  216.          var _loc2_:* = undefined;
  217.          if(!overrides)
  218.          {
  219.             overrides = {};
  220.          }
  221.          overrides[param1] = undefined;
  222.          for(_loc2_ in clones)
  223.          {
  224.             delete _loc2_[param1];
  225.          }
  226.       }
  227.       
  228.       mx_internal function createProtoChainRoot() : Object
  229.       {
  230.          var _loc1_:Object = {};
  231.          if(defaultFactory != null)
  232.          {
  233.             defaultFactory.prototype = _loc1_;
  234.             _loc1_ = new defaultFactory();
  235.          }
  236.          if(factory != null)
  237.          {
  238.             factory.prototype = _loc1_;
  239.             _loc1_ = new factory();
  240.          }
  241.          clones[_loc1_] = 1;
  242.          return _loc1_;
  243.       }
  244.       
  245.       mx_internal function clearOverride(param1:String) : void
  246.       {
  247.          if(Boolean(overrides) && Boolean(overrides[param1]))
  248.          {
  249.             delete overrides[param1];
  250.          }
  251.       }
  252.       
  253.       mx_internal function setStyle(param1:String, param2:*) : void
  254.       {
  255.          var _loc3_:Object = null;
  256.          var _loc4_:* = undefined;
  257.          var _loc5_:Number = NaN;
  258.          var _loc6_:Object = null;
  259.          if(param2 === undefined)
  260.          {
  261.             clearStyleAttr(param1);
  262.             return;
  263.          }
  264.          if(param2 is String)
  265.          {
  266.             if(!styleManager)
  267.             {
  268.                styleManager = Singleton.getInstance("mx.styles::IStyleManager2") as IStyleManager2;
  269.             }
  270.             _loc5_ = Number(styleManager.getColorName(param2));
  271.             if(_loc5_ != NOT_A_COLOR)
  272.             {
  273.                param2 = _loc5_;
  274.             }
  275.          }
  276.          if(defaultFactory != null)
  277.          {
  278.             _loc3_ = new defaultFactory();
  279.             if(_loc3_[param1] !== param2)
  280.             {
  281.                if(!overrides)
  282.                {
  283.                   overrides = {};
  284.                }
  285.                overrides[param1] = param2;
  286.             }
  287.             else if(overrides)
  288.             {
  289.                delete overrides[param1];
  290.             }
  291.          }
  292.          if(factory != null)
  293.          {
  294.             _loc3_ = new factory();
  295.             if(_loc3_[param1] !== param2)
  296.             {
  297.                if(!overrides)
  298.                {
  299.                   overrides = {};
  300.                }
  301.                overrides[param1] = param2;
  302.             }
  303.             else if(overrides)
  304.             {
  305.                delete overrides[param1];
  306.             }
  307.          }
  308.          if(defaultFactory == null && factory == null)
  309.          {
  310.             if(!overrides)
  311.             {
  312.                overrides = {};
  313.             }
  314.             overrides[param1] = param2;
  315.          }
  316.          for(_loc4_ in clones)
  317.          {
  318.             _loc6_ = _loc4_[FILTERMAP_PROP];
  319.             if(_loc6_)
  320.             {
  321.                if(_loc6_[param1] != null)
  322.                {
  323.                   _loc4_[_loc6_[param1]] = param2;
  324.                }
  325.             }
  326.             else
  327.             {
  328.                _loc4_[param1] = param2;
  329.             }
  330.          }
  331.       }
  332.    }
  333. }
  334.  
  335.