home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2012 April / ME_04_2012.iso / Video-Tutorial / iPhoto / media / player.swf / scripts / mx / controls / SWFLoader.as < prev    next >
Encoding:
Text File  |  2011-11-11  |  49.4 KB  |  1,429 lines
  1. package mx.controls
  2. {
  3.    import flash.display.Bitmap;
  4.    import flash.display.DisplayObject;
  5.    import flash.display.DisplayObjectContainer;
  6.    import flash.display.Loader;
  7.    import flash.display.LoaderInfo;
  8.    import flash.display.Sprite;
  9.    import flash.events.Event;
  10.    import flash.events.EventDispatcher;
  11.    import flash.events.HTTPStatusEvent;
  12.    import flash.events.IEventDispatcher;
  13.    import flash.events.IOErrorEvent;
  14.    import flash.events.MouseEvent;
  15.    import flash.events.ProgressEvent;
  16.    import flash.events.SecurityErrorEvent;
  17.    import flash.geom.Point;
  18.    import flash.geom.Rectangle;
  19.    import flash.net.URLRequest;
  20.    import flash.system.ApplicationDomain;
  21.    import flash.system.Capabilities;
  22.    import flash.system.LoaderContext;
  23.    import flash.system.SecurityDomain;
  24.    import flash.utils.ByteArray;
  25.    import mx.core.FlexGlobals;
  26.    import mx.core.FlexLoader;
  27.    import mx.core.FlexVersion;
  28.    import mx.core.IFlexDisplayObject;
  29.    import mx.core.IFlexModuleFactory;
  30.    import mx.core.ILayoutDirectionElement;
  31.    import mx.core.ISWFLoader;
  32.    import mx.core.IUIComponent;
  33.    import mx.core.UIComponent;
  34.    import mx.core.mx_internal;
  35.    import mx.events.FlexEvent;
  36.    import mx.events.InterManagerRequest;
  37.    import mx.events.InvalidateRequestData;
  38.    import mx.events.Request;
  39.    import mx.events.SWFBridgeEvent;
  40.    import mx.events.SWFBridgeRequest;
  41.    import mx.managers.CursorManager;
  42.    import mx.managers.IMarshalSystemManager;
  43.    import mx.managers.ISystemManager;
  44.    import mx.managers.SystemManagerGlobals;
  45.    import mx.styles.ISimpleStyleClient;
  46.    import mx.utils.LoaderUtil;
  47.    
  48.    use namespace mx_internal;
  49.    
  50.    public class SWFLoader extends UIComponent implements ISWFLoader
  51.    {
  52.       mx_internal static const VERSION:String = "4.5.0.20967";
  53.       
  54.       mx_internal var contentHolder:DisplayObject;
  55.       
  56.       private var contentChanged:Boolean = false;
  57.       
  58.       private var scaleContentChanged:Boolean = false;
  59.       
  60.       private var smoothBitmapContentChanged:Boolean = false;
  61.       
  62.       private var isContentLoaded:Boolean = false;
  63.       
  64.       private var brokenImage:Boolean = false;
  65.       
  66.       private var resizableContent:Boolean = false;
  67.       
  68.       private var flexContent:Boolean = false;
  69.       
  70.       private var contentRequestID:String = null;
  71.       
  72.       private var attemptingChildAppDomain:Boolean = false;
  73.       
  74.       private var requestedURL:URLRequest;
  75.       
  76.       private var brokenImageBorder:IFlexDisplayObject;
  77.       
  78.       private var explicitLoaderContext:Boolean = false;
  79.       
  80.       private var mouseShield:Sprite;
  81.       
  82.       private var useUnloadAndStop:Boolean;
  83.       
  84.       private var unloadAndStopGC:Boolean;
  85.       
  86.       private var _autoLoad:Boolean = true;
  87.       
  88.       private var _loadForCompatibility:Boolean = false;
  89.       
  90.       private var _bytesLoaded:Number = NaN;
  91.       
  92.       private var _bytesTotal:Number = NaN;
  93.       
  94.       private var _loaderContext:LoaderContext;
  95.       
  96.       private var _maintainAspectRatio:Boolean = true;
  97.       
  98.       private var _swfBridge:IEventDispatcher;
  99.       
  100.       private var _scaleContent:Boolean = true;
  101.       
  102.       private var _showBusyCursor:Boolean = false;
  103.       
  104.       private var _smoothBitmapContent:Boolean = false;
  105.       
  106.       private var _source:Object;
  107.       
  108.       private var _trustContent:Boolean = false;
  109.       
  110.       public function SWFLoader()
  111.       {
  112.          super();
  113.          tabEnabled = false;
  114.          tabFocusEnabled = false;
  115.          addEventListener(FlexEvent.INITIALIZE,this.initializeHandler);
  116.          addEventListener(Event.ADDED_TO_STAGE,this.addedToStageHandler);
  117.          addEventListener(MouseEvent.CLICK,this.clickHandler);
  118.          showInAutomationHierarchy = false;
  119.       }
  120.       
  121.       [Bindable("autoLoadChanged")]
  122.       public function get autoLoad() : Boolean
  123.       {
  124.          return this._autoLoad;
  125.       }
  126.       
  127.       public function set autoLoad(param1:Boolean) : void
  128.       {
  129.          if(this._autoLoad != param1)
  130.          {
  131.             this._autoLoad = param1;
  132.             this.contentChanged = true;
  133.             invalidateProperties();
  134.             invalidateSize();
  135.             invalidateDisplayList();
  136.             dispatchEvent(new Event("autoLoadChanged"));
  137.          }
  138.       }
  139.       
  140.       [Bindable("loadForCompatibilityChanged")]
  141.       public function get loadForCompatibility() : Boolean
  142.       {
  143.          return this._loadForCompatibility;
  144.       }
  145.       
  146.       public function set loadForCompatibility(param1:Boolean) : void
  147.       {
  148.          if(this._loadForCompatibility != param1)
  149.          {
  150.             this._loadForCompatibility = param1;
  151.             this.contentChanged = true;
  152.             invalidateProperties();
  153.             invalidateSize();
  154.             invalidateDisplayList();
  155.             dispatchEvent(new Event("loadForCompatibilityChanged"));
  156.          }
  157.       }
  158.       
  159.       [Bindable("progress")]
  160.       public function get bytesLoaded() : Number
  161.       {
  162.          return this._bytesLoaded;
  163.       }
  164.       
  165.       [Bindable("complete")]
  166.       public function get bytesTotal() : Number
  167.       {
  168.          return this._bytesTotal;
  169.       }
  170.       
  171.       public function get content() : DisplayObject
  172.       {
  173.          if(this.mx_internal::contentHolder is Loader)
  174.          {
  175.             return Loader(this.mx_internal::contentHolder).content;
  176.          }
  177.          return this.mx_internal::contentHolder;
  178.       }
  179.       
  180.       public function get contentHeight() : Number
  181.       {
  182.          return !!this.mx_internal::contentHolder ? this.mx_internal::contentHolder.height : NaN;
  183.       }
  184.       
  185.       private function get contentHolderHeight() : Number
  186.       {
  187.          var loaderInfo:LoaderInfo = null;
  188.          var mp:IMarshalSystemManager = null;
  189.          var content:IFlexDisplayObject = null;
  190.          var bridge:IEventDispatcher = null;
  191.          var request:SWFBridgeRequest = null;
  192.          var testContent:DisplayObject = null;
  193.          if(this.mx_internal::contentHolder is Loader)
  194.          {
  195.             loaderInfo = Loader(this.mx_internal::contentHolder).contentLoaderInfo;
  196.          }
  197.          if(loaderInfo)
  198.          {
  199.             if(loaderInfo.contentType == "application/x-shockwave-flash")
  200.             {
  201.                try
  202.                {
  203.                   mp = IMarshalSystemManager(systemManager.getImplementation("mx.managers::IMarshalSystemManager"));
  204.                   if(Boolean(mp) && Boolean(mp.swfBridgeGroup))
  205.                   {
  206.                      bridge = this.swfBridge;
  207.                      if(bridge)
  208.                      {
  209.                         request = new SWFBridgeRequest(SWFBridgeRequest.GET_SIZE_REQUEST);
  210.                         bridge.dispatchEvent(request);
  211.                         return request.data.height;
  212.                      }
  213.                   }
  214.                   content = Loader(this.mx_internal::contentHolder).content as IFlexDisplayObject;
  215.                   if(content)
  216.                   {
  217.                      return content.measuredHeight;
  218.                   }
  219.                }
  220.                catch(error:Error)
  221.                {
  222.                   return mx_internal::contentHolder.height;
  223.                }
  224.             }
  225.             else
  226.             {
  227.                try
  228.                {
  229.                   testContent = Loader(this.mx_internal::contentHolder).content;
  230.                }
  231.                catch(error:Error)
  232.                {
  233.                   return mx_internal::contentHolder.height;
  234.                }
  235.             }
  236.             return loaderInfo.height;
  237.          }
  238.          if(this.mx_internal::contentHolder is IUIComponent)
  239.          {
  240.             return IUIComponent(this.mx_internal::contentHolder).getExplicitOrMeasuredHeight();
  241.          }
  242.          if(this.mx_internal::contentHolder is IFlexDisplayObject)
  243.          {
  244.             return IFlexDisplayObject(this.mx_internal::contentHolder).measuredHeight;
  245.          }
  246.          return this.mx_internal::contentHolder.height;
  247.       }
  248.       
  249.       private function get contentHolderWidth() : Number
  250.       {
  251.          var loaderInfo:LoaderInfo = null;
  252.          var content:IFlexDisplayObject = null;
  253.          var request:SWFBridgeRequest = null;
  254.          var testContent:DisplayObject = null;
  255.          if(this.mx_internal::contentHolder is Loader)
  256.          {
  257.             loaderInfo = Loader(this.mx_internal::contentHolder).contentLoaderInfo;
  258.          }
  259.          if(loaderInfo)
  260.          {
  261.             if(loaderInfo.contentType == "application/x-shockwave-flash")
  262.             {
  263.                try
  264.                {
  265.                   if(this.swfBridge)
  266.                   {
  267.                      request = new SWFBridgeRequest(SWFBridgeRequest.GET_SIZE_REQUEST);
  268.                      this.swfBridge.dispatchEvent(request);
  269.                      return request.data.width;
  270.                   }
  271.                   content = Loader(this.mx_internal::contentHolder).content as IFlexDisplayObject;
  272.                   if(content)
  273.                   {
  274.                      return content.measuredWidth;
  275.                   }
  276.                }
  277.                catch(error:Error)
  278.                {
  279.                   return mx_internal::contentHolder.width;
  280.                }
  281.             }
  282.             else
  283.             {
  284.                try
  285.                {
  286.                   testContent = Loader(this.mx_internal::contentHolder).content;
  287.                }
  288.                catch(error:Error)
  289.                {
  290.                   return mx_internal::contentHolder.width;
  291.                }
  292.             }
  293.             return loaderInfo.width;
  294.          }
  295.          if(this.mx_internal::contentHolder is IUIComponent)
  296.          {
  297.             return IUIComponent(this.mx_internal::contentHolder).getExplicitOrMeasuredWidth();
  298.          }
  299.          if(this.mx_internal::contentHolder is IFlexDisplayObject)
  300.          {
  301.             return IFlexDisplayObject(this.mx_internal::contentHolder).measuredWidth;
  302.          }
  303.          return this.mx_internal::contentHolder.width;
  304.       }
  305.       
  306.       public function get contentWidth() : Number
  307.       {
  308.          return !!this.mx_internal::contentHolder ? this.mx_internal::contentHolder.width : NaN;
  309.       }
  310.       
  311.       [Bindable("loaderContextChanged")]
  312.       public function get loaderContext() : LoaderContext
  313.       {
  314.          return this._loaderContext;
  315.       }
  316.       
  317.       public function set loaderContext(param1:LoaderContext) : void
  318.       {
  319.          this._loaderContext = param1;
  320.          this.explicitLoaderContext = true;
  321.          dispatchEvent(new Event("loaderContextChanged"));
  322.       }
  323.       
  324.       [Bindable("maintainAspectRatioChanged")]
  325.       public function get maintainAspectRatio() : Boolean
  326.       {
  327.          return this._maintainAspectRatio;
  328.       }
  329.       
  330.       public function set maintainAspectRatio(param1:Boolean) : void
  331.       {
  332.          this._maintainAspectRatio = param1;
  333.          dispatchEvent(new Event("maintainAspectRatioChanged"));
  334.       }
  335.       
  336.       [Bindable("progress")]
  337.       public function get percentLoaded() : Number
  338.       {
  339.          var _loc1_:Number = isNaN(this._bytesTotal) || this._bytesTotal == 0 ? 0 : 100 * (this._bytesLoaded / this._bytesTotal);
  340.          if(isNaN(_loc1_))
  341.          {
  342.             _loc1_ = 0;
  343.          }
  344.          return _loc1_;
  345.       }
  346.       
  347.       [Bindable("scaleContentChanged")]
  348.       public function get scaleContent() : Boolean
  349.       {
  350.          return this._scaleContent;
  351.       }
  352.       
  353.       public function set scaleContent(param1:Boolean) : void
  354.       {
  355.          if(this._scaleContent != param1)
  356.          {
  357.             this._scaleContent = param1;
  358.             this.scaleContentChanged = true;
  359.             invalidateDisplayList();
  360.          }
  361.          dispatchEvent(new Event("scaleContentChanged"));
  362.       }
  363.       
  364.       public function get showBusyCursor() : Boolean
  365.       {
  366.          return this._showBusyCursor;
  367.       }
  368.       
  369.       public function set showBusyCursor(param1:Boolean) : void
  370.       {
  371.          if(this._showBusyCursor != param1)
  372.          {
  373.             this._showBusyCursor = param1;
  374.             if(this._showBusyCursor)
  375.             {
  376.                CursorManager.mx_internal::registerToUseBusyCursor(this);
  377.             }
  378.             else
  379.             {
  380.                CursorManager.mx_internal::unRegisterToUseBusyCursor(this);
  381.             }
  382.          }
  383.       }
  384.       
  385.       [Bindable("smoothBitmapContentChanged")]
  386.       public function get smoothBitmapContent() : Boolean
  387.       {
  388.          return this._smoothBitmapContent;
  389.       }
  390.       
  391.       public function set smoothBitmapContent(param1:Boolean) : void
  392.       {
  393.          if(this._smoothBitmapContent != param1)
  394.          {
  395.             this._smoothBitmapContent = param1;
  396.             this.smoothBitmapContentChanged = true;
  397.             invalidateDisplayList();
  398.          }
  399.          dispatchEvent(new Event("smoothBitmapContentChanged"));
  400.       }
  401.       
  402.       [Bindable("sourceChanged")]
  403.       public function get source() : Object
  404.       {
  405.          return this._source;
  406.       }
  407.       
  408.       public function set source(param1:Object) : void
  409.       {
  410.          if(this._source != param1)
  411.          {
  412.             this._source = param1;
  413.             this.contentChanged = true;
  414.             invalidateProperties();
  415.             invalidateSize();
  416.             invalidateDisplayList();
  417.             dispatchEvent(new Event("sourceChanged"));
  418.          }
  419.       }
  420.       
  421.       [Bindable("trustContentChanged")]
  422.       public function get trustContent() : Boolean
  423.       {
  424.          return this._trustContent;
  425.       }
  426.       
  427.       public function set trustContent(param1:Boolean) : void
  428.       {
  429.          if(this._trustContent != param1)
  430.          {
  431.             this._trustContent = param1;
  432.             invalidateProperties();
  433.             invalidateSize();
  434.             invalidateDisplayList();
  435.             dispatchEvent(new Event("trustContentChanged"));
  436.          }
  437.       }
  438.       
  439.       public function get swfBridge() : IEventDispatcher
  440.       {
  441.          return this._swfBridge;
  442.       }
  443.       
  444.       public function get childAllowsParent() : Boolean
  445.       {
  446.          if(!this.isContentLoaded)
  447.          {
  448.             return false;
  449.          }
  450.          try
  451.          {
  452.             if(this.mx_internal::contentHolder is Loader)
  453.             {
  454.                return Loader(this.mx_internal::contentHolder).contentLoaderInfo.childAllowsParent;
  455.             }
  456.          }
  457.          catch(error:Error)
  458.          {
  459.             return false;
  460.          }
  461.          return true;
  462.       }
  463.       
  464.       public function get parentAllowsChild() : Boolean
  465.       {
  466.          if(!this.isContentLoaded)
  467.          {
  468.             return false;
  469.          }
  470.          try
  471.          {
  472.             if(this.mx_internal::contentHolder is Loader)
  473.             {
  474.                return Loader(this.mx_internal::contentHolder).contentLoaderInfo.parentAllowsChild;
  475.             }
  476.          }
  477.          catch(error:Error)
  478.          {
  479.             return false;
  480.          }
  481.          return true;
  482.       }
  483.       
  484.       override protected function commitProperties() : void
  485.       {
  486.          super.commitProperties();
  487.          if(this.contentChanged)
  488.          {
  489.             this.contentChanged = false;
  490.             if(this._autoLoad)
  491.             {
  492.                this.load(this._source);
  493.             }
  494.          }
  495.       }
  496.       
  497.       override protected function measure() : void
  498.       {
  499.          var _loc1_:Number = NaN;
  500.          var _loc2_:Number = NaN;
  501.          super.measure();
  502.          if(this.isContentLoaded)
  503.          {
  504.             _loc1_ = this.mx_internal::contentHolder.scaleX;
  505.             _loc2_ = this.mx_internal::contentHolder.scaleY;
  506.             this.mx_internal::contentHolder.scaleX = 1;
  507.             this.mx_internal::contentHolder.scaleY = 1;
  508.             measuredWidth = this.contentHolderWidth;
  509.             measuredHeight = this.contentHolderHeight;
  510.             this.mx_internal::contentHolder.scaleX = _loc1_;
  511.             this.mx_internal::contentHolder.scaleY = _loc2_;
  512.          }
  513.          else if(!this._source || this._source == "")
  514.          {
  515.             measuredWidth = 0;
  516.             measuredHeight = 0;
  517.          }
  518.       }
  519.       
  520.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  521.       {
  522.          var _loc3_:Class = null;
  523.          super.updateDisplayList(param1,param2);
  524.          if(this.contentChanged)
  525.          {
  526.             this.contentChanged = false;
  527.             if(this._autoLoad)
  528.             {
  529.                this.load(this._source);
  530.             }
  531.          }
  532.          if(this.isContentLoaded)
  533.          {
  534.             if(this._scaleContent && !this.brokenImage)
  535.             {
  536.                this.doScaleContent();
  537.             }
  538.             else
  539.             {
  540.                this.doScaleLoader();
  541.             }
  542.             this.scaleContentChanged = false;
  543.             if(this.smoothBitmapContentChanged)
  544.             {
  545.                this.doSmoothBitmapContent();
  546.                this.smoothBitmapContentChanged = false;
  547.             }
  548.          }
  549.          if(this.brokenImage && !this.brokenImageBorder)
  550.          {
  551.             _loc3_ = getStyle("brokenImageBorderSkin");
  552.             if(_loc3_)
  553.             {
  554.                this.brokenImageBorder = IFlexDisplayObject(new _loc3_());
  555.                if(this.brokenImageBorder is ISimpleStyleClient)
  556.                {
  557.                   ISimpleStyleClient(this.brokenImageBorder).styleName = this;
  558.                }
  559.                addChild(DisplayObject(this.brokenImageBorder));
  560.             }
  561.          }
  562.          else if(!this.brokenImage && Boolean(this.brokenImageBorder))
  563.          {
  564.             removeChild(DisplayObject(this.brokenImageBorder));
  565.             this.brokenImageBorder = null;
  566.          }
  567.          if(this.brokenImageBorder)
  568.          {
  569.             this.brokenImageBorder.setActualSize(param1,param2);
  570.          }
  571.          this.sizeShield();
  572.       }
  573.       
  574.       public function load(param1:Object = null) : void
  575.       {
  576.          if(param1)
  577.          {
  578.             this._source = param1;
  579.          }
  580.          this.unloadContent();
  581.          this.isContentLoaded = false;
  582.          this.brokenImage = false;
  583.          this.useUnloadAndStop = false;
  584.          this.contentChanged = false;
  585.          if(!this._source || this._source == "")
  586.          {
  587.             return;
  588.          }
  589.          this.loadContent(this._source);
  590.       }
  591.       
  592.       public function unloadAndStop(param1:Boolean = true) : void
  593.       {
  594.          this.useUnloadAndStop = true;
  595.          this.unloadAndStopGC = param1;
  596.          this.source = null;
  597.          if(!this.autoLoad)
  598.          {
  599.             this.load(null);
  600.          }
  601.       }
  602.       
  603.       public function getVisibleApplicationRect(param1:Boolean = false) : Rectangle
  604.       {
  605.          var _loc2_:Rectangle = getVisibleRect();
  606.          if(param1)
  607.          {
  608.             _loc2_ = systemManager.getVisibleApplicationRect(_loc2_);
  609.          }
  610.          return _loc2_;
  611.       }
  612.       
  613.       private function unloadContent() : void
  614.       {
  615.          var imageData:Bitmap = null;
  616.          var contentLoader:Loader = null;
  617.          var request:SWFBridgeEvent = null;
  618.          if(this.mx_internal::contentHolder)
  619.          {
  620.             if(this.isContentLoaded)
  621.             {
  622.                if(this.mx_internal::contentHolder is Loader)
  623.                {
  624.                   contentLoader = Loader(this.mx_internal::contentHolder);
  625.                   try
  626.                   {
  627.                      if(contentLoader.content is Bitmap)
  628.                      {
  629.                         imageData = Bitmap(contentLoader.content);
  630.                         if(imageData.bitmapData)
  631.                         {
  632.                            imageData.bitmapData = null;
  633.                         }
  634.                      }
  635.                   }
  636.                   catch(error:Error)
  637.                   {
  638.                   }
  639.                   if(this._swfBridge)
  640.                   {
  641.                      request = new SWFBridgeEvent(SWFBridgeEvent.BRIDGE_APPLICATION_UNLOADING,false,false,this._swfBridge);
  642.                      this._swfBridge.dispatchEvent(request);
  643.                   }
  644.                   if(contentLoader.contentLoaderInfo.contentType == "application/x-shockwave-flash" && contentLoader.contentLoaderInfo.parentAllowsChild && contentLoader.contentLoaderInfo.childAllowsParent && Boolean(contentLoader.content))
  645.                   {
  646.                      contentLoader.content.removeEventListener(Request.GET_PARENT_FLEX_MODULE_FACTORY_REQUEST,this.contentHolder_getFlexModuleFactoryRequestHandler);
  647.                   }
  648.                   this.mx_internal::contentHolder.removeEventListener(Event.ADDED,this.contentHolder_addedHandler);
  649.                   this.removeInitSystemManagerCompleteListener(contentLoader.contentLoaderInfo);
  650.                   if(this.useUnloadAndStop)
  651.                   {
  652.                      contentLoader.unloadAndStop(this.unloadAndStopGC);
  653.                   }
  654.                   else
  655.                   {
  656.                      contentLoader.unload();
  657.                   }
  658.                   if(!this.explicitLoaderContext)
  659.                   {
  660.                      this._loaderContext = null;
  661.                   }
  662.                }
  663.                else if(this.mx_internal::contentHolder is Bitmap)
  664.                {
  665.                   imageData = Bitmap(this.mx_internal::contentHolder);
  666.                   if(imageData.bitmapData)
  667.                   {
  668.                      imageData.bitmapData = null;
  669.                   }
  670.                }
  671.             }
  672.             else if(this.mx_internal::contentHolder is Loader)
  673.             {
  674.                try
  675.                {
  676.                   Loader(this.mx_internal::contentHolder).close();
  677.                }
  678.                catch(error:Error)
  679.                {
  680.                }
  681.             }
  682.             try
  683.             {
  684.                if(this.mx_internal::contentHolder.parent == this)
  685.                {
  686.                   removeChild(this.mx_internal::contentHolder);
  687.                }
  688.             }
  689.             catch(error:Error)
  690.             {
  691.                try
  692.                {
  693.                   removeChild(mx_internal::contentHolder);
  694.                }
  695.                catch(error1:Error)
  696.                {
  697.                }
  698.             }
  699.             this.mx_internal::contentHolder = null;
  700.          }
  701.       }
  702.       
  703.       private function loadContent(param1:Object) : void
  704.       {
  705.          var _loc2_:DisplayObject = null;
  706.          var _loc3_:Class = null;
  707.          var _loc4_:String = null;
  708.          var _loc5_:ByteArray = null;
  709.          var _loc6_:Loader = null;
  710.          var _loc7_:LoaderContext = null;
  711.          var _loc8_:String = null;
  712.          var _loc9_:ApplicationDomain = null;
  713.          var _loc10_:ApplicationDomain = null;
  714.          var _loc11_:ApplicationDomain = null;
  715.          var _loc12_:String = null;
  716.          if(param1 is Class)
  717.          {
  718.             _loc3_ = Class(param1);
  719.          }
  720.          else if(param1 is String)
  721.          {
  722.             try
  723.             {
  724.                _loc3_ = Class(systemManager.getDefinitionByName(String(param1)));
  725.             }
  726.             catch(e:Error)
  727.             {
  728.             }
  729.             _loc4_ = String(param1);
  730.          }
  731.          else if(param1 is ByteArray)
  732.          {
  733.             _loc5_ = ByteArray(param1);
  734.          }
  735.          else
  736.          {
  737.             _loc4_ = param1.toString();
  738.          }
  739.          if(_loc3_)
  740.          {
  741.             this.mx_internal::contentHolder = _loc2_ = new _loc3_();
  742.             this.mx_internal::contentHolder.addEventListener(Event.ADDED,this.contentHolder_addedHandler,false,0,true);
  743.             addChild(_loc2_);
  744.             this.contentLoaded();
  745.          }
  746.          else if(param1 is DisplayObject)
  747.          {
  748.             addChild(this.mx_internal::contentHolder = DisplayObject(param1));
  749.             this.contentLoaded();
  750.             this.mx_internal::contentHolder.addEventListener(Request.GET_PARENT_FLEX_MODULE_FACTORY_REQUEST,this.contentHolder_getFlexModuleFactoryRequestHandler);
  751.          }
  752.          else if(_loc5_)
  753.          {
  754.             _loc6_ = new FlexLoader();
  755.             addChild(this.mx_internal::contentHolder = _loc6_);
  756.             _loc6_.contentLoaderInfo.addEventListener(Event.COMPLETE,this.mx_internal::contentLoaderInfo_completeEventHandler);
  757.             _loc6_.contentLoaderInfo.addEventListener(Event.INIT,this.contentLoaderInfo_initEventHandler);
  758.             _loc6_.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.contentLoaderInfo_ioErrorEventHandler);
  759.             _loc6_.contentLoaderInfo.addEventListener(Event.UNLOAD,this.contentLoaderInfo_unloadEventHandler);
  760.             _loc6_.loadBytes(_loc5_,this.loaderContext);
  761.          }
  762.          else
  763.          {
  764.             if(!_loc4_)
  765.             {
  766.                _loc12_ = resourceManager.getString("controls","notLoadable",[this.source]);
  767.                throw new Error(_loc12_);
  768.             }
  769.             _loc6_ = new FlexLoader();
  770.             this.mx_internal::contentHolder = _loc2_ = _loc6_;
  771.             addChild(_loc6_);
  772.             _loc6_.contentLoaderInfo.addEventListener(Event.COMPLETE,this.mx_internal::contentLoaderInfo_completeEventHandler);
  773.             _loc6_.contentLoaderInfo.addEventListener(HTTPStatusEvent.HTTP_STATUS,this.contentLoaderInfo_httpStatusEventHandler);
  774.             _loc6_.contentLoaderInfo.addEventListener(Event.INIT,this.contentLoaderInfo_initEventHandler);
  775.             _loc6_.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.contentLoaderInfo_ioErrorEventHandler);
  776.             _loc6_.contentLoaderInfo.addEventListener(Event.OPEN,this.contentLoaderInfo_openEventHandler);
  777.             _loc6_.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,this.contentLoaderInfo_progressEventHandler);
  778.             _loc6_.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.contentLoaderInfo_securityErrorEventHandler);
  779.             _loc6_.contentLoaderInfo.addEventListener(Event.UNLOAD,this.contentLoaderInfo_unloadEventHandler);
  780.             if(Capabilities.isDebugger == true && _loc4_.indexOf(".jpg") == -1 && LoaderUtil.normalizeURL(FlexGlobals.topLevelApplication.systemManager.loaderInfo).indexOf("debug=true") > -1)
  781.             {
  782.                _loc4_ += _loc4_.indexOf("?") > -1 ? "&debug=true" : "?debug=true";
  783.             }
  784.             if(!(_loc4_.indexOf(":") > -1 || _loc4_.indexOf("/") == 0 || _loc4_.indexOf("\\") == 0))
  785.             {
  786.                if(SystemManagerGlobals.bootstrapLoaderInfoURL != null && SystemManagerGlobals.bootstrapLoaderInfoURL != "")
  787.                {
  788.                   _loc8_ = SystemManagerGlobals.bootstrapLoaderInfoURL;
  789.                }
  790.                else if(root)
  791.                {
  792.                   _loc8_ = LoaderUtil.normalizeURL(root.loaderInfo);
  793.                }
  794.                else if(systemManager)
  795.                {
  796.                   _loc8_ = LoaderUtil.normalizeURL(DisplayObject(systemManager).loaderInfo);
  797.                }
  798.                _loc4_ = LoaderUtil.mx_internal::OSToPlayerURI(_loc4_,LoaderUtil.mx_internal::isLocal(!!_loc8_ ? _loc8_ : _loc4_));
  799.                if(_loc8_)
  800.                {
  801.                   _loc4_ = LoaderUtil.createAbsoluteURL(_loc8_,_loc4_);
  802.                }
  803.             }
  804.             else
  805.             {
  806.                _loc4_ = LoaderUtil.mx_internal::OSToPlayerURI(_loc4_,LoaderUtil.mx_internal::isLocal(_loc4_));
  807.             }
  808.             this.requestedURL = new URLRequest(_loc4_);
  809.             _loc7_ = this.loaderContext;
  810.             if(!_loc7_)
  811.             {
  812.                _loc7_ = new LoaderContext();
  813.                this._loaderContext = _loc7_;
  814.                if(Boolean(moduleFactory) && FlexVersion.compatibilityVersion >= FlexVersion.VERSION_4_0)
  815.                {
  816.                   _loc9_ = moduleFactory.info()["currentDomain"];
  817.                }
  818.                else
  819.                {
  820.                   _loc9_ = ApplicationDomain.currentDomain;
  821.                }
  822.                if(this.loadForCompatibility)
  823.                {
  824.                   _loc10_ = _loc9_.parentDomain;
  825.                   _loc11_ = null;
  826.                   while(_loc10_)
  827.                   {
  828.                      _loc11_ = _loc10_;
  829.                      _loc10_ = _loc10_.parentDomain;
  830.                   }
  831.                   _loc7_.applicationDomain = new ApplicationDomain(_loc11_);
  832.                }
  833.                if(this.trustContent)
  834.                {
  835.                   _loc7_.securityDomain = SecurityDomain.currentDomain;
  836.                }
  837.                else if(!this.loadForCompatibility)
  838.                {
  839.                   this.attemptingChildAppDomain = true;
  840.                   _loc7_.applicationDomain = new ApplicationDomain(_loc9_);
  841.                }
  842.             }
  843.             _loc6_.load(this.requestedURL,_loc7_);
  844.          }
  845.          if(Boolean(this.mx_internal::contentHolder) && this.mx_internal::contentHolder is ILayoutDirectionElement)
  846.          {
  847.             ILayoutDirectionElement(this.mx_internal::contentHolder).layoutDirection = null;
  848.          }
  849.          invalidateDisplayList();
  850.       }
  851.       
  852.       protected function contentLoaded() : void
  853.       {
  854.          var loaderInfo:LoaderInfo = null;
  855.          this.isContentLoaded = true;
  856.          if(this.mx_internal::contentHolder is Loader)
  857.          {
  858.             loaderInfo = Loader(this.mx_internal::contentHolder).contentLoaderInfo;
  859.          }
  860.          this.resizableContent = false;
  861.          if(loaderInfo)
  862.          {
  863.             if(loaderInfo.contentType == "application/x-shockwave-flash")
  864.             {
  865.                this.resizableContent = true;
  866.             }
  867.             if(this.resizableContent)
  868.             {
  869.                try
  870.                {
  871.                   if(Loader(this.mx_internal::contentHolder).content is IFlexDisplayObject)
  872.                   {
  873.                      this.flexContent = true;
  874.                   }
  875.                   else
  876.                   {
  877.                      this.flexContent = this.swfBridge != null;
  878.                   }
  879.                }
  880.                catch(e:Error)
  881.                {
  882.                   flexContent = swfBridge != null;
  883.                }
  884.             }
  885.          }
  886.          try
  887.          {
  888.             if(tabChildren && this.mx_internal::contentHolder is Loader && (loaderInfo.contentType == "application/x-shockwave-flash" || Loader(this.mx_internal::contentHolder).content is DisplayObjectContainer))
  889.             {
  890.                Loader(this.mx_internal::contentHolder).tabChildren = true;
  891.                DisplayObjectContainer(Loader(this.mx_internal::contentHolder).content).tabChildren = true;
  892.             }
  893.          }
  894.          catch(e:Error)
  895.          {
  896.          }
  897.          invalidateSize();
  898.          invalidateDisplayList();
  899.       }
  900.       
  901.       private function doScaleContent() : void
  902.       {
  903.          var interiorWidth:Number = NaN;
  904.          var interiorHeight:Number = NaN;
  905.          var contentWidth:Number = NaN;
  906.          var contentHeight:Number = NaN;
  907.          var x:Number = NaN;
  908.          var y:Number = NaN;
  909.          var newXScale:Number = NaN;
  910.          var newYScale:Number = NaN;
  911.          var scale:Number = NaN;
  912.          var w:Number = NaN;
  913.          var h:Number = NaN;
  914.          var holder:Loader = null;
  915.          var sizeSet:Boolean = false;
  916.          var lInfo:LoaderInfo = null;
  917.          if(!this.isContentLoaded)
  918.          {
  919.             return;
  920.          }
  921.          if(!this.resizableContent || this.maintainAspectRatio && !this.flexContent)
  922.          {
  923.             this.unScaleContent();
  924.             interiorWidth = unscaledWidth;
  925.             interiorHeight = unscaledHeight;
  926.             contentWidth = this.contentHolderWidth;
  927.             contentHeight = this.contentHolderHeight;
  928.             x = 0;
  929.             y = 0;
  930.             newXScale = contentWidth == 0 ? 1 : interiorWidth / contentWidth;
  931.             newYScale = contentHeight == 0 ? 1 : interiorHeight / contentHeight;
  932.             if(this._maintainAspectRatio)
  933.             {
  934.                if(newXScale > newYScale)
  935.                {
  936.                   x = Math.floor((interiorWidth - contentWidth * newYScale) * this.getHorizontalAlignValue());
  937.                   scale = newYScale;
  938.                }
  939.                else
  940.                {
  941.                   y = Math.floor((interiorHeight - contentHeight * newXScale) * this.getVerticalAlignValue());
  942.                   scale = newXScale;
  943.                }
  944.                this.mx_internal::contentHolder.scaleX = scale;
  945.                this.mx_internal::contentHolder.scaleY = scale;
  946.             }
  947.             else
  948.             {
  949.                this.mx_internal::contentHolder.scaleX = newXScale;
  950.                this.mx_internal::contentHolder.scaleY = newYScale;
  951.             }
  952.             this.mx_internal::contentHolder.x = x;
  953.             this.mx_internal::contentHolder.y = y;
  954.          }
  955.          else
  956.          {
  957.             this.mx_internal::contentHolder.x = 0;
  958.             this.mx_internal::contentHolder.y = 0;
  959.             w = unscaledWidth;
  960.             h = unscaledHeight;
  961.             if(this.mx_internal::contentHolder is Loader)
  962.             {
  963.                holder = Loader(this.mx_internal::contentHolder);
  964.                try
  965.                {
  966.                   if(this.getContentSize().x > 0)
  967.                   {
  968.                      sizeSet = false;
  969.                      if(holder.contentLoaderInfo.contentType == "application/x-shockwave-flash")
  970.                      {
  971.                         if(this.childAllowsParent)
  972.                         {
  973.                            if(holder.content is IFlexDisplayObject)
  974.                            {
  975.                               IFlexDisplayObject(holder.content).setActualSize(w,h);
  976.                               sizeSet = true;
  977.                            }
  978.                         }
  979.                         if(!sizeSet && Boolean(this.swfBridge))
  980.                         {
  981.                            this.swfBridge.dispatchEvent(new SWFBridgeRequest(SWFBridgeRequest.SET_ACTUAL_SIZE_REQUEST,false,false,null,{
  982.                               "width":w,
  983.                               "height":h
  984.                            }));
  985.                            sizeSet = true;
  986.                         }
  987.                      }
  988.                      if(!sizeSet)
  989.                      {
  990.                         lInfo = holder.contentLoaderInfo;
  991.                         if(lInfo)
  992.                         {
  993.                            this.mx_internal::contentHolder.scaleX = w / lInfo.width;
  994.                            this.mx_internal::contentHolder.scaleY = h / lInfo.height;
  995.                         }
  996.                         else
  997.                         {
  998.                            this.mx_internal::contentHolder.width = w;
  999.                            this.mx_internal::contentHolder.height = h;
  1000.                         }
  1001.                      }
  1002.                   }
  1003.                   else if(this.childAllowsParent && !(holder.content is IFlexDisplayObject))
  1004.                   {
  1005.                      this.mx_internal::contentHolder.width = w;
  1006.                      this.mx_internal::contentHolder.height = h;
  1007.                   }
  1008.                }
  1009.                catch(error:Error)
  1010.                {
  1011.                   mx_internal::contentHolder.width = w;
  1012.                   mx_internal::contentHolder.height = h;
  1013.                }
  1014.                if(!this.parentAllowsChild)
  1015.                {
  1016.                   this.mx_internal::contentHolder.scrollRect = new Rectangle(0,0,w / this.mx_internal::contentHolder.scaleX,h / this.mx_internal::contentHolder.scaleY);
  1017.                }
  1018.             }
  1019.             else
  1020.             {
  1021.                this.mx_internal::contentHolder.width = w;
  1022.                this.mx_internal::contentHolder.height = h;
  1023.             }
  1024.          }
  1025.       }
  1026.       
  1027.       private function doScaleLoader() : void
  1028.       {
  1029.          if(!this.isContentLoaded)
  1030.          {
  1031.             return;
  1032.          }
  1033.          this.unScaleContent();
  1034.          var _loc1_:Number = unscaledWidth;
  1035.          var _loc2_:Number = unscaledHeight;
  1036.          if(this.contentHolderWidth > _loc1_ || this.contentHolderHeight > _loc2_ || !this.parentAllowsChild)
  1037.          {
  1038.             this.mx_internal::contentHolder.scrollRect = new Rectangle(0,0,_loc1_,_loc2_);
  1039.          }
  1040.          else
  1041.          {
  1042.             this.mx_internal::contentHolder.scrollRect = null;
  1043.          }
  1044.          this.mx_internal::contentHolder.x = (_loc1_ - this.contentHolderWidth) * this.getHorizontalAlignValue();
  1045.          this.mx_internal::contentHolder.y = (_loc2_ - this.contentHolderHeight) * this.getVerticalAlignValue();
  1046.       }
  1047.       
  1048.       private function doSmoothBitmapContent() : void
  1049.       {
  1050.          if(this.content is Bitmap)
  1051.          {
  1052.             (this.content as Bitmap).smoothing = this._smoothBitmapContent;
  1053.          }
  1054.       }
  1055.       
  1056.       private function unScaleContent() : void
  1057.       {
  1058.          this.mx_internal::contentHolder.scaleX = 1;
  1059.          this.mx_internal::contentHolder.scaleY = 1;
  1060.          this.mx_internal::contentHolder.x = 0;
  1061.          this.mx_internal::contentHolder.y = 0;
  1062.       }
  1063.       
  1064.       private function getHorizontalAlignValue() : Number
  1065.       {
  1066.          var _loc1_:String = getStyle("horizontalAlign");
  1067.          if(_loc1_ == "left")
  1068.          {
  1069.             return 0;
  1070.          }
  1071.          if(_loc1_ == "right")
  1072.          {
  1073.             return 1;
  1074.          }
  1075.          return 0.5;
  1076.       }
  1077.       
  1078.       private function getVerticalAlignValue() : Number
  1079.       {
  1080.          var _loc1_:String = getStyle("verticalAlign");
  1081.          if(_loc1_ == "top")
  1082.          {
  1083.             return 0;
  1084.          }
  1085.          if(_loc1_ == "bottom")
  1086.          {
  1087.             return 1;
  1088.          }
  1089.          return 0.5;
  1090.       }
  1091.       
  1092.       private function dispatchInvalidateRequest(param1:Boolean, param2:Boolean, param3:Boolean) : void
  1093.       {
  1094.          var _loc4_:ISystemManager = systemManager;
  1095.          var _loc5_:IMarshalSystemManager = IMarshalSystemManager(systemManager.getImplementation("mx.managers::IMarshalSystemManager"));
  1096.          if(!_loc5_ || !_loc5_.useSWFBridge())
  1097.          {
  1098.             return;
  1099.          }
  1100.          var _loc6_:IEventDispatcher = _loc5_.swfBridgeGroup.parentBridge;
  1101.          var _loc7_:uint = 0;
  1102.          if(param1)
  1103.          {
  1104.             _loc7_ |= InvalidateRequestData.PROPERTIES;
  1105.          }
  1106.          if(param2)
  1107.          {
  1108.             _loc7_ |= InvalidateRequestData.SIZE;
  1109.          }
  1110.          if(param3)
  1111.          {
  1112.             _loc7_ |= InvalidateRequestData.DISPLAY_LIST;
  1113.          }
  1114.          var _loc8_:SWFBridgeRequest = new SWFBridgeRequest(SWFBridgeRequest.INVALIDATE_REQUEST,false,false,_loc6_,_loc7_);
  1115.          _loc6_.dispatchEvent(_loc8_);
  1116.       }
  1117.       
  1118.       private function initializeHandler(param1:FlexEvent) : void
  1119.       {
  1120.          if(this.contentChanged)
  1121.          {
  1122.             this.contentChanged = false;
  1123.             if(this._autoLoad)
  1124.             {
  1125.                this.load(this._source);
  1126.             }
  1127.          }
  1128.       }
  1129.       
  1130.       private function addedToStageHandler(param1:Event) : void
  1131.       {
  1132.          systemManager.getSandboxRoot().addEventListener(InterManagerRequest.DRAG_MANAGER_REQUEST,this.mouseShieldHandler,false,0,true);
  1133.       }
  1134.       
  1135.       mx_internal function contentLoaderInfo_completeEventHandler(param1:Event) : void
  1136.       {
  1137.          if(LoaderInfo(param1.target).loader != this.mx_internal::contentHolder)
  1138.          {
  1139.             return;
  1140.          }
  1141.          dispatchEvent(param1);
  1142.          this.contentLoaded();
  1143.       }
  1144.       
  1145.       private function contentLoaderInfo_httpStatusEventHandler(param1:HTTPStatusEvent) : void
  1146.       {
  1147.          dispatchEvent(param1);
  1148.       }
  1149.       
  1150.       private function contentLoaderInfo_initEventHandler(param1:Event) : void
  1151.       {
  1152.          dispatchEvent(param1);
  1153.          var _loc2_:LoaderInfo = LoaderInfo(param1.target);
  1154.          this.addInitSystemManagerCompleteListener(_loc2_.loader.contentLoaderInfo);
  1155.          if(_loc2_.contentType == "application/x-shockwave-flash" && _loc2_.parentAllowsChild && _loc2_.childAllowsParent && Boolean(_loc2_.content))
  1156.          {
  1157.             _loc2_.content.addEventListener(Request.GET_PARENT_FLEX_MODULE_FACTORY_REQUEST,this.contentHolder_getFlexModuleFactoryRequestHandler);
  1158.          }
  1159.       }
  1160.       
  1161.       private function addInitSystemManagerCompleteListener(param1:LoaderInfo) : void
  1162.       {
  1163.          var _loc2_:EventDispatcher = null;
  1164.          if(param1.contentType == "application/x-shockwave-flash")
  1165.          {
  1166.             _loc2_ = param1.sharedEvents;
  1167.             _loc2_.addEventListener(SWFBridgeEvent.BRIDGE_NEW_APPLICATION,this.initSystemManagerCompleteEventHandler);
  1168.          }
  1169.       }
  1170.       
  1171.       private function removeInitSystemManagerCompleteListener(param1:LoaderInfo) : void
  1172.       {
  1173.          var _loc2_:EventDispatcher = null;
  1174.          if(param1.contentType == "application/x-shockwave-flash")
  1175.          {
  1176.             _loc2_ = param1.sharedEvents;
  1177.             _loc2_.removeEventListener(SWFBridgeEvent.BRIDGE_NEW_APPLICATION,this.initSystemManagerCompleteEventHandler);
  1178.          }
  1179.       }
  1180.       
  1181.       private function contentLoaderInfo_ioErrorEventHandler(param1:IOErrorEvent) : void
  1182.       {
  1183.          this.source = getStyle("brokenImageSkin");
  1184.          this.load();
  1185.          this.contentChanged = false;
  1186.          this.brokenImage = true;
  1187.          if(hasEventListener(param1.type))
  1188.          {
  1189.             dispatchEvent(param1);
  1190.          }
  1191.          if(this.mx_internal::contentHolder is Loader)
  1192.          {
  1193.             this.removeInitSystemManagerCompleteListener(Loader(this.mx_internal::contentHolder).contentLoaderInfo);
  1194.          }
  1195.       }
  1196.       
  1197.       private function contentLoaderInfo_openEventHandler(param1:Event) : void
  1198.       {
  1199.          dispatchEvent(param1);
  1200.       }
  1201.       
  1202.       private function contentLoaderInfo_progressEventHandler(param1:ProgressEvent) : void
  1203.       {
  1204.          this._bytesTotal = param1.bytesTotal;
  1205.          this._bytesLoaded = param1.bytesLoaded;
  1206.          dispatchEvent(param1);
  1207.       }
  1208.       
  1209.       private function contentLoaderInfo_securityErrorEventHandler(param1:SecurityErrorEvent) : void
  1210.       {
  1211.          var _loc2_:LoaderContext = null;
  1212.          if(this.attemptingChildAppDomain)
  1213.          {
  1214.             this.attemptingChildAppDomain = false;
  1215.             _loc2_ = new LoaderContext();
  1216.             this._loaderContext = _loc2_;
  1217.             callLater(this.load);
  1218.             return;
  1219.          }
  1220.          dispatchEvent(param1);
  1221.          if(this.mx_internal::contentHolder is Loader)
  1222.          {
  1223.             this.removeInitSystemManagerCompleteListener(Loader(this.mx_internal::contentHolder).contentLoaderInfo);
  1224.          }
  1225.       }
  1226.       
  1227.       private function contentLoaderInfo_unloadEventHandler(param1:Event) : void
  1228.       {
  1229.          var _loc2_:ISystemManager = null;
  1230.          var _loc3_:IMarshalSystemManager = null;
  1231.          this.isContentLoaded = false;
  1232.          dispatchEvent(param1);
  1233.          if(this._swfBridge)
  1234.          {
  1235.             this._swfBridge.removeEventListener(SWFBridgeRequest.INVALIDATE_REQUEST,this.invalidateRequestHandler);
  1236.             _loc2_ = systemManager;
  1237.             _loc3_ = IMarshalSystemManager(systemManager.getImplementation("mx.managers::IMarshalSystemManager"));
  1238.             _loc3_.removeChildBridge(this._swfBridge);
  1239.             this._swfBridge = null;
  1240.          }
  1241.       }
  1242.       
  1243.       private function contentHolder_getFlexModuleFactoryRequestHandler(param1:Event) : void
  1244.       {
  1245.          if("value" in param1)
  1246.          {
  1247.             param1["value"] = moduleFactory;
  1248.          }
  1249.       }
  1250.       
  1251.       private function contentHolder_addedHandler(param1:Event) : void
  1252.       {
  1253.          if(param1.target == this.mx_internal::contentHolder)
  1254.          {
  1255.             return;
  1256.          }
  1257.          if(param1.target is IFlexModuleFactory)
  1258.          {
  1259.             param1.target.addEventListener(Request.GET_PARENT_FLEX_MODULE_FACTORY_REQUEST,this.contentHolder_getFlexModuleFactoryRequestHandler);
  1260.          }
  1261.          this.mx_internal::contentHolder.removeEventListener(Event.ADDED,this.contentHolder_addedHandler);
  1262.       }
  1263.       
  1264.       private function initSystemManagerCompleteEventHandler(param1:Event) : void
  1265.       {
  1266.          var _loc3_:ISystemManager = null;
  1267.          var _loc2_:Object = Object(param1);
  1268.          if(this.mx_internal::contentHolder is Loader && _loc2_.data == Loader(this.mx_internal::contentHolder).contentLoaderInfo.sharedEvents)
  1269.          {
  1270.             this._swfBridge = Loader(this.mx_internal::contentHolder).contentLoaderInfo.sharedEvents;
  1271.             this.flexContent = true;
  1272.             this.unScaleContent();
  1273.             _loc3_ = systemManager;
  1274.             IMarshalSystemManager(_loc3_.getImplementation("mx.managers::IMarshalSystemManager")).addChildBridge(this._swfBridge,this);
  1275.             this.removeInitSystemManagerCompleteListener(Loader(this.mx_internal::contentHolder).contentLoaderInfo);
  1276.             this._swfBridge.addEventListener(SWFBridgeRequest.INVALIDATE_REQUEST,this.invalidateRequestHandler);
  1277.          }
  1278.       }
  1279.       
  1280.       private function invalidateRequestHandler(param1:Event) : void
  1281.       {
  1282.          if(param1 is SWFBridgeRequest)
  1283.          {
  1284.             return;
  1285.          }
  1286.          var _loc2_:SWFBridgeRequest = SWFBridgeRequest.marshal(param1);
  1287.          var _loc3_:uint = uint(_loc2_.data);
  1288.          if(_loc3_ & InvalidateRequestData.PROPERTIES)
  1289.          {
  1290.             invalidateProperties();
  1291.          }
  1292.          if(_loc3_ & InvalidateRequestData.SIZE)
  1293.          {
  1294.             invalidateSize();
  1295.          }
  1296.          if(_loc3_ & InvalidateRequestData.DISPLAY_LIST)
  1297.          {
  1298.             invalidateDisplayList();
  1299.          }
  1300.          this.dispatchInvalidateRequest((_loc3_ & InvalidateRequestData.PROPERTIES) != 0,(_loc3_ & InvalidateRequestData.SIZE) != 0,(_loc3_ & InvalidateRequestData.DISPLAY_LIST) != 0);
  1301.       }
  1302.       
  1303.       private function mouseShieldHandler(param1:Event) : void
  1304.       {
  1305.          if(param1["name"] != "mouseShield")
  1306.          {
  1307.             return;
  1308.          }
  1309.          if(!this.isContentLoaded || this.parentAllowsChild)
  1310.          {
  1311.             return;
  1312.          }
  1313.          if(param1["value"])
  1314.          {
  1315.             if(!this.mouseShield)
  1316.             {
  1317.                this.mouseShield = new Sprite();
  1318.                this.mouseShield.graphics.beginFill(0,0);
  1319.                this.mouseShield.graphics.drawRect(0,0,100,100);
  1320.                this.mouseShield.graphics.endFill();
  1321.             }
  1322.             if(!this.mouseShield.parent)
  1323.             {
  1324.                addChild(this.mouseShield);
  1325.             }
  1326.             this.sizeShield();
  1327.          }
  1328.          else if(Boolean(this.mouseShield) && Boolean(this.mouseShield.parent))
  1329.          {
  1330.             removeChild(this.mouseShield);
  1331.          }
  1332.       }
  1333.       
  1334.       private function sizeShield() : void
  1335.       {
  1336.          if(Boolean(this.mouseShield) && Boolean(this.mouseShield.parent))
  1337.          {
  1338.             this.mouseShield.width = unscaledWidth;
  1339.             this.mouseShield.height = unscaledHeight;
  1340.          }
  1341.       }
  1342.       
  1343.       override public function regenerateStyleCache(param1:Boolean) : void
  1344.       {
  1345.          var _loc2_:ISystemManager = null;
  1346.          var _loc3_:Object = null;
  1347.          super.regenerateStyleCache(param1);
  1348.          try
  1349.          {
  1350.             _loc2_ = this.content as ISystemManager;
  1351.             if(_loc2_ != null)
  1352.             {
  1353.                _loc3_ = _loc2_.getImplementation("mx.managers::ISystemManagerChildManager");
  1354.                Object(_loc3_).regenerateStyleCache(param1);
  1355.             }
  1356.          }
  1357.          catch(error:Error)
  1358.          {
  1359.          }
  1360.       }
  1361.       
  1362.       override public function notifyStyleChangeInChildren(param1:String, param2:Boolean) : void
  1363.       {
  1364.          var _loc3_:ISystemManager = null;
  1365.          var _loc4_:Object = null;
  1366.          super.notifyStyleChangeInChildren(param1,param2);
  1367.          try
  1368.          {
  1369.             _loc3_ = this.content as ISystemManager;
  1370.             if(_loc3_ != null)
  1371.             {
  1372.                _loc4_ = _loc3_.getImplementation("mx.managers::ISystemManagerChildManager");
  1373.                Object(_loc4_).notifyStyleChangeInChildren(param1,param2);
  1374.             }
  1375.          }
  1376.          catch(error:Error)
  1377.          {
  1378.          }
  1379.       }
  1380.       
  1381.       private function getContentSize() : Point
  1382.       {
  1383.          var _loc3_:IEventDispatcher = null;
  1384.          var _loc4_:SWFBridgeRequest = null;
  1385.          var _loc1_:Point = new Point();
  1386.          if(!this.mx_internal::contentHolder is Loader)
  1387.          {
  1388.             return _loc1_;
  1389.          }
  1390.          var _loc2_:Loader = Loader(this.mx_internal::contentHolder);
  1391.          if(_loc2_.contentLoaderInfo.childAllowsParent)
  1392.          {
  1393.             _loc1_.x = _loc2_.content.width;
  1394.             _loc1_.y = _loc2_.content.height;
  1395.          }
  1396.          else
  1397.          {
  1398.             _loc3_ = this.swfBridge;
  1399.             if(_loc3_)
  1400.             {
  1401.                _loc4_ = new SWFBridgeRequest(SWFBridgeRequest.GET_SIZE_REQUEST);
  1402.                _loc3_.dispatchEvent(_loc4_);
  1403.                _loc1_.x = _loc4_.data.width;
  1404.                _loc1_.y = _loc4_.data.height;
  1405.             }
  1406.          }
  1407.          if(_loc1_.x == 0)
  1408.          {
  1409.             _loc1_.x = _loc2_.contentLoaderInfo.width;
  1410.          }
  1411.          if(_loc1_.y == 0)
  1412.          {
  1413.             _loc1_.y = _loc2_.contentLoaderInfo.height;
  1414.          }
  1415.          return _loc1_;
  1416.       }
  1417.       
  1418.       protected function clickHandler(param1:MouseEvent) : void
  1419.       {
  1420.          if(!enabled)
  1421.          {
  1422.             param1.stopImmediatePropagation();
  1423.             return;
  1424.          }
  1425.       }
  1426.    }
  1427. }
  1428.  
  1429.