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