home *** CD-ROM | disk | FTP | other *** search
/ PCGUIA 2010 Software/Programs / PCGuia_programas.iso / Software / Utils / Livebrush / Install-LivebrushLite.air / livebrush.swf / scripts / fl / managers / StyleManager.as < prev   
Encoding:
Text File  |  2009-10-26  |  7.7 KB  |  249 lines
  1. package fl.managers
  2. {
  3.    import fl.core.UIComponent;
  4.    import flash.text.TextFormat;
  5.    import flash.utils.Dictionary;
  6.    import flash.utils.getDefinitionByName;
  7.    import flash.utils.getQualifiedClassName;
  8.    import flash.utils.getQualifiedSuperclassName;
  9.    
  10.    public class StyleManager
  11.    {
  12.       private static var _instance:StyleManager;
  13.       
  14.       private var classToInstancesDict:Dictionary;
  15.       
  16.       private var globalStyles:Object;
  17.       
  18.       private var styleToClassesHash:Object;
  19.       
  20.       private var classToStylesDict:Dictionary;
  21.       
  22.       private var classToDefaultStylesDict:Dictionary;
  23.       
  24.       public function StyleManager()
  25.       {
  26.          super();
  27.          styleToClassesHash = {};
  28.          classToInstancesDict = new Dictionary(true);
  29.          classToStylesDict = new Dictionary(true);
  30.          classToDefaultStylesDict = new Dictionary(true);
  31.          globalStyles = UIComponent.getStyleDefinition();
  32.       }
  33.       
  34.       public static function clearComponentStyle(param1:Object, param2:String) : void
  35.       {
  36.          var _loc3_:Class = getClassDef(param1);
  37.          var _loc4_:Object = getInstance().classToStylesDict[_loc3_];
  38.          if(_loc4_ != null && _loc4_[param2] != null)
  39.          {
  40.             delete _loc4_[param2];
  41.             invalidateComponentStyle(_loc3_,param2);
  42.          }
  43.       }
  44.       
  45.       private static function getClassDef(param1:Object) : Class
  46.       {
  47.          var component:Object = param1;
  48.          if(component is Class)
  49.          {
  50.             return component as Class;
  51.          }
  52.          try
  53.          {
  54.             return getDefinitionByName(getQualifiedClassName(component)) as Class;
  55.          }
  56.          catch(e:Error)
  57.          {
  58.             if(component is UIComponent)
  59.             {
  60.                try
  61.                {
  62.                   return component.loaderInfo.applicationDomain.getDefinition(getQualifiedClassName(component)) as Class;
  63.                }
  64.                catch(e:Error)
  65.                {
  66.                }
  67.             }
  68.          }
  69.          return null;
  70.       }
  71.       
  72.       public static function clearStyle(param1:String) : void
  73.       {
  74.          setStyle(param1,null);
  75.       }
  76.       
  77.       public static function setComponentStyle(param1:Object, param2:String, param3:Object) : void
  78.       {
  79.          var _loc4_:Class = getClassDef(param1);
  80.          var _loc5_:Object = getInstance().classToStylesDict[_loc4_];
  81.          if(_loc5_ == null)
  82.          {
  83.             _loc5_ = getInstance().classToStylesDict[_loc4_] = {};
  84.          }
  85.          if(_loc5_ == param3)
  86.          {
  87.             return;
  88.          }
  89.          _loc5_[param2] = param3;
  90.          invalidateComponentStyle(_loc4_,param2);
  91.       }
  92.       
  93.       private static function setSharedStyles(param1:UIComponent) : void
  94.       {
  95.          var _loc5_:String = null;
  96.          var _loc2_:StyleManager = getInstance();
  97.          var _loc3_:Class = getClassDef(param1);
  98.          var _loc4_:Object = _loc2_.classToDefaultStylesDict[_loc3_];
  99.          for(_loc5_ in _loc4_)
  100.          {
  101.             param1.setSharedStyle(_loc5_,getSharedStyle(param1,_loc5_));
  102.          }
  103.       }
  104.       
  105.       public static function getComponentStyle(param1:Object, param2:String) : Object
  106.       {
  107.          var _loc3_:Class = getClassDef(param1);
  108.          var _loc4_:Object = getInstance().classToStylesDict[_loc3_];
  109.          return _loc4_ == null ? null : _loc4_[param2];
  110.       }
  111.       
  112.       private static function getInstance() : *
  113.       {
  114.          if(_instance == null)
  115.          {
  116.             _instance = new StyleManager();
  117.          }
  118.          return _instance;
  119.       }
  120.       
  121.       private static function invalidateComponentStyle(param1:Class, param2:String) : void
  122.       {
  123.          var _loc4_:Object = null;
  124.          var _loc5_:UIComponent = null;
  125.          var _loc3_:Dictionary = getInstance().classToInstancesDict[param1];
  126.          if(_loc3_ == null)
  127.          {
  128.             return;
  129.          }
  130.          for(_loc4_ in _loc3_)
  131.          {
  132.             _loc5_ = _loc4_ as UIComponent;
  133.             if(_loc5_ != null)
  134.             {
  135.                _loc5_.setSharedStyle(param2,getSharedStyle(_loc5_,param2));
  136.             }
  137.          }
  138.       }
  139.       
  140.       private static function invalidateStyle(param1:String) : void
  141.       {
  142.          var _loc3_:Object = null;
  143.          var _loc2_:Dictionary = getInstance().styleToClassesHash[param1];
  144.          if(_loc2_ == null)
  145.          {
  146.             return;
  147.          }
  148.          for(_loc3_ in _loc2_)
  149.          {
  150.             invalidateComponentStyle(Class(_loc3_),param1);
  151.          }
  152.       }
  153.       
  154.       public static function registerInstance(param1:UIComponent) : void
  155.       {
  156.          var target:Class = null;
  157.          var defaultStyles:Object = null;
  158.          var styleToClasses:Object = null;
  159.          var n:String = null;
  160.          var instance:UIComponent = param1;
  161.          var inst:StyleManager = getInstance();
  162.          var classDef:Class = getClassDef(instance);
  163.          if(classDef == null)
  164.          {
  165.             return;
  166.          }
  167.          if(inst.classToInstancesDict[classDef] == null)
  168.          {
  169.             inst.classToInstancesDict[classDef] = new Dictionary(true);
  170.             target = classDef;
  171.             while(defaultStyles == null)
  172.             {
  173.                if(target["getStyleDefinition"] != null)
  174.                {
  175.                   defaultStyles = target["getStyleDefinition"]();
  176.                   break;
  177.                }
  178.                try
  179.                {
  180.                   target = instance.loaderInfo.applicationDomain.getDefinition(getQualifiedSuperclassName(target)) as Class;
  181.                }
  182.                catch(err:Error)
  183.                {
  184.                   try
  185.                   {
  186.                      target = getDefinitionByName(getQualifiedSuperclassName(target)) as Class;
  187.                   }
  188.                   catch(e:Error)
  189.                   {
  190.                      defaultStyles = UIComponent.getStyleDefinition();
  191.                      break;
  192.                   }
  193.                }
  194.             }
  195.             styleToClasses = inst.styleToClassesHash;
  196.             for(n in defaultStyles)
  197.             {
  198.                if(styleToClasses[n] == null)
  199.                {
  200.                   styleToClasses[n] = new Dictionary(true);
  201.                }
  202.                styleToClasses[n][classDef] = true;
  203.             }
  204.             inst.classToDefaultStylesDict[classDef] = defaultStyles;
  205.             if(inst.classToStylesDict[classDef] == null)
  206.             {
  207.                inst.classToStylesDict[classDef] = {};
  208.             }
  209.          }
  210.          inst.classToInstancesDict[classDef][instance] = true;
  211.          setSharedStyles(instance);
  212.       }
  213.       
  214.       public static function getStyle(param1:String) : Object
  215.       {
  216.          return getInstance().globalStyles[param1];
  217.       }
  218.       
  219.       private static function getSharedStyle(param1:UIComponent, param2:String) : Object
  220.       {
  221.          var _loc3_:Class = getClassDef(param1);
  222.          var _loc4_:StyleManager = getInstance();
  223.          var _loc5_:Object = _loc4_.classToStylesDict[_loc3_][param2];
  224.          if(_loc5_ != null)
  225.          {
  226.             return _loc5_;
  227.          }
  228.          _loc5_ = _loc4_.globalStyles[param2];
  229.          if(_loc5_ != null)
  230.          {
  231.             return _loc5_;
  232.          }
  233.          return _loc4_.classToDefaultStylesDict[_loc3_][param2];
  234.       }
  235.       
  236.       public static function setStyle(param1:String, param2:Object) : void
  237.       {
  238.          var _loc3_:Object = getInstance().globalStyles;
  239.          if(_loc3_[param1] === param2 && !(param2 is TextFormat))
  240.          {
  241.             return;
  242.          }
  243.          _loc3_[param1] = param2;
  244.          invalidateStyle(param1);
  245.       }
  246.    }
  247. }
  248.  
  249.