home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2012 April / ME_04_2012.iso / Video-Tutorial / iPhoto / media / player.swf / scripts / mx / styles / StyleProtoChain.as < prev    next >
Encoding:
Text File  |  2011-11-11  |  24.9 KB  |  703 lines

  1. package mx.styles
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.system.ApplicationDomain;
  6.    import flash.utils.getQualifiedClassName;
  7.    import flash.utils.getQualifiedSuperclassName;
  8.    import mx.core.FlexGlobals;
  9.    import mx.core.IFlexDisplayObject;
  10.    import mx.core.IFlexModule;
  11.    import mx.core.IFlexModuleFactory;
  12.    import mx.core.IFontContextComponent;
  13.    import mx.core.IInvalidating;
  14.    import mx.core.IUITextField;
  15.    import mx.core.IVisualElement;
  16.    import mx.core.UIComponent;
  17.    import mx.core.mx_internal;
  18.    import mx.effects.EffectManager;
  19.    import mx.managers.SystemManager;
  20.    import mx.modules.IModule;
  21.    import mx.modules.ModuleManager;
  22.    import mx.utils.NameUtil;
  23.    import mx.utils.OrderedObject;
  24.    import mx.utils.object_proxy;
  25.    
  26.    use namespace mx_internal;
  27.    use namespace object_proxy;
  28.    
  29.    public class StyleProtoChain
  30.    {
  31.       mx_internal static const VERSION:String = "4.5.0.20967";
  32.       
  33.       public static var STYLE_UNINITIALIZED:Object = {};
  34.       
  35.       public function StyleProtoChain()
  36.       {
  37.          super();
  38.       }
  39.       
  40.       public static function getClassStyleDeclarations(param1:IStyleClient) : Array
  41.       {
  42.          var _loc11_:String = null;
  43.          var _loc12_:Array = null;
  44.          var _loc13_:Array = null;
  45.          var _loc14_:CSSStyleDeclaration = null;
  46.          var _loc2_:IStyleManager2 = getStyleManager(param1);
  47.          var _loc3_:Boolean = _loc2_.qualifiedTypeSelectors;
  48.          var _loc4_:String = _loc3_ ? getQualifiedClassName(param1) : param1.className;
  49.          var _loc5_:IAdvancedStyleClient = param1 as IAdvancedStyleClient;
  50.          var _loc6_:OrderedObject = getTypeHierarchy(param1,_loc3_);
  51.          var _loc7_:Array = _loc6_.object_proxy::propertyList;
  52.          var _loc8_:int = int(_loc7_.length);
  53.          var _loc9_:Array = null;
  54.          if(!_loc2_.hasAdvancedSelectors())
  55.          {
  56.             _loc9_ = _loc2_.typeSelectorCache[_loc4_];
  57.             if(_loc9_)
  58.             {
  59.                return _loc9_;
  60.             }
  61.          }
  62.          _loc9_ = [];
  63.          var _loc10_:int = _loc8_ - 1;
  64.          while(_loc10_ >= 0)
  65.          {
  66.             _loc11_ = _loc7_[_loc10_].toString();
  67.             if(_loc2_.hasAdvancedSelectors() && _loc5_ != null)
  68.             {
  69.                _loc12_ = _loc2_.getStyleDeclarations(_loc11_);
  70.                if(_loc12_)
  71.                {
  72.                   _loc13_ = matchStyleDeclarations(_loc12_,_loc5_);
  73.                   _loc9_ = _loc9_.concat(_loc13_);
  74.                }
  75.             }
  76.             else
  77.             {
  78.                _loc14_ = _loc2_.getMergedStyleDeclaration(_loc11_);
  79.                if(_loc14_)
  80.                {
  81.                   _loc9_.push(_loc14_);
  82.                }
  83.             }
  84.             _loc10_--;
  85.          }
  86.          if(_loc2_.hasAdvancedSelectors() && _loc5_ != null)
  87.          {
  88.             _loc9_ = sortOnSpecificity(_loc9_);
  89.          }
  90.          else
  91.          {
  92.             _loc2_.typeSelectorCache[_loc4_] = _loc9_;
  93.          }
  94.          return _loc9_;
  95.       }
  96.       
  97.       public static function initProtoChain(param1:IStyleClient) : void
  98.       {
  99.          var _loc3_:int = 0;
  100.          var _loc4_:int = 0;
  101.          var _loc14_:Object = null;
  102.          var _loc15_:DisplayObjectContainer = null;
  103.          var _loc16_:Array = null;
  104.          var _loc2_:IStyleManager2 = getStyleManager(param1);
  105.          var _loc5_:UIComponent = param1 as UIComponent;
  106.          var _loc6_:IAdvancedStyleClient = param1 as IAdvancedStyleClient;
  107.          var _loc7_:CSSStyleDeclaration = null;
  108.          var _loc8_:Array = [];
  109.          var _loc9_:Boolean = false;
  110.          var _loc10_:Object = param1.styleName;
  111.          if(_loc10_)
  112.          {
  113.             if(_loc10_ is CSSStyleDeclaration)
  114.             {
  115.                _loc8_.push(CSSStyleDeclaration(_loc10_));
  116.             }
  117.             else
  118.             {
  119.                if(_loc10_ is IFlexDisplayObject || _loc10_ is IStyleClient)
  120.                {
  121.                   StyleProtoChain.initProtoChainForUIComponentStyleName(param1);
  122.                   return;
  123.                }
  124.                if(_loc10_ is String)
  125.                {
  126.                   _loc9_ = true;
  127.                }
  128.             }
  129.          }
  130.          var _loc11_:Object = _loc2_.stylesRoot;
  131.          if((Boolean(_loc11_)) && Boolean(_loc11_.effects))
  132.          {
  133.             param1.registerEffects(_loc11_.effects);
  134.          }
  135.          var _loc12_:IStyleClient = null;
  136.          if(param1 is IVisualElement)
  137.          {
  138.             _loc12_ = IVisualElement(param1).parent as IStyleClient;
  139.          }
  140.          else if(param1 is IAdvancedStyleClient)
  141.          {
  142.             _loc12_ = IAdvancedStyleClient(param1).styleParent as IStyleClient;
  143.          }
  144.          if(_loc12_)
  145.          {
  146.             _loc14_ = _loc12_.inheritingStyles;
  147.             if(_loc14_ == StyleProtoChain.STYLE_UNINITIALIZED)
  148.             {
  149.                _loc14_ = _loc11_;
  150.             }
  151.             if(param1 is IModule)
  152.             {
  153.                _loc7_ = _loc2_.getStyleDeclaration("global");
  154.                if(_loc7_)
  155.                {
  156.                   _loc14_ = _loc7_.mx_internal::addStyleToProtoChain(_loc14_,DisplayObject(param1));
  157.                }
  158.             }
  159.          }
  160.          else if(Boolean(_loc5_) && _loc5_.isPopUp)
  161.          {
  162.             _loc15_ = _loc5_.mx_internal::_owner;
  163.             if((Boolean(_loc15_)) && _loc15_ is IStyleClient)
  164.             {
  165.                _loc14_ = IStyleClient(_loc15_).inheritingStyles;
  166.             }
  167.             else
  168.             {
  169.                _loc14_ = FlexGlobals.topLevelApplication.inheritingStyles;
  170.             }
  171.          }
  172.          else
  173.          {
  174.             _loc14_ = _loc2_.stylesRoot;
  175.          }
  176.          var _loc13_:Array = null;
  177.          if(_loc2_.hasAdvancedSelectors() && _loc6_ != null)
  178.          {
  179.             _loc13_ = getMatchingStyleDeclarations(_loc6_,_loc8_);
  180.             _loc3_ = _loc13_ != null ? int(_loc13_.length) : 0;
  181.             _loc4_ = 0;
  182.             while(_loc4_ < _loc3_)
  183.             {
  184.                _loc7_ = _loc13_[_loc4_];
  185.                _loc14_ = _loc7_.mx_internal::addStyleToProtoChain(_loc14_,_loc5_);
  186.                _loc11_ = _loc7_.mx_internal::addStyleToProtoChain(_loc11_,_loc5_);
  187.                if(_loc7_.mx_internal::effects)
  188.                {
  189.                   _loc6_.registerEffects(_loc7_.mx_internal::effects);
  190.                }
  191.                _loc4_++;
  192.             }
  193.          }
  194.          else
  195.          {
  196.             if(_loc9_)
  197.             {
  198.                _loc16_ = _loc10_.split(/\s+/);
  199.                _loc3_ = int(_loc16_.length);
  200.                _loc4_ = 0;
  201.                while(_loc4_ < _loc3_)
  202.                {
  203.                   if(_loc16_[_loc4_].length)
  204.                   {
  205.                      _loc7_ = _loc2_.getMergedStyleDeclaration("." + _loc16_[_loc4_]);
  206.                      if(_loc7_)
  207.                      {
  208.                         _loc8_.push(_loc7_);
  209.                      }
  210.                   }
  211.                   _loc4_++;
  212.                }
  213.             }
  214.             _loc13_ = param1.getClassStyleDeclarations();
  215.             _loc3_ = _loc13_ != null ? int(_loc13_.length) : 0;
  216.             _loc4_ = 0;
  217.             while(_loc4_ < _loc3_)
  218.             {
  219.                _loc7_ = _loc13_[_loc4_];
  220.                _loc14_ = _loc7_.mx_internal::addStyleToProtoChain(_loc14_,_loc5_);
  221.                _loc11_ = _loc7_.mx_internal::addStyleToProtoChain(_loc11_,_loc5_);
  222.                if(_loc7_.mx_internal::effects)
  223.                {
  224.                   param1.registerEffects(_loc7_.mx_internal::effects);
  225.                }
  226.                _loc4_++;
  227.             }
  228.             _loc3_ = int(_loc8_.length);
  229.             _loc4_ = 0;
  230.             while(_loc4_ < _loc3_)
  231.             {
  232.                _loc7_ = _loc8_[_loc4_];
  233.                if(_loc7_)
  234.                {
  235.                   _loc14_ = _loc7_.mx_internal::addStyleToProtoChain(_loc14_,_loc5_);
  236.                   _loc11_ = _loc7_.mx_internal::addStyleToProtoChain(_loc11_,_loc5_);
  237.                   if(_loc7_.mx_internal::effects)
  238.                   {
  239.                      param1.registerEffects(_loc7_.mx_internal::effects);
  240.                   }
  241.                }
  242.                _loc4_++;
  243.             }
  244.          }
  245.          _loc7_ = param1.styleDeclaration;
  246.          param1.inheritingStyles = !!_loc7_ ? _loc7_.mx_internal::addStyleToProtoChain(_loc14_,_loc5_) : _loc14_;
  247.          param1.nonInheritingStyles = !!_loc7_ ? _loc7_.mx_internal::addStyleToProtoChain(_loc11_,_loc5_) : _loc11_;
  248.       }
  249.       
  250.       public static function initProtoChainForUIComponentStyleName(param1:IStyleClient) : void
  251.       {
  252.          var _loc10_:CSSStyleDeclaration = null;
  253.          var _loc2_:IStyleManager2 = getStyleManager(param1);
  254.          var _loc3_:IStyleClient = IStyleClient(param1.styleName);
  255.          var _loc4_:DisplayObject = param1 as DisplayObject;
  256.          var _loc5_:Object = _loc3_.nonInheritingStyles;
  257.          if(!_loc5_ || _loc5_ == StyleProtoChain.STYLE_UNINITIALIZED)
  258.          {
  259.             _loc5_ = _loc2_.stylesRoot;
  260.             if(_loc5_.effects)
  261.             {
  262.                param1.registerEffects(_loc5_.effects);
  263.             }
  264.          }
  265.          var _loc6_:Object = _loc3_.inheritingStyles;
  266.          if(!_loc6_ || _loc6_ == StyleProtoChain.STYLE_UNINITIALIZED)
  267.          {
  268.             _loc6_ = _loc2_.stylesRoot;
  269.          }
  270.          var _loc7_:Array = param1.getClassStyleDeclarations();
  271.          var _loc8_:int = int(_loc7_.length);
  272.          if(_loc3_ is StyleProxy)
  273.          {
  274.             if(_loc8_ == 0)
  275.             {
  276.                _loc5_ = addProperties(_loc5_,_loc3_,false);
  277.             }
  278.             _loc4_ = StyleProxy(_loc3_).source as DisplayObject;
  279.          }
  280.          var _loc9_:int = 0;
  281.          while(_loc9_ < _loc8_)
  282.          {
  283.             _loc10_ = _loc7_[_loc9_];
  284.             _loc6_ = _loc10_.mx_internal::addStyleToProtoChain(_loc6_,_loc4_);
  285.             _loc6_ = addProperties(_loc6_,_loc3_,true);
  286.             _loc5_ = _loc10_.mx_internal::addStyleToProtoChain(_loc5_,_loc4_);
  287.             _loc5_ = addProperties(_loc5_,_loc3_,false);
  288.             if(_loc10_.mx_internal::effects)
  289.             {
  290.                param1.registerEffects(_loc10_.mx_internal::effects);
  291.             }
  292.             _loc9_++;
  293.          }
  294.          param1.inheritingStyles = !!param1.styleDeclaration ? param1.styleDeclaration.mx_internal::addStyleToProtoChain(_loc6_,_loc4_) : _loc6_;
  295.          param1.nonInheritingStyles = !!param1.styleDeclaration ? param1.styleDeclaration.mx_internal::addStyleToProtoChain(_loc5_,_loc4_) : _loc5_;
  296.       }
  297.       
  298.       private static function addProperties(param1:Object, param2:IStyleClient, param3:Boolean) : Object
  299.       {
  300.          var _loc9_:Array = null;
  301.          var _loc10_:CSSStyleDeclaration = null;
  302.          var _loc12_:int = 0;
  303.          var _loc13_:int = 0;
  304.          var _loc14_:Array = null;
  305.          var _loc15_:int = 0;
  306.          var _loc4_:Object = param2 is StyleProxy && !param3 ? StyleProxy(param2).filterMap : null;
  307.          var _loc5_:IStyleClient = param2;
  308.          while(_loc5_ is StyleProxy)
  309.          {
  310.             _loc5_ = StyleProxy(_loc5_).source;
  311.          }
  312.          var _loc6_:DisplayObject = _loc5_ as DisplayObject;
  313.          var _loc7_:IAdvancedStyleClient = param2 as IAdvancedStyleClient;
  314.          var _loc8_:Object = param2.styleName;
  315.          var _loc11_:IStyleManager2 = getStyleManager(_loc6_);
  316.          if(_loc7_ != null && _loc11_.hasAdvancedSelectors())
  317.          {
  318.             if(_loc8_ is CSSStyleDeclaration)
  319.             {
  320.                _loc9_ = [CSSStyleDeclaration(_loc8_)];
  321.             }
  322.             _loc9_ = getMatchingStyleDeclarations(_loc7_,_loc9_);
  323.             _loc13_ = 0;
  324.             while(_loc13_ < _loc9_.length)
  325.             {
  326.                _loc10_ = _loc9_[_loc13_];
  327.                if(_loc10_)
  328.                {
  329.                   param1 = _loc10_.mx_internal::addStyleToProtoChain(param1,_loc6_,_loc4_);
  330.                   if(_loc10_.mx_internal::effects)
  331.                   {
  332.                      param2.registerEffects(_loc10_.mx_internal::effects);
  333.                   }
  334.                }
  335.                _loc13_++;
  336.             }
  337.             if(_loc8_ is IStyleClient)
  338.             {
  339.                param1 = addProperties(param1,IStyleClient(_loc8_),param3);
  340.             }
  341.          }
  342.          else
  343.          {
  344.             _loc9_ = param2.getClassStyleDeclarations();
  345.             _loc12_ = int(_loc9_.length);
  346.             _loc13_ = 0;
  347.             while(_loc13_ < _loc12_)
  348.             {
  349.                _loc10_ = _loc9_[_loc13_];
  350.                param1 = _loc10_.mx_internal::addStyleToProtoChain(param1,_loc6_,_loc4_);
  351.                if(_loc10_.mx_internal::effects)
  352.                {
  353.                   param2.registerEffects(_loc10_.mx_internal::effects);
  354.                }
  355.                _loc13_++;
  356.             }
  357.             if(_loc8_)
  358.             {
  359.                _loc9_ = [];
  360.                if(typeof _loc8_ == "object")
  361.                {
  362.                   if(_loc8_ is CSSStyleDeclaration)
  363.                   {
  364.                      _loc9_.push(CSSStyleDeclaration(_loc8_));
  365.                   }
  366.                   else
  367.                   {
  368.                      param1 = addProperties(param1,IStyleClient(_loc8_),param3);
  369.                   }
  370.                }
  371.                else
  372.                {
  373.                   _loc14_ = _loc8_.split(/\s+/);
  374.                   _loc15_ = 0;
  375.                   while(_loc15_ < _loc14_.length)
  376.                   {
  377.                      if(_loc14_[_loc15_].length)
  378.                      {
  379.                         _loc9_.push(_loc11_.getMergedStyleDeclaration("." + _loc14_[_loc15_]));
  380.                      }
  381.                      _loc15_++;
  382.                   }
  383.                }
  384.                _loc13_ = 0;
  385.                while(_loc13_ < _loc9_.length)
  386.                {
  387.                   _loc10_ = _loc9_[_loc13_];
  388.                   if(_loc10_)
  389.                   {
  390.                      param1 = _loc10_.mx_internal::addStyleToProtoChain(param1,_loc6_,_loc4_);
  391.                      if(_loc10_.mx_internal::effects)
  392.                      {
  393.                         param2.registerEffects(_loc10_.mx_internal::effects);
  394.                      }
  395.                   }
  396.                   _loc13_++;
  397.                }
  398.             }
  399.          }
  400.          if(param2.styleDeclaration)
  401.          {
  402.             param1 = param2.styleDeclaration.mx_internal::addStyleToProtoChain(param1,_loc6_,_loc4_);
  403.          }
  404.          return param1;
  405.       }
  406.       
  407.       public static function initTextField(param1:IUITextField) : void
  408.       {
  409.          var _loc8_:Array = null;
  410.          var _loc9_:int = 0;
  411.          var _loc10_:CSSStyleDeclaration = null;
  412.          var _loc2_:IStyleManager2 = StyleManager.getStyleManager(param1.moduleFactory);
  413.          var _loc3_:Object = param1.styleName;
  414.          var _loc4_:Array = [];
  415.          if(_loc3_)
  416.          {
  417.             if(typeof _loc3_ == "object")
  418.             {
  419.                if(!(_loc3_ is CSSStyleDeclaration))
  420.                {
  421.                   if(_loc3_ is StyleProxy)
  422.                   {
  423.                      param1.inheritingStyles = IStyleClient(_loc3_).inheritingStyles;
  424.                      param1.nonInheritingStyles = addProperties(_loc2_.stylesRoot,IStyleClient(_loc3_),false);
  425.                      return;
  426.                   }
  427.                   param1.inheritingStyles = IStyleClient(_loc3_).inheritingStyles;
  428.                   param1.nonInheritingStyles = IStyleClient(_loc3_).nonInheritingStyles;
  429.                   return;
  430.                }
  431.                _loc4_.push(CSSStyleDeclaration(_loc3_));
  432.             }
  433.             else
  434.             {
  435.                _loc8_ = _loc3_.split(/\s+/);
  436.                _loc9_ = 0;
  437.                while(_loc9_ < _loc8_.length)
  438.                {
  439.                   if(_loc8_[_loc9_].length)
  440.                   {
  441.                      _loc4_.push(_loc2_.getMergedStyleDeclaration("." + _loc8_[_loc9_]));
  442.                   }
  443.                   _loc9_++;
  444.                }
  445.             }
  446.          }
  447.          var _loc5_:Object = IStyleClient(param1.parent).inheritingStyles;
  448.          var _loc6_:Object = _loc2_.stylesRoot;
  449.          if(!_loc5_)
  450.          {
  451.             _loc5_ = _loc2_.stylesRoot;
  452.          }
  453.          var _loc7_:int = 0;
  454.          while(_loc7_ < _loc4_.length)
  455.          {
  456.             _loc10_ = _loc4_[_loc7_];
  457.             if(_loc10_)
  458.             {
  459.                _loc5_ = _loc10_.mx_internal::addStyleToProtoChain(_loc5_,DisplayObject(param1));
  460.                _loc6_ = _loc10_.mx_internal::addStyleToProtoChain(_loc6_,DisplayObject(param1));
  461.             }
  462.             _loc7_++;
  463.          }
  464.          param1.inheritingStyles = _loc5_;
  465.          param1.nonInheritingStyles = _loc6_;
  466.       }
  467.       
  468.       public static function setStyle(param1:IStyleClient, param2:String, param3:*) : void
  469.       {
  470.          var _loc4_:IStyleManager2 = getStyleManager(param1);
  471.          if(param2 == "styleName")
  472.          {
  473.             param1.styleName = param3;
  474.             return;
  475.          }
  476.          if(EffectManager.mx_internal::getEventForEffectTrigger(param2) != "")
  477.          {
  478.             EffectManager.mx_internal::setStyle(param2,param1);
  479.          }
  480.          var _loc5_:Boolean = Boolean(_loc4_.isInheritingStyle(param2));
  481.          var _loc6_:* = param1.inheritingStyles != StyleProtoChain.STYLE_UNINITIALIZED;
  482.          var _loc7_:* = param1.getStyle(param2) != param3;
  483.          if(!param1.styleDeclaration)
  484.          {
  485.             param1.styleDeclaration = new CSSStyleDeclaration(null,_loc4_);
  486.             param1.styleDeclaration.mx_internal::setLocalStyle(param2,param3);
  487.             if(_loc6_)
  488.             {
  489.                param1.regenerateStyleCache(_loc5_);
  490.             }
  491.          }
  492.          else
  493.          {
  494.             param1.styleDeclaration.mx_internal::setLocalStyle(param2,param3);
  495.          }
  496.          if(_loc6_ && _loc7_)
  497.          {
  498.             param1.styleChanged(param2);
  499.             param1.notifyStyleChangeInChildren(param2,_loc5_);
  500.          }
  501.       }
  502.       
  503.       public static function styleChanged(param1:IInvalidating, param2:String) : void
  504.       {
  505.          var _loc4_:IInvalidating = null;
  506.          var _loc3_:IStyleManager2 = getStyleManager(param1);
  507.          if(param1 is IFontContextComponent && "hasFontContextChanged" in param1 && Boolean(param1["hasFontContextChanged"]()))
  508.          {
  509.             param1.invalidateProperties();
  510.          }
  511.          if(!param2 || param2 == "styleName" || param2 == "layoutDirection")
  512.          {
  513.             param1.invalidateProperties();
  514.          }
  515.          if(!param2 || param2 == "styleName" || Boolean(_loc3_.isSizeInvalidatingStyle(param2)))
  516.          {
  517.             param1.invalidateSize();
  518.          }
  519.          if(!param2 || param2 == "styleName" || param2 == "themeColor")
  520.          {
  521.             if(param1 is UIComponent)
  522.             {
  523.                param1["initThemeColor"]();
  524.             }
  525.          }
  526.          param1.invalidateDisplayList();
  527.          if(param1 is IVisualElement)
  528.          {
  529.             _loc4_ = IVisualElement(param1).parent as IInvalidating;
  530.          }
  531.          if(_loc4_)
  532.          {
  533.             if(param2 == "styleName" || Boolean(_loc3_.isParentSizeInvalidatingStyle(param2)))
  534.             {
  535.                _loc4_.invalidateSize();
  536.             }
  537.             if(param2 == "styleName" || Boolean(_loc3_.isParentDisplayListInvalidatingStyle(param2)))
  538.             {
  539.                _loc4_.invalidateDisplayList();
  540.             }
  541.          }
  542.       }
  543.       
  544.       public static function matchesCSSType(param1:IAdvancedStyleClient, param2:String) : Boolean
  545.       {
  546.          var _loc3_:IStyleManager2 = getStyleManager(param1);
  547.          var _loc4_:Boolean = _loc3_.qualifiedTypeSelectors;
  548.          var _loc5_:OrderedObject = getTypeHierarchy(param1,_loc4_);
  549.          return _loc5_.object_proxy::getObjectProperty(param2) != null;
  550.       }
  551.       
  552.       public static function getMatchingStyleDeclarations(param1:IAdvancedStyleClient, param2:Array = null) : Array
  553.       {
  554.          var _loc3_:IStyleManager2 = getStyleManager(param1);
  555.          if(param2 == null)
  556.          {
  557.             param2 = [];
  558.          }
  559.          var _loc4_:Array = _loc3_.getStyleDeclarations("*");
  560.          param2 = matchStyleDeclarations(_loc4_,param1).concat(param2);
  561.          if(param2.length > 0)
  562.          {
  563.             param2 = param1.getClassStyleDeclarations().concat(param2);
  564.             param2 = sortOnSpecificity(param2);
  565.          }
  566.          else
  567.          {
  568.             param2 = param1.getClassStyleDeclarations();
  569.          }
  570.          return param2;
  571.       }
  572.       
  573.       private static function getTypeHierarchy(param1:IStyleClient, param2:Boolean = true) : OrderedObject
  574.       {
  575.          var myApplicationDomain:ApplicationDomain = null;
  576.          var factory:IFlexModuleFactory = null;
  577.          var myRoot:DisplayObject = null;
  578.          var type:String = null;
  579.          var object:IStyleClient = param1;
  580.          var qualified:Boolean = param2;
  581.          var styleManager:IStyleManager2 = getStyleManager(object);
  582.          var className:String = getQualifiedClassName(object);
  583.          var hierarchy:OrderedObject = styleManager.typeHierarchyCache[className] as OrderedObject;
  584.          if(hierarchy == null)
  585.          {
  586.             hierarchy = new OrderedObject();
  587.             factory = ModuleManager.getAssociatedFactory(object);
  588.             if(factory != null)
  589.             {
  590.                myApplicationDomain = ApplicationDomain(factory.info()["currentDomain"]);
  591.             }
  592.             else
  593.             {
  594.                myRoot = SystemManager.getSWFRoot(object);
  595.                if(!myRoot)
  596.                {
  597.                   return hierarchy;
  598.                }
  599.                myApplicationDomain = myRoot.loaderInfo.applicationDomain;
  600.             }
  601.             styleManager.typeHierarchyCache[className] = hierarchy;
  602.             while(!isStopClass(className))
  603.             {
  604.                try
  605.                {
  606.                   if(qualified)
  607.                   {
  608.                      type = className.replace("::",".");
  609.                   }
  610.                   else
  611.                   {
  612.                      type = NameUtil.getUnqualifiedClassName(className);
  613.                   }
  614.                   hierarchy.object_proxy::setObjectProperty(type,true);
  615.                   className = getQualifiedSuperclassName(myApplicationDomain.getDefinition(className));
  616.                }
  617.                catch(e:ReferenceError)
  618.                {
  619.                   className = null;
  620.                }
  621.             }
  622.          }
  623.          return hierarchy;
  624.       }
  625.       
  626.       private static function isStopClass(param1:String) : Boolean
  627.       {
  628.          return param1 == null || param1 == "mx.core::UIComponent" || param1 == "mx.core::UITextField" || param1 == "mx.graphics.baseClasses::GraphicElement";
  629.       }
  630.       
  631.       private static function matchStyleDeclarations(param1:Array, param2:IAdvancedStyleClient) : Array
  632.       {
  633.          var _loc4_:CSSStyleDeclaration = null;
  634.          var _loc3_:Array = [];
  635.          for each(_loc4_ in param1)
  636.          {
  637.             if(_loc4_.matchesStyleClient(param2))
  638.             {
  639.                _loc3_.push(_loc4_);
  640.             }
  641.          }
  642.          return _loc3_;
  643.       }
  644.       
  645.       private static function sortOnSpecificity(param1:Array) : Array
  646.       {
  647.          var _loc3_:CSSStyleDeclaration = null;
  648.          var _loc5_:int = 0;
  649.          var _loc2_:Number = param1.length;
  650.          if(_loc2_ <= 1)
  651.          {
  652.             return param1;
  653.          }
  654.          var _loc4_:int = 1;
  655.          while(_loc4_ < _loc2_)
  656.          {
  657.             _loc5_ = _loc4_;
  658.             while(_loc5_ > 0)
  659.             {
  660.                if(param1[_loc5_].specificity >= param1[_loc5_ - 1].specificity)
  661.                {
  662.                   break;
  663.                }
  664.                _loc3_ = param1[_loc5_];
  665.                param1[_loc5_] = param1[_loc5_ - 1];
  666.                param1[_loc5_ - 1] = _loc3_;
  667.                _loc5_--;
  668.             }
  669.             _loc4_++;
  670.          }
  671.          return param1;
  672.       }
  673.       
  674.       private static function getStyleManager(param1:Object) : IStyleManager2
  675.       {
  676.          if(param1 is IFlexModule)
  677.          {
  678.             return StyleManager.getStyleManager(IFlexModule(param1).moduleFactory);
  679.          }
  680.          if(param1 is StyleProxy)
  681.          {
  682.             return getStyleManagerFromStyleProxy(StyleProxy(param1));
  683.          }
  684.          return StyleManager.getStyleManager(null);
  685.       }
  686.       
  687.       private static function getStyleManagerFromStyleProxy(param1:StyleProxy) : IStyleManager2
  688.       {
  689.          var _loc2_:IStyleClient = param1;
  690.          while(_loc2_ is StyleProxy)
  691.          {
  692.             _loc2_ = StyleProxy(_loc2_).source;
  693.          }
  694.          if(_loc2_ is IFlexModule)
  695.          {
  696.             return StyleManager.getStyleManager(IFlexModule(_loc2_).moduleFactory);
  697.          }
  698.          return StyleManager.getStyleManager(null);
  699.       }
  700.    }
  701. }
  702.  
  703.