home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / mx / styles / CSSStyleDeclaration.as next >
Encoding:
Text File  |  2010-05-14  |  7.8 KB  |  290 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 = "2.0.1.0";
  15.       
  16.       private static const NOT_A_COLOR:uint = 4294967295;
  17.       
  18.       private static var styleManager:IStyleManager = Singleton.getInstance("mx.styles::IStyleManager") as IStyleManager;
  19.       
  20.       mx_internal var effects:Array;
  21.       
  22.       public var defaultFactory:Function;
  23.       
  24.       public var factory:Function;
  25.       
  26.       protected var overrides:Object;
  27.       
  28.       private var clones:Dictionary;
  29.       
  30.       mx_internal var selectorRefCount:int = 0;
  31.       
  32.       public function CSSStyleDeclaration(param1:String = null)
  33.       {
  34.          clones = new Dictionary(true);
  35.          mx_internal::selectorRefCount = 0;
  36.          super();
  37.          if(param1)
  38.          {
  39.             StyleManager.setStyleDeclaration(param1,this,false);
  40.          }
  41.       }
  42.       
  43.       mx_internal function addStyleToProtoChain(param1:Object, param2:DisplayObject) : Object
  44.       {
  45.          var nodeAddedToChain:Boolean = false;
  46.          var p:String = null;
  47.          var emptyObjectFactory:Function = null;
  48.          var chain:Object = param1;
  49.          var target:DisplayObject = param2;
  50.          nodeAddedToChain = false;
  51.          if(defaultFactory != null)
  52.          {
  53.             defaultFactory.prototype = chain;
  54.             chain = new defaultFactory();
  55.             nodeAddedToChain = true;
  56.          }
  57.          if(factory != null)
  58.          {
  59.             factory.prototype = chain;
  60.             chain = new factory();
  61.             nodeAddedToChain = true;
  62.          }
  63.          if(overrides)
  64.          {
  65.             if(defaultFactory == null && factory == null)
  66.             {
  67.                emptyObjectFactory = function():void
  68.                {
  69.                };
  70.                emptyObjectFactory.prototype = chain;
  71.                chain = new emptyObjectFactory();
  72.                nodeAddedToChain = true;
  73.             }
  74.             for(p in overrides)
  75.             {
  76.                if(overrides[p] === undefined)
  77.                {
  78.                   delete chain[p];
  79.                }
  80.                else
  81.                {
  82.                   chain[p] = overrides[p];
  83.                }
  84.             }
  85.          }
  86.          if(nodeAddedToChain)
  87.          {
  88.             clones[chain] = 1;
  89.          }
  90.          return chain;
  91.       }
  92.       
  93.       public function getStyle(param1:String) : *
  94.       {
  95.          var _loc2_:* = undefined;
  96.          var _loc3_:* = undefined;
  97.          if(overrides)
  98.          {
  99.             if(param1 in overrides && overrides[param1] === undefined)
  100.             {
  101.                return undefined;
  102.             }
  103.             _loc3_ = overrides[param1];
  104.             if(_loc3_ !== undefined)
  105.             {
  106.                return _loc3_;
  107.             }
  108.          }
  109.          if(factory != null)
  110.          {
  111.             factory.prototype = {};
  112.             _loc2_ = new factory();
  113.             _loc3_ = _loc2_[param1];
  114.             if(_loc3_ !== undefined)
  115.             {
  116.                return _loc3_;
  117.             }
  118.          }
  119.          if(defaultFactory != null)
  120.          {
  121.             defaultFactory.prototype = {};
  122.             _loc2_ = new defaultFactory();
  123.             _loc3_ = _loc2_[param1];
  124.             if(_loc3_ !== undefined)
  125.             {
  126.                return _loc3_;
  127.             }
  128.          }
  129.          return undefined;
  130.       }
  131.       
  132.       mx_internal function createProtoChainRoot() : Object
  133.       {
  134.          var _loc1_:Object = null;
  135.          _loc1_ = {};
  136.          if(defaultFactory != null)
  137.          {
  138.             defaultFactory.prototype = _loc1_;
  139.             _loc1_ = new defaultFactory();
  140.          }
  141.          if(factory != null)
  142.          {
  143.             factory.prototype = _loc1_;
  144.             _loc1_ = new factory();
  145.          }
  146.          clones[_loc1_] = 1;
  147.          return _loc1_;
  148.       }
  149.       
  150.       public function clearStyle(param1:String) : void
  151.       {
  152.          setStyle(param1,undefined);
  153.       }
  154.       
  155.       public function setStyle(param1:String, param2:*) : void
  156.       {
  157.          var _loc3_:Object = null;
  158.          var _loc4_:Boolean = false;
  159.          var _loc5_:Array = null;
  160.          var _loc6_:int = 0;
  161.          var _loc7_:int = 0;
  162.          var _loc8_:Object = null;
  163.          _loc3_ = getStyle(param1);
  164.          _loc4_ = false;
  165.          if(mx_internal::selectorRefCount > 0 && factory == null && defaultFactory == null && !overrides && _loc3_ !== param2)
  166.          {
  167.             _loc4_ = true;
  168.          }
  169.          if(param2 !== undefined)
  170.          {
  171.             mx_internal::setStyle(param1,param2);
  172.          }
  173.          else
  174.          {
  175.             if(param2 == _loc3_)
  176.             {
  177.                return;
  178.             }
  179.             mx_internal::setStyle(param1,param2);
  180.          }
  181.          _loc5_ = SystemManagerGlobals.topLevelSystemManagers;
  182.          _loc6_ = int(_loc5_.length);
  183.          if(_loc4_)
  184.          {
  185.             _loc7_ = 0;
  186.             while(_loc7_ < _loc6_)
  187.             {
  188.                _loc8_ = _loc5_[_loc7_];
  189.                _loc8_.regenerateStyleCache(true);
  190.                _loc7_++;
  191.             }
  192.          }
  193.          _loc7_ = 0;
  194.          while(_loc7_ < _loc6_)
  195.          {
  196.             _loc8_ = _loc5_[_loc7_];
  197.             _loc8_.notifyStyleChangeInChildren(param1,true);
  198.             _loc7_++;
  199.          }
  200.       }
  201.       
  202.       private function clearStyleAttr(param1:String) : void
  203.       {
  204.          var _loc2_:* = undefined;
  205.          if(!overrides)
  206.          {
  207.             overrides = {};
  208.          }
  209.          overrides[param1] = undefined;
  210.          for(_loc2_ in clones)
  211.          {
  212.             delete _loc2_[param1];
  213.          }
  214.       }
  215.       
  216.       mx_internal function clearOverride(param1:String) : void
  217.       {
  218.          if(Boolean(overrides) && Boolean(overrides[param1]))
  219.          {
  220.             delete overrides[param1];
  221.          }
  222.       }
  223.       
  224.       mx_internal function setStyle(param1:String, param2:*) : void
  225.       {
  226.          var _loc3_:Object = null;
  227.          var _loc4_:* = undefined;
  228.          var _loc5_:Number = NaN;
  229.          if(param2 === undefined)
  230.          {
  231.             clearStyleAttr(param1);
  232.             return;
  233.          }
  234.          if(param2 is String)
  235.          {
  236.             _loc5_ = StyleManager.getColorName(param2);
  237.             if(_loc5_ != NOT_A_COLOR)
  238.             {
  239.                param2 = _loc5_;
  240.             }
  241.          }
  242.          if(defaultFactory != null)
  243.          {
  244.             _loc3_ = new defaultFactory();
  245.             if(_loc3_[param1] !== param2)
  246.             {
  247.                if(!overrides)
  248.                {
  249.                   overrides = {};
  250.                }
  251.                overrides[param1] = param2;
  252.             }
  253.             else if(overrides)
  254.             {
  255.                delete overrides[param1];
  256.             }
  257.          }
  258.          if(factory != null)
  259.          {
  260.             _loc3_ = new factory();
  261.             if(_loc3_[param1] !== param2)
  262.             {
  263.                if(!overrides)
  264.                {
  265.                   overrides = {};
  266.                }
  267.                overrides[param1] = param2;
  268.             }
  269.             else if(overrides)
  270.             {
  271.                delete overrides[param1];
  272.             }
  273.          }
  274.          if(defaultFactory == null && factory == null)
  275.          {
  276.             if(!overrides)
  277.             {
  278.                overrides = {};
  279.             }
  280.             overrides[param1] = param2;
  281.          }
  282.          for(_loc4_ in clones)
  283.          {
  284.             _loc4_[param1] = param2;
  285.          }
  286.       }
  287.    }
  288. }
  289.  
  290.