home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / core / Application.as next >
Encoding:
Text File  |  2010-06-23  |  21.8 KB  |  696 lines
  1. package mx.core
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.InteractiveObject;
  5.    import flash.events.ContextMenuEvent;
  6.    import flash.events.Event;
  7.    import flash.external.ExternalInterface;
  8.    import flash.net.URLRequest;
  9.    import flash.net.navigateToURL;
  10.    import flash.system.Capabilities;
  11.    import flash.ui.ContextMenu;
  12.    import flash.ui.ContextMenuItem;
  13.    import flash.utils.setInterval;
  14.    import mx.containers.utilityClasses.ApplicationLayout;
  15.    import mx.effects.EffectManager;
  16.    import mx.events.FlexEvent;
  17.    import mx.managers.FocusManager;
  18.    import mx.managers.ILayoutManager;
  19.    import mx.managers.ISystemManager;
  20.    import mx.styles.CSSStyleDeclaration;
  21.    import mx.styles.IStyleClient;
  22.    import mx.styles.StyleManager;
  23.    
  24.    use namespace mx_internal;
  25.    
  26.    public class Application extends LayoutContainer
  27.    {
  28.       mx_internal static const VERSION:String = "3.5.0.12683";
  29.       
  30.       mx_internal static var useProgressiveLayout:Boolean = false;
  31.       
  32.       public var preloader:Object;
  33.       
  34.       public var pageTitle:String;
  35.       
  36.       private var resizeWidth:Boolean = true;
  37.       
  38.       private var _applicationViewMetrics:EdgeMetrics;
  39.       
  40.       mx_internal var _parameters:Object;
  41.       
  42.       private var processingCreationQueue:Boolean = false;
  43.       
  44.       private var resizeHandlerAdded:Boolean = false;
  45.       
  46.       public var scriptRecursionLimit:int;
  47.       
  48.       private var preloadObj:Object;
  49.       
  50.       public var usePreloader:Boolean;
  51.       
  52.       mx_internal var _url:String;
  53.       
  54.       private var _viewSourceURL:String;
  55.       
  56.       public var resetHistory:Boolean = true;
  57.       
  58.       public var historyManagementEnabled:Boolean = true;
  59.       
  60.       public var scriptTimeLimit:Number;
  61.       
  62.       public var frameRate:Number;
  63.       
  64.       private var creationQueue:Array = [];
  65.       
  66.       private var resizeHeight:Boolean = true;
  67.       
  68.       public var controlBar:IUIComponent;
  69.       
  70.       private var viewSourceCMI:ContextMenuItem;
  71.       
  72.       public function Application()
  73.       {
  74.          name = "application";
  75.          UIComponentGlobals.mx_internal::layoutManager = ILayoutManager(Singleton.getInstance("mx.managers::ILayoutManager"));
  76.          UIComponentGlobals.mx_internal::layoutManager.usePhasedInstantiation = true;
  77.          if(!ApplicationGlobals.application)
  78.          {
  79.             ApplicationGlobals.application = this;
  80.          }
  81.          super();
  82.          layoutObject = new ApplicationLayout();
  83.          layoutObject.target = this;
  84.          boxLayoutClass = ApplicationLayout;
  85.          showInAutomationHierarchy = true;
  86.       }
  87.       
  88.       public static function get application() : Object
  89.       {
  90.          return ApplicationGlobals.application;
  91.       }
  92.       
  93.       public function set viewSourceURL(param1:String) : void
  94.       {
  95.          _viewSourceURL = param1;
  96.       }
  97.       
  98.       override public function set enabled(param1:Boolean) : void
  99.       {
  100.          super.enabled = param1;
  101.          if(controlBar)
  102.          {
  103.             controlBar.enabled = param1;
  104.          }
  105.       }
  106.       
  107.       override public function prepareToPrint(param1:IFlexDisplayObject) : Object
  108.       {
  109.          var _loc2_:Object = {};
  110.          if(param1 == this)
  111.          {
  112.             _loc2_.width = width;
  113.             _loc2_.height = height;
  114.             _loc2_.verticalScrollPosition = verticalScrollPosition;
  115.             _loc2_.horizontalScrollPosition = horizontalScrollPosition;
  116.             _loc2_.horizontalScrollBarVisible = horizontalScrollBar != null;
  117.             _loc2_.verticalScrollBarVisible = verticalScrollBar != null;
  118.             _loc2_.whiteBoxVisible = whiteBox != null;
  119.             setActualSize(measuredWidth,measuredHeight);
  120.             horizontalScrollPosition = 0;
  121.             verticalScrollPosition = 0;
  122.             if(horizontalScrollBar)
  123.             {
  124.                horizontalScrollBar.visible = false;
  125.             }
  126.             if(verticalScrollBar)
  127.             {
  128.                verticalScrollBar.visible = false;
  129.             }
  130.             if(whiteBox)
  131.             {
  132.                whiteBox.visible = false;
  133.             }
  134.             updateDisplayList(unscaledWidth,unscaledHeight);
  135.          }
  136.          _loc2_.scrollRect = super.prepareToPrint(param1);
  137.          return _loc2_;
  138.       }
  139.       
  140.       override protected function measure() : void
  141.       {
  142.          var _loc2_:Number = NaN;
  143.          super.measure();
  144.          var _loc1_:EdgeMetrics = borderMetrics;
  145.          if(Boolean(controlBar) && Boolean(controlBar.includeInLayout))
  146.          {
  147.             _loc2_ = controlBar.getExplicitOrMeasuredWidth() + _loc1_.left + _loc1_.right;
  148.             measuredWidth = Math.max(measuredWidth,_loc2_);
  149.             measuredMinWidth = Math.max(measuredMinWidth,_loc2_);
  150.          }
  151.       }
  152.       
  153.       override public function getChildIndex(param1:DisplayObject) : int
  154.       {
  155.          if(Boolean(controlBar) && param1 == controlBar)
  156.          {
  157.             return -1;
  158.          }
  159.          return super.getChildIndex(param1);
  160.       }
  161.       
  162.       private function resizeHandler(param1:Event) : void
  163.       {
  164.          var _loc2_:Number = NaN;
  165.          var _loc3_:Number = NaN;
  166.          if(resizeWidth)
  167.          {
  168.             if(isNaN(percentWidth))
  169.             {
  170.                _loc2_ = DisplayObject(systemManager).width;
  171.             }
  172.             else
  173.             {
  174.                super.percentWidth = Math.max(percentWidth,0);
  175.                super.percentWidth = Math.min(percentWidth,100);
  176.                _loc2_ = percentWidth * screen.width / 100;
  177.             }
  178.             if(!isNaN(explicitMaxWidth))
  179.             {
  180.                _loc2_ = Math.min(_loc2_,explicitMaxWidth);
  181.             }
  182.             if(!isNaN(explicitMinWidth))
  183.             {
  184.                _loc2_ = Math.max(_loc2_,explicitMinWidth);
  185.             }
  186.          }
  187.          else
  188.          {
  189.             _loc2_ = width;
  190.          }
  191.          if(resizeHeight)
  192.          {
  193.             if(isNaN(percentHeight))
  194.             {
  195.                _loc3_ = DisplayObject(systemManager).height;
  196.             }
  197.             else
  198.             {
  199.                super.percentHeight = Math.max(percentHeight,0);
  200.                super.percentHeight = Math.min(percentHeight,100);
  201.                _loc3_ = percentHeight * screen.height / 100;
  202.             }
  203.             if(!isNaN(explicitMaxHeight))
  204.             {
  205.                _loc3_ = Math.min(_loc3_,explicitMaxHeight);
  206.             }
  207.             if(!isNaN(explicitMinHeight))
  208.             {
  209.                _loc3_ = Math.max(_loc3_,explicitMinHeight);
  210.             }
  211.          }
  212.          else
  213.          {
  214.             _loc3_ = height;
  215.          }
  216.          if(_loc2_ != width || _loc3_ != height)
  217.          {
  218.             invalidateProperties();
  219.             invalidateSize();
  220.          }
  221.          setActualSize(_loc2_,_loc3_);
  222.          invalidateDisplayList();
  223.       }
  224.       
  225.       private function initManagers(param1:ISystemManager) : void
  226.       {
  227.          if(param1.isTopLevel())
  228.          {
  229.             focusManager = new FocusManager(this);
  230.             param1.activate(this);
  231.          }
  232.       }
  233.       
  234.       override public function initialize() : void
  235.       {
  236.          var _loc2_:Object = null;
  237.          var _loc1_:ISystemManager = systemManager;
  238.          mx_internal::_url = _loc1_.loaderInfo.url;
  239.          mx_internal::_parameters = _loc1_.loaderInfo.parameters;
  240.          initManagers(_loc1_);
  241.          mx_internal::_descriptor = null;
  242.          if(mx_internal::documentDescriptor)
  243.          {
  244.             creationPolicy = mx_internal::documentDescriptor.properties.creationPolicy;
  245.             if(creationPolicy == null || creationPolicy.length == 0)
  246.             {
  247.                creationPolicy = ContainerCreationPolicy.AUTO;
  248.             }
  249.             _loc2_ = mx_internal::documentDescriptor.properties;
  250.             if(_loc2_.width != null)
  251.             {
  252.                width = _loc2_.width;
  253.                delete _loc2_.width;
  254.             }
  255.             if(_loc2_.height != null)
  256.             {
  257.                height = _loc2_.height;
  258.                delete _loc2_.height;
  259.             }
  260.             mx_internal::documentDescriptor.events = null;
  261.          }
  262.          initContextMenu();
  263.          super.initialize();
  264.          addEventListener(Event.ADDED,addedHandler);
  265.          if(Boolean(_loc1_.isTopLevelRoot()) && Capabilities.isDebugger == true)
  266.          {
  267.             setInterval(debugTickler,1500);
  268.          }
  269.       }
  270.       
  271.       override public function set percentHeight(param1:Number) : void
  272.       {
  273.          super.percentHeight = param1;
  274.          invalidateDisplayList();
  275.       }
  276.       
  277.       override public function set percentWidth(param1:Number) : void
  278.       {
  279.          super.percentWidth = param1;
  280.          invalidateDisplayList();
  281.       }
  282.       
  283.       override public function get id() : String
  284.       {
  285.          if(!super.id && this == Application.application && ExternalInterface.available)
  286.          {
  287.             return ExternalInterface.objectID;
  288.          }
  289.          return super.id;
  290.       }
  291.       
  292.       override mx_internal function setUnscaledWidth(param1:Number) : void
  293.       {
  294.          invalidateProperties();
  295.          super.mx_internal::setUnscaledWidth(param1);
  296.       }
  297.       
  298.       private function doNextQueueItem(param1:FlexEvent = null) : void
  299.       {
  300.          processingCreationQueue = true;
  301.          Application.mx_internal::useProgressiveLayout = true;
  302.          callLater(processNextQueueItem);
  303.       }
  304.       
  305.       private function addedHandler(param1:Event) : void
  306.       {
  307.          if(param1.target == this && creationQueue.length > 0)
  308.          {
  309.             doNextQueueItem();
  310.          }
  311.       }
  312.       
  313.       public function get viewSourceURL() : String
  314.       {
  315.          return _viewSourceURL;
  316.       }
  317.       
  318.       override mx_internal function get usePadding() : Boolean
  319.       {
  320.          return layout != ContainerLayout.ABSOLUTE;
  321.       }
  322.       
  323.       override mx_internal function setUnscaledHeight(param1:Number) : void
  324.       {
  325.          invalidateProperties();
  326.          super.mx_internal::setUnscaledHeight(param1);
  327.       }
  328.       
  329.       private function debugTickler() : void
  330.       {
  331.          var _loc1_:int = 0;
  332.       }
  333.       
  334.       override public function styleChanged(param1:String) : void
  335.       {
  336.          super.styleChanged(param1);
  337.          if(param1 == "backgroundColor" && getStyle("backgroundImage") == getStyle("defaultBackgroundImage"))
  338.          {
  339.             clearStyle("backgroundImage");
  340.          }
  341.       }
  342.       
  343.       override protected function layoutChrome(param1:Number, param2:Number) : void
  344.       {
  345.          super.layoutChrome(param1,param2);
  346.          if(!mx_internal::doingLayout)
  347.          {
  348.             createBorder();
  349.          }
  350.          var _loc3_:EdgeMetrics = borderMetrics;
  351.          var _loc4_:Number = getStyle("borderThickness");
  352.          var _loc5_:EdgeMetrics = new EdgeMetrics();
  353.          _loc5_.left = _loc3_.left - _loc4_;
  354.          _loc5_.top = _loc3_.top - _loc4_;
  355.          _loc5_.right = _loc3_.right - _loc4_;
  356.          _loc5_.bottom = _loc3_.bottom - _loc4_;
  357.          if(Boolean(controlBar) && Boolean(controlBar.includeInLayout))
  358.          {
  359.             if(controlBar is IInvalidating)
  360.             {
  361.                IInvalidating(controlBar).invalidateDisplayList();
  362.             }
  363.             controlBar.setActualSize(width - (_loc5_.left + _loc5_.right),controlBar.getExplicitOrMeasuredHeight());
  364.             controlBar.move(_loc5_.left,_loc5_.top);
  365.          }
  366.       }
  367.       
  368.       protected function menuItemSelectHandler(param1:Event) : void
  369.       {
  370.          navigateToURL(new URLRequest(_viewSourceURL),"_blank");
  371.       }
  372.       
  373.       private function printCreationQueue() : void
  374.       {
  375.          var _loc4_:Object = null;
  376.          var _loc1_:String = "";
  377.          var _loc2_:Number = creationQueue.length;
  378.          var _loc3_:int = 0;
  379.          while(_loc3_ < _loc2_)
  380.          {
  381.             _loc4_ = creationQueue[_loc3_];
  382.             _loc1_ += " [" + _loc3_ + "] " + _loc4_.id + " " + _loc4_.index;
  383.             _loc3_++;
  384.          }
  385.       }
  386.       
  387.       override protected function resourcesChanged() : void
  388.       {
  389.          super.resourcesChanged();
  390.          if(viewSourceCMI)
  391.          {
  392.             viewSourceCMI.caption = resourceManager.getString("core","viewSource");
  393.          }
  394.       }
  395.       
  396.       override protected function commitProperties() : void
  397.       {
  398.          super.commitProperties();
  399.          resizeWidth = isNaN(explicitWidth);
  400.          resizeHeight = isNaN(explicitHeight);
  401.          if(resizeWidth || resizeHeight)
  402.          {
  403.             resizeHandler(new Event(Event.RESIZE));
  404.             if(!resizeHandlerAdded)
  405.             {
  406.                systemManager.addEventListener(Event.RESIZE,resizeHandler,false,0,true);
  407.                resizeHandlerAdded = true;
  408.             }
  409.          }
  410.          else if(resizeHandlerAdded)
  411.          {
  412.             systemManager.removeEventListener(Event.RESIZE,resizeHandler);
  413.             resizeHandlerAdded = false;
  414.          }
  415.       }
  416.       
  417.       override public function set toolTip(param1:String) : void
  418.       {
  419.       }
  420.       
  421.       public function addToCreationQueue(param1:Object, param2:int = -1, param3:Function = null, param4:IFlexDisplayObject = null) : void
  422.       {
  423.          var _loc8_:int = 0;
  424.          var _loc9_:int = 0;
  425.          var _loc10_:int = 0;
  426.          var _loc12_:int = 0;
  427.          var _loc5_:int = int(creationQueue.length);
  428.          var _loc6_:Object = {};
  429.          var _loc7_:Boolean = false;
  430.          _loc6_.id = param1;
  431.          _loc6_.parent = param4;
  432.          _loc6_.callbackFunc = param3;
  433.          _loc6_.index = param2;
  434.          var _loc11_:int = 0;
  435.          while(_loc11_ < _loc5_)
  436.          {
  437.             _loc9_ = int(creationQueue[_loc11_].index);
  438.             _loc10_ = !!creationQueue[_loc11_].parent ? int(creationQueue[_loc11_].parent.nestLevel) : 0;
  439.             if(_loc6_.index != -1)
  440.             {
  441.                if(_loc9_ == -1 || _loc6_.index < _loc9_)
  442.                {
  443.                   _loc8_ = _loc11_;
  444.                   _loc7_ = true;
  445.                   break;
  446.                }
  447.             }
  448.             else
  449.             {
  450.                _loc12_ = !!_loc6_.parent ? int(_loc6_.parent.nestLevel) : 0;
  451.                if(_loc9_ == -1 && _loc10_ < _loc12_)
  452.                {
  453.                   _loc8_ = _loc11_;
  454.                   _loc7_ = true;
  455.                   break;
  456.                }
  457.             }
  458.             _loc11_++;
  459.          }
  460.          if(!_loc7_)
  461.          {
  462.             creationQueue.push(_loc6_);
  463.             _loc7_ = true;
  464.          }
  465.          else
  466.          {
  467.             creationQueue.splice(_loc8_,0,_loc6_);
  468.          }
  469.          if(initialized && !processingCreationQueue)
  470.          {
  471.             doNextQueueItem();
  472.          }
  473.       }
  474.       
  475.       override mx_internal function initThemeColor() : Boolean
  476.       {
  477.          var _loc2_:Object = null;
  478.          var _loc3_:Number = NaN;
  479.          var _loc4_:Number = NaN;
  480.          var _loc5_:CSSStyleDeclaration = null;
  481.          var _loc1_:Boolean = super.mx_internal::initThemeColor();
  482.          if(!_loc1_)
  483.          {
  484.             _loc5_ = StyleManager.getStyleDeclaration("global");
  485.             if(_loc5_)
  486.             {
  487.                _loc2_ = _loc5_.getStyle("themeColor");
  488.                _loc3_ = _loc5_.getStyle("rollOverColor");
  489.                _loc4_ = _loc5_.getStyle("selectionColor");
  490.             }
  491.             if(_loc2_ && isNaN(_loc3_) && isNaN(_loc4_))
  492.             {
  493.                mx_internal::setThemeColor(_loc2_);
  494.             }
  495.             _loc1_ = true;
  496.          }
  497.          return _loc1_;
  498.       }
  499.       
  500.       mx_internal function dockControlBar(param1:IUIComponent, param2:Boolean) : void
  501.       {
  502.          var controlBar:IUIComponent = param1;
  503.          var dock:Boolean = param2;
  504.          if(dock)
  505.          {
  506.             try
  507.             {
  508.                removeChild(DisplayObject(controlBar));
  509.             }
  510.             catch(e:Error)
  511.             {
  512.                return;
  513.             }
  514.             rawChildren.addChildAt(DisplayObject(controlBar),mx_internal::firstChildIndex);
  515.             setControlBar(controlBar);
  516.          }
  517.          else
  518.          {
  519.             try
  520.             {
  521.                rawChildren.removeChild(DisplayObject(controlBar));
  522.             }
  523.             catch(e:Error)
  524.             {
  525.                return;
  526.             }
  527.             setControlBar(null);
  528.             addChildAt(DisplayObject(controlBar),0);
  529.          }
  530.       }
  531.       
  532.       override public function get viewMetrics() : EdgeMetrics
  533.       {
  534.          if(!_applicationViewMetrics)
  535.          {
  536.             _applicationViewMetrics = new EdgeMetrics();
  537.          }
  538.          var _loc1_:EdgeMetrics = _applicationViewMetrics;
  539.          var _loc2_:EdgeMetrics = super.viewMetrics;
  540.          var _loc3_:Number = getStyle("borderThickness");
  541.          _loc1_.left = _loc2_.left;
  542.          _loc1_.top = _loc2_.top;
  543.          _loc1_.right = _loc2_.right;
  544.          _loc1_.bottom = _loc2_.bottom;
  545.          if(Boolean(controlBar) && Boolean(controlBar.includeInLayout))
  546.          {
  547.             _loc1_.top -= _loc3_;
  548.             _loc1_.top += Math.max(controlBar.getExplicitOrMeasuredHeight(),_loc3_);
  549.          }
  550.          return _loc1_;
  551.       }
  552.       
  553.       override public function finishPrint(param1:Object, param2:IFlexDisplayObject) : void
  554.       {
  555.          if(param2 == this)
  556.          {
  557.             setActualSize(param1.width,param1.height);
  558.             if(horizontalScrollBar)
  559.             {
  560.                horizontalScrollBar.visible = param1.horizontalScrollBarVisible;
  561.             }
  562.             if(verticalScrollBar)
  563.             {
  564.                verticalScrollBar.visible = param1.verticalScrollBarVisible;
  565.             }
  566.             if(whiteBox)
  567.             {
  568.                whiteBox.visible = param1.whiteBoxVisible;
  569.             }
  570.             horizontalScrollPosition = param1.horizontalScrollPosition;
  571.             verticalScrollPosition = param1.verticalScrollPosition;
  572.             updateDisplayList(unscaledWidth,unscaledHeight);
  573.          }
  574.          super.finishPrint(param1.scrollRect,param2);
  575.       }
  576.       
  577.       private function processNextQueueItem() : void
  578.       {
  579.          var queueItem:Object = null;
  580.          var nextChild:IUIComponent = null;
  581.          if(EffectManager.mx_internal::effectsPlaying.length > 0)
  582.          {
  583.             callLater(processNextQueueItem);
  584.          }
  585.          else if(creationQueue.length > 0)
  586.          {
  587.             queueItem = creationQueue.shift();
  588.             try
  589.             {
  590.                nextChild = queueItem.id is String ? document[queueItem.id] : queueItem.id;
  591.                if(nextChild is Container)
  592.                {
  593.                   Container(nextChild).createComponentsFromDescriptors(true);
  594.                }
  595.                if(nextChild is Container && Container(nextChild).creationPolicy == ContainerCreationPolicy.QUEUED)
  596.                {
  597.                   doNextQueueItem();
  598.                }
  599.                else
  600.                {
  601.                   nextChild.addEventListener("childrenCreationComplete",doNextQueueItem);
  602.                }
  603.             }
  604.             catch(e:Error)
  605.             {
  606.                processNextQueueItem();
  607.             }
  608.          }
  609.          else
  610.          {
  611.             processingCreationQueue = false;
  612.             Application.mx_internal::useProgressiveLayout = false;
  613.          }
  614.       }
  615.       
  616.       override public function set label(param1:String) : void
  617.       {
  618.       }
  619.       
  620.       public function get parameters() : Object
  621.       {
  622.          return mx_internal::_parameters;
  623.       }
  624.       
  625.       public function get url() : String
  626.       {
  627.          return mx_internal::_url;
  628.       }
  629.       
  630.       private function initContextMenu() : void
  631.       {
  632.          var _loc2_:String = null;
  633.          if(flexContextMenu != null)
  634.          {
  635.             if(systemManager is InteractiveObject)
  636.             {
  637.                InteractiveObject(systemManager).contextMenu = contextMenu;
  638.             }
  639.             return;
  640.          }
  641.          var _loc1_:ContextMenu = new ContextMenu();
  642.          _loc1_.hideBuiltInItems();
  643.          _loc1_.builtInItems.print = true;
  644.          if(_viewSourceURL)
  645.          {
  646.             _loc2_ = resourceManager.getString("core","viewSource");
  647.             viewSourceCMI = new ContextMenuItem(_loc2_,true);
  648.             viewSourceCMI.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT,menuItemSelectHandler);
  649.             _loc1_.customItems.push(viewSourceCMI);
  650.          }
  651.          contextMenu = _loc1_;
  652.          if(systemManager is InteractiveObject)
  653.          {
  654.             InteractiveObject(systemManager).contextMenu = _loc1_;
  655.          }
  656.       }
  657.       
  658.       override public function set icon(param1:Class) : void
  659.       {
  660.       }
  661.       
  662.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  663.       {
  664.          super.updateDisplayList(param1,param2);
  665.          createBorder();
  666.       }
  667.       
  668.       private function setControlBar(param1:IUIComponent) : void
  669.       {
  670.          if(param1 == controlBar)
  671.          {
  672.             return;
  673.          }
  674.          if(Boolean(controlBar) && controlBar is IStyleClient)
  675.          {
  676.             IStyleClient(controlBar).clearStyle("cornerRadius");
  677.             IStyleClient(controlBar).clearStyle("docked");
  678.          }
  679.          controlBar = param1;
  680.          if(Boolean(controlBar) && controlBar is IStyleClient)
  681.          {
  682.             IStyleClient(controlBar).setStyle("cornerRadius",0);
  683.             IStyleClient(controlBar).setStyle("docked",true);
  684.          }
  685.          invalidateSize();
  686.          invalidateDisplayList();
  687.          mx_internal::invalidateViewMetricsAndPadding();
  688.       }
  689.       
  690.       override public function set tabIndex(param1:int) : void
  691.       {
  692.       }
  693.    }
  694. }
  695.  
  696.