home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2012 April / ME_04_2012.iso / Video-Tutorial / iPhoto / media / player.swf / scripts / mx / managers / FocusManager.as < prev    next >
Encoding:
Text File  |  2011-11-11  |  51.1 KB  |  1,486 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.display.InteractiveObject;
  6.    import flash.display.Sprite;
  7.    import flash.display.Stage;
  8.    import flash.events.Event;
  9.    import flash.events.EventDispatcher;
  10.    import flash.events.FocusEvent;
  11.    import flash.events.KeyboardEvent;
  12.    import flash.events.MouseEvent;
  13.    import flash.system.Capabilities;
  14.    import flash.system.IME;
  15.    import flash.text.TextField;
  16.    import flash.ui.Keyboard;
  17.    import mx.core.FlexSprite;
  18.    import mx.core.IButton;
  19.    import mx.core.IChildList;
  20.    import mx.core.IIMESupport;
  21.    import mx.core.IRawChildrenContainer;
  22.    import mx.core.ISWFLoader;
  23.    import mx.core.IToggleButton;
  24.    import mx.core.IUIComponent;
  25.    import mx.core.IVisualElement;
  26.    import mx.core.mx_internal;
  27.    import mx.events.FlexEvent;
  28.    
  29.    use namespace mx_internal;
  30.    
  31.    public class FocusManager extends EventDispatcher implements IFocusManager
  32.    {
  33.       public static var mixins:Array;
  34.       
  35.       mx_internal static const VERSION:String = "4.5.0.20967";
  36.       
  37.       private static const FROM_INDEX_UNSPECIFIED:int = -2;
  38.       
  39.       private var LARGE_TAB_INDEX:int = 99999;
  40.       
  41.       mx_internal var calculateCandidates:Boolean = true;
  42.       
  43.       mx_internal var popup:Boolean;
  44.       
  45.       mx_internal var IMEEnabled:Boolean;
  46.       
  47.       mx_internal var lastAction:String;
  48.       
  49.       public var browserMode:Boolean;
  50.       
  51.       public var desktopMode:Boolean;
  52.       
  53.       private var browserFocusComponent:InteractiveObject;
  54.       
  55.       mx_internal var focusableObjects:Array;
  56.       
  57.       private var focusableCandidates:Array;
  58.       
  59.       private var activated:Boolean;
  60.       
  61.       private var windowActivated:Boolean;
  62.       
  63.       mx_internal var focusChanged:Boolean;
  64.       
  65.       mx_internal var fauxFocus:DisplayObject;
  66.       
  67.       mx_internal var _showFocusIndicator:Boolean = false;
  68.       
  69.       private var defButton:IButton;
  70.       
  71.       private var _defaultButton:IButton;
  72.       
  73.       private var _defaultButtonEnabled:Boolean = true;
  74.       
  75.       private var _focusPane:Sprite;
  76.       
  77.       private var _form:IFocusManagerContainer;
  78.       
  79.       private var _lastFocus:IFocusManagerComponent;
  80.       
  81.       public function FocusManager(param1:IFocusManagerContainer, param2:Boolean = false)
  82.       {
  83.          var _loc3_:int = 0;
  84.          var _loc4_:int = 0;
  85.          var _loc5_:IActiveWindowManager = null;
  86.          super();
  87.          this.mx_internal::popup = param2;
  88.          this.mx_internal::IMEEnabled = true;
  89.          this.browserMode = Capabilities.playerType == "ActiveX" && !param2;
  90.          this.desktopMode = Capabilities.playerType == "Desktop" && !param2;
  91.          this.windowActivated = !this.desktopMode;
  92.          param1.focusManager = this;
  93.          this._form = param1;
  94.          this.mx_internal::focusableObjects = [];
  95.          this.focusPane = new FlexSprite();
  96.          this.focusPane.name = "focusPane";
  97.          this.mx_internal::addFocusables(DisplayObject(param1));
  98.          param1.addEventListener(Event.ADDED,this.addedHandler);
  99.          param1.addEventListener(Event.REMOVED,this.removedHandler);
  100.          param1.addEventListener(FlexEvent.SHOW,this.showHandler);
  101.          param1.addEventListener(FlexEvent.HIDE,this.hideHandler);
  102.          param1.addEventListener(FlexEvent.HIDE,this.childHideHandler,true);
  103.          param1.addEventListener("_navigationChange_",this.viewHideHandler,true);
  104.          if(param1.systemManager is SystemManager)
  105.          {
  106.             if(param1 != SystemManager(param1.systemManager).application)
  107.             {
  108.                param1.addEventListener(FlexEvent.CREATION_COMPLETE,this.creationCompleteHandler);
  109.             }
  110.          }
  111.          if(mixins)
  112.          {
  113.             _loc3_ = int(mixins.length);
  114.             _loc4_ = 0;
  115.             while(_loc4_ < _loc3_)
  116.             {
  117.                new mixins[_loc4_](this);
  118.                _loc4_++;
  119.             }
  120.          }
  121.          try
  122.          {
  123.             _loc5_ = IActiveWindowManager(param1.systemManager.getImplementation("mx.managers::IActiveWindowManager"));
  124.             if(_loc5_)
  125.             {
  126.                _loc5_.addFocusManager(param1);
  127.             }
  128.             if(hasEventListener("initialize"))
  129.             {
  130.                dispatchEvent(new Event("initialize"));
  131.             }
  132.          }
  133.          catch(e:Error)
  134.          {
  135.          }
  136.       }
  137.       
  138.       public function get showFocusIndicator() : Boolean
  139.       {
  140.          return this.mx_internal::_showFocusIndicator;
  141.       }
  142.       
  143.       public function set showFocusIndicator(param1:Boolean) : void
  144.       {
  145.          var _loc2_:* = this.mx_internal::_showFocusIndicator != param1;
  146.          this.mx_internal::_showFocusIndicator = param1;
  147.          if(hasEventListener("showFocusIndicator"))
  148.          {
  149.             dispatchEvent(new Event("showFocusIndicator"));
  150.          }
  151.       }
  152.       
  153.       public function get defaultButton() : IButton
  154.       {
  155.          return this._defaultButton;
  156.       }
  157.       
  158.       public function set defaultButton(param1:IButton) : void
  159.       {
  160.          var _loc2_:IButton = !!param1 ? IButton(param1) : null;
  161.          if(_loc2_ != this._defaultButton)
  162.          {
  163.             if(this._defaultButton)
  164.             {
  165.                this._defaultButton.emphasized = false;
  166.             }
  167.             if(this.defButton)
  168.             {
  169.                this.defButton.emphasized = false;
  170.             }
  171.             this._defaultButton = _loc2_;
  172.             if(this.defButton != this._lastFocus || this._lastFocus == this._defaultButton)
  173.             {
  174.                this.defButton = _loc2_;
  175.                if(_loc2_)
  176.                {
  177.                   _loc2_.emphasized = true;
  178.                }
  179.             }
  180.          }
  181.       }
  182.       
  183.       public function get defaultButtonEnabled() : Boolean
  184.       {
  185.          return this._defaultButtonEnabled;
  186.       }
  187.       
  188.       public function set defaultButtonEnabled(param1:Boolean) : void
  189.       {
  190.          this._defaultButtonEnabled = param1;
  191.          if(this.defButton)
  192.          {
  193.             this.defButton.emphasized = param1;
  194.          }
  195.       }
  196.       
  197.       public function get focusPane() : Sprite
  198.       {
  199.          return this._focusPane;
  200.       }
  201.       
  202.       public function set focusPane(param1:Sprite) : void
  203.       {
  204.          this._focusPane = param1;
  205.       }
  206.       
  207.       mx_internal function get form() : IFocusManagerContainer
  208.       {
  209.          return this._form;
  210.       }
  211.       
  212.       mx_internal function set form(param1:IFocusManagerContainer) : void
  213.       {
  214.          this._form = param1;
  215.       }
  216.       
  217.       mx_internal function get lastFocus() : IFocusManagerComponent
  218.       {
  219.          return this._lastFocus;
  220.       }
  221.       
  222.       mx_internal function set lastFocus(param1:IFocusManagerComponent) : void
  223.       {
  224.          this._lastFocus = param1;
  225.       }
  226.       
  227.       public function get nextTabIndex() : int
  228.       {
  229.          return this.getMaxTabIndex() + 1;
  230.       }
  231.       
  232.       private function getMaxTabIndex() : int
  233.       {
  234.          var _loc4_:Number = NaN;
  235.          var _loc1_:Number = 0;
  236.          var _loc2_:int = int(this.mx_internal::focusableObjects.length);
  237.          var _loc3_:int = 0;
  238.          while(_loc3_ < _loc2_)
  239.          {
  240.             _loc4_ = Number(this.mx_internal::focusableObjects[_loc3_].tabIndex);
  241.             if(!isNaN(_loc4_))
  242.             {
  243.                _loc1_ = Math.max(_loc1_,_loc4_);
  244.             }
  245.             _loc3_++;
  246.          }
  247.          return _loc1_;
  248.       }
  249.       
  250.       public function getFocus() : IFocusManagerComponent
  251.       {
  252.          var _loc1_:Stage = this.mx_internal::form.systemManager.stage;
  253.          if(!_loc1_)
  254.          {
  255.             return null;
  256.          }
  257.          var _loc2_:InteractiveObject = _loc1_.focus;
  258.          return this.findFocusManagerComponent(_loc2_);
  259.       }
  260.       
  261.       public function setFocus(param1:IFocusManagerComponent) : void
  262.       {
  263.          param1.setFocus();
  264.          if(hasEventListener("setFocus"))
  265.          {
  266.             dispatchEvent(new Event("setFocus"));
  267.          }
  268.       }
  269.       
  270.       private function focusInHandler(param1:FocusEvent) : void
  271.       {
  272.          var _loc3_:Boolean = false;
  273.          var _loc4_:IIMESupport = null;
  274.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  275.          if(hasEventListener(FocusEvent.FOCUS_IN))
  276.          {
  277.             if(!dispatchEvent(new FocusEvent(FocusEvent.FOCUS_IN,false,true,_loc2_)))
  278.             {
  279.                return;
  280.             }
  281.          }
  282.          if(this.isParent(DisplayObjectContainer(this.mx_internal::form),_loc2_))
  283.          {
  284.             if(this._defaultButton)
  285.             {
  286.                if(_loc2_ is IButton && _loc2_ != this._defaultButton && !(_loc2_ is IToggleButton))
  287.                {
  288.                   this._defaultButton.emphasized = false;
  289.                }
  290.                else if(this._defaultButtonEnabled)
  291.                {
  292.                   this._defaultButton.emphasized = true;
  293.                }
  294.             }
  295.             this._lastFocus = this.findFocusManagerComponent(InteractiveObject(_loc2_));
  296.             if(Capabilities.hasIME)
  297.             {
  298.                if(this._lastFocus is IIMESupport)
  299.                {
  300.                   _loc4_ = IIMESupport(this._lastFocus);
  301.                   if(_loc4_.enableIME)
  302.                   {
  303.                      _loc3_ = true;
  304.                   }
  305.                }
  306.                if(this.mx_internal::IMEEnabled)
  307.                {
  308.                   IME.enabled = _loc3_;
  309.                }
  310.             }
  311.             if(this._lastFocus is IButton && !(this._lastFocus is IToggleButton))
  312.             {
  313.                this.defButton = this._lastFocus as IButton;
  314.             }
  315.             else if(Boolean(this.defButton) && this.defButton != this._defaultButton)
  316.             {
  317.                this.defButton = this._defaultButton;
  318.             }
  319.          }
  320.       }
  321.       
  322.       private function focusOutHandler(param1:FocusEvent) : void
  323.       {
  324.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  325.       }
  326.       
  327.       private function activateHandler(param1:Event) : void
  328.       {
  329.          if(this.activated && !this.desktopMode)
  330.          {
  331.             dispatchEvent(new FlexEvent(FlexEvent.FLEX_WINDOW_ACTIVATE));
  332.             if(Boolean(this._lastFocus) && !this.browserMode)
  333.             {
  334.                this._lastFocus.setFocus();
  335.             }
  336.             this.mx_internal::lastAction = "ACTIVATE";
  337.          }
  338.       }
  339.       
  340.       private function deactivateHandler(param1:Event) : void
  341.       {
  342.          if(this.activated && !this.desktopMode)
  343.          {
  344.             dispatchEvent(new FlexEvent(FlexEvent.FLEX_WINDOW_DEACTIVATE));
  345.          }
  346.       }
  347.       
  348.       private function activateWindowHandler(param1:Event) : void
  349.       {
  350.          this.windowActivated = true;
  351.          if(this.activated)
  352.          {
  353.             dispatchEvent(new FlexEvent(FlexEvent.FLEX_WINDOW_ACTIVATE));
  354.             if(Boolean(this._lastFocus) && !this.browserMode)
  355.             {
  356.                this._lastFocus.setFocus();
  357.             }
  358.             this.mx_internal::lastAction = "ACTIVATE";
  359.          }
  360.       }
  361.       
  362.       private function deactivateWindowHandler(param1:Event) : void
  363.       {
  364.          this.windowActivated = false;
  365.          if(this.activated)
  366.          {
  367.             dispatchEvent(new FlexEvent(FlexEvent.FLEX_WINDOW_DEACTIVATE));
  368.             if(this.mx_internal::form.systemManager.stage)
  369.             {
  370.                this.mx_internal::form.systemManager.stage.focus = null;
  371.             }
  372.          }
  373.       }
  374.       
  375.       public function showFocus() : void
  376.       {
  377.          if(!this.showFocusIndicator)
  378.          {
  379.             this.showFocusIndicator = true;
  380.             if(this._lastFocus)
  381.             {
  382.                this._lastFocus.drawFocus(true);
  383.             }
  384.          }
  385.       }
  386.       
  387.       public function hideFocus() : void
  388.       {
  389.          if(this.showFocusIndicator)
  390.          {
  391.             this.showFocusIndicator = false;
  392.             if(this._lastFocus)
  393.             {
  394.                this._lastFocus.drawFocus(false);
  395.             }
  396.          }
  397.       }
  398.       
  399.       public function activate() : void
  400.       {
  401.          if(this.activated)
  402.          {
  403.             return;
  404.          }
  405.          var _loc1_:ISystemManager = this.mx_internal::form.systemManager;
  406.          if(_loc1_)
  407.          {
  408.             if(_loc1_.isTopLevelRoot())
  409.             {
  410.                _loc1_.stage.addEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,this.mouseFocusChangeHandler,false,0,true);
  411.                _loc1_.stage.addEventListener(FocusEvent.KEY_FOCUS_CHANGE,this.mx_internal::keyFocusChangeHandler,false,0,true);
  412.                _loc1_.stage.addEventListener(Event.ACTIVATE,this.activateHandler,false,0,true);
  413.                _loc1_.stage.addEventListener(Event.DEACTIVATE,this.deactivateHandler,false,0,true);
  414.             }
  415.             else
  416.             {
  417.                _loc1_.addEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,this.mouseFocusChangeHandler,false,0,true);
  418.                _loc1_.addEventListener(FocusEvent.KEY_FOCUS_CHANGE,this.mx_internal::keyFocusChangeHandler,false,0,true);
  419.                _loc1_.addEventListener(Event.ACTIVATE,this.activateHandler,false,0,true);
  420.                _loc1_.addEventListener(Event.DEACTIVATE,this.deactivateHandler,false,0,true);
  421.             }
  422.          }
  423.          this.mx_internal::form.addEventListener(FocusEvent.FOCUS_IN,this.focusInHandler,true);
  424.          this.mx_internal::form.addEventListener(FocusEvent.FOCUS_OUT,this.focusOutHandler,true);
  425.          this.mx_internal::form.addEventListener(MouseEvent.MOUSE_DOWN,this.mouseDownHandler);
  426.          this.mx_internal::form.addEventListener(MouseEvent.MOUSE_DOWN,this.mouseDownCaptureHandler,true);
  427.          this.mx_internal::form.addEventListener(KeyboardEvent.KEY_DOWN,this.defaultButtonKeyHandler);
  428.          this.mx_internal::form.addEventListener(KeyboardEvent.KEY_DOWN,this.mx_internal::keyDownHandler,true);
  429.          if(_loc1_)
  430.          {
  431.             _loc1_.addEventListener("windowActivate",this.activateWindowHandler,true,0,true);
  432.             _loc1_.addEventListener("windowDeactivate",this.deactivateWindowHandler,true,0,true);
  433.          }
  434.          this.activated = true;
  435.          dispatchEvent(new FlexEvent(FlexEvent.FLEX_WINDOW_ACTIVATE));
  436.          if(this._lastFocus)
  437.          {
  438.             this.setFocus(this._lastFocus);
  439.          }
  440.          if(hasEventListener("activateFM"))
  441.          {
  442.             dispatchEvent(new Event("activateFM"));
  443.          }
  444.       }
  445.       
  446.       public function deactivate() : void
  447.       {
  448.          var _loc1_:ISystemManager = this.mx_internal::form.systemManager;
  449.          if(_loc1_)
  450.          {
  451.             if(_loc1_.isTopLevelRoot())
  452.             {
  453.                _loc1_.stage.removeEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,this.mouseFocusChangeHandler);
  454.                _loc1_.stage.removeEventListener(FocusEvent.KEY_FOCUS_CHANGE,this.mx_internal::keyFocusChangeHandler);
  455.                _loc1_.stage.removeEventListener(Event.ACTIVATE,this.activateHandler);
  456.                _loc1_.stage.removeEventListener(Event.DEACTIVATE,this.deactivateHandler);
  457.             }
  458.             else
  459.             {
  460.                _loc1_.removeEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,this.mouseFocusChangeHandler);
  461.                _loc1_.removeEventListener(FocusEvent.KEY_FOCUS_CHANGE,this.mx_internal::keyFocusChangeHandler);
  462.                _loc1_.removeEventListener(Event.ACTIVATE,this.activateHandler);
  463.                _loc1_.removeEventListener(Event.DEACTIVATE,this.deactivateHandler);
  464.             }
  465.          }
  466.          this.mx_internal::form.removeEventListener(FocusEvent.FOCUS_IN,this.focusInHandler,true);
  467.          this.mx_internal::form.removeEventListener(FocusEvent.FOCUS_OUT,this.focusOutHandler,true);
  468.          this.mx_internal::form.removeEventListener(MouseEvent.MOUSE_DOWN,this.mouseDownHandler);
  469.          this.mx_internal::form.removeEventListener(MouseEvent.MOUSE_DOWN,this.mouseDownCaptureHandler,true);
  470.          this.mx_internal::form.removeEventListener(KeyboardEvent.KEY_DOWN,this.defaultButtonKeyHandler);
  471.          this.mx_internal::form.removeEventListener(KeyboardEvent.KEY_DOWN,this.mx_internal::keyDownHandler,true);
  472.          this.activated = false;
  473.          dispatchEvent(new FlexEvent(FlexEvent.FLEX_WINDOW_DEACTIVATE));
  474.          if(hasEventListener("deactivateFM"))
  475.          {
  476.             dispatchEvent(new Event("deactivateFM"));
  477.          }
  478.       }
  479.       
  480.       public function findFocusManagerComponent(param1:InteractiveObject) : IFocusManagerComponent
  481.       {
  482.          return this.findFocusManagerComponent2(param1) as IFocusManagerComponent;
  483.       }
  484.       
  485.       private function findFocusManagerComponent2(param1:InteractiveObject) : DisplayObject
  486.       {
  487.          try
  488.          {
  489.             while(param1)
  490.             {
  491.                if(param1 is IFocusManagerComponent && IFocusManagerComponent(param1).focusEnabled || param1 is ISWFLoader)
  492.                {
  493.                   return param1;
  494.                }
  495.                param1 = param1.parent;
  496.             }
  497.          }
  498.          catch(error:SecurityError)
  499.          {
  500.          }
  501.          return null;
  502.       }
  503.       
  504.       private function isParent(param1:DisplayObjectContainer, param2:DisplayObject) : Boolean
  505.       {
  506.          if(param1 == param2)
  507.          {
  508.             return false;
  509.          }
  510.          if(param1 is IRawChildrenContainer)
  511.          {
  512.             return IRawChildrenContainer(param1).rawChildren.contains(param2);
  513.          }
  514.          return param1.contains(param2);
  515.       }
  516.       
  517.       private function isEnabledAndVisible(param1:DisplayObject) : Boolean
  518.       {
  519.          var _loc2_:DisplayObjectContainer = DisplayObjectContainer(this.mx_internal::form);
  520.          while(param1 != _loc2_)
  521.          {
  522.             if(param1 is IUIComponent)
  523.             {
  524.                if(!IUIComponent(param1).enabled)
  525.                {
  526.                   return false;
  527.                }
  528.             }
  529.             if(param1 is IVisualElement)
  530.             {
  531.                if(Boolean(IVisualElement(param1).designLayer) && !IVisualElement(param1).designLayer.effectiveVisibility)
  532.                {
  533.                   return false;
  534.                }
  535.             }
  536.             if(!param1.visible)
  537.             {
  538.                return false;
  539.             }
  540.             param1 = param1.parent;
  541.             if(!param1)
  542.             {
  543.                return false;
  544.             }
  545.          }
  546.          return true;
  547.       }
  548.       
  549.       private function sortByTabIndex(param1:InteractiveObject, param2:InteractiveObject) : int
  550.       {
  551.          var _loc3_:int = param1.tabIndex;
  552.          var _loc4_:int = param2.tabIndex;
  553.          if(_loc3_ == -1)
  554.          {
  555.             _loc3_ = int.MAX_VALUE;
  556.          }
  557.          if(_loc4_ == -1)
  558.          {
  559.             _loc4_ = int.MAX_VALUE;
  560.          }
  561.          return _loc3_ > _loc4_ ? 1 : (_loc3_ < _loc4_ ? -1 : int(this.sortByDepth(DisplayObject(param1),DisplayObject(param2))));
  562.       }
  563.       
  564.       private function sortFocusableObjectsTabIndex() : void
  565.       {
  566.          var _loc3_:IFocusManagerComponent = null;
  567.          this.focusableCandidates = [];
  568.          var _loc1_:int = int(this.mx_internal::focusableObjects.length);
  569.          var _loc2_:int = 0;
  570.          while(_loc2_ < _loc1_)
  571.          {
  572.             _loc3_ = this.mx_internal::focusableObjects[_loc2_] as IFocusManagerComponent;
  573.             if(_loc3_ && _loc3_.tabIndex && !isNaN(Number(_loc3_.tabIndex)) || this.mx_internal::focusableObjects[_loc2_] is ISWFLoader)
  574.             {
  575.                this.focusableCandidates.push(this.mx_internal::focusableObjects[_loc2_]);
  576.             }
  577.             _loc2_++;
  578.          }
  579.          this.focusableCandidates.sort(this.sortByTabIndex);
  580.       }
  581.       
  582.       private function sortByDepth(param1:DisplayObject, param2:DisplayObject) : Number
  583.       {
  584.          var _loc5_:int = 0;
  585.          var _loc6_:String = null;
  586.          var _loc7_:String = null;
  587.          var _loc3_:String = "";
  588.          var _loc4_:String = "";
  589.          var _loc8_:String = "0000";
  590.          var _loc9_:DisplayObject = DisplayObject(param1);
  591.          var _loc10_:DisplayObject = DisplayObject(param2);
  592.          while(_loc9_ != DisplayObject(this.mx_internal::form) && Boolean(_loc9_.parent))
  593.          {
  594.             _loc5_ = this.getChildIndex(_loc9_.parent,_loc9_);
  595.             _loc6_ = _loc5_.toString(16);
  596.             if(_loc6_.length < 4)
  597.             {
  598.                _loc7_ = _loc8_.substring(0,4 - _loc6_.length) + _loc6_;
  599.             }
  600.             _loc3_ = _loc7_ + _loc3_;
  601.             _loc9_ = _loc9_.parent;
  602.          }
  603.          while(_loc10_ != DisplayObject(this.mx_internal::form) && Boolean(_loc10_.parent))
  604.          {
  605.             _loc5_ = this.getChildIndex(_loc10_.parent,_loc10_);
  606.             _loc6_ = _loc5_.toString(16);
  607.             if(_loc6_.length < 4)
  608.             {
  609.                _loc7_ = _loc8_.substring(0,4 - _loc6_.length) + _loc6_;
  610.             }
  611.             _loc4_ = _loc7_ + _loc4_;
  612.             _loc10_ = _loc10_.parent;
  613.          }
  614.          return _loc3_ > _loc4_ ? 1 : (_loc3_ < _loc4_ ? -1 : 0);
  615.       }
  616.       
  617.       private function getChildIndex(param1:DisplayObjectContainer, param2:DisplayObject) : int
  618.       {
  619.          var parent:DisplayObjectContainer = param1;
  620.          var child:DisplayObject = param2;
  621.          try
  622.          {
  623.             return parent.getChildIndex(child);
  624.          }
  625.          catch(e:Error)
  626.          {
  627.             if(parent is IRawChildrenContainer)
  628.             {
  629.                return IRawChildrenContainer(parent).rawChildren.getChildIndex(child);
  630.             }
  631.             throw e;
  632.          }
  633.       }
  634.       
  635.       private function sortFocusableObjects() : void
  636.       {
  637.          var _loc3_:InteractiveObject = null;
  638.          this.focusableCandidates = [];
  639.          var _loc1_:int = int(this.mx_internal::focusableObjects.length);
  640.          var _loc2_:int = 0;
  641.          while(_loc2_ < _loc1_)
  642.          {
  643.             _loc3_ = this.mx_internal::focusableObjects[_loc2_];
  644.             if(_loc3_.tabIndex && !isNaN(Number(_loc3_.tabIndex)) && _loc3_.tabIndex > 0)
  645.             {
  646.                this.sortFocusableObjectsTabIndex();
  647.                return;
  648.             }
  649.             this.focusableCandidates.push(_loc3_);
  650.             _loc2_++;
  651.          }
  652.          this.focusableCandidates.sort(this.sortByDepth);
  653.       }
  654.       
  655.       mx_internal function sendDefaultButtonEvent() : void
  656.       {
  657.          this.defButton.dispatchEvent(new MouseEvent("click"));
  658.       }
  659.       
  660.       mx_internal function addFocusables(param1:DisplayObject, param2:Boolean = false) : void
  661.       {
  662.          var _loc3_:Boolean = false;
  663.          var _loc4_:IFocusManagerComponent = null;
  664.          var _loc5_:DisplayObjectContainer = null;
  665.          var _loc6_:Boolean = false;
  666.          var _loc7_:IChildList = null;
  667.          var _loc8_:int = 0;
  668.          if(param1 is IFocusManagerComponent && !param2)
  669.          {
  670.             _loc3_ = false;
  671.             if(param1 is IFocusManagerComponent)
  672.             {
  673.                _loc4_ = IFocusManagerComponent(param1);
  674.                if(_loc4_.focusEnabled)
  675.                {
  676.                   if(_loc4_.tabFocusEnabled && this.isTabVisible(param1))
  677.                   {
  678.                      _loc3_ = true;
  679.                   }
  680.                }
  681.             }
  682.             if(_loc3_)
  683.             {
  684.                if(this.mx_internal::focusableObjects.indexOf(param1) == -1)
  685.                {
  686.                   this.mx_internal::focusableObjects.push(param1);
  687.                   this.mx_internal::calculateCandidates = true;
  688.                }
  689.             }
  690.             param1.addEventListener("tabFocusEnabledChange",this.tabFocusEnabledChangeHandler);
  691.             param1.addEventListener("tabIndexChange",this.tabIndexChangeHandler);
  692.          }
  693.          if(param1 is DisplayObjectContainer)
  694.          {
  695.             _loc5_ = DisplayObjectContainer(param1);
  696.             if(param1 is IFocusManagerComponent)
  697.             {
  698.                param1.addEventListener("hasFocusableChildrenChange",this.hasFocusableChildrenChangeHandler);
  699.                _loc6_ = IFocusManagerComponent(param1).hasFocusableChildren;
  700.             }
  701.             else
  702.             {
  703.                param1.addEventListener("tabChildrenChange",this.tabChildrenChangeHandler);
  704.                _loc6_ = _loc5_.tabChildren;
  705.             }
  706.             if(_loc6_)
  707.             {
  708.                if(param1 is IRawChildrenContainer)
  709.                {
  710.                   _loc7_ = IRawChildrenContainer(param1).rawChildren;
  711.                   _loc8_ = 0;
  712.                   while(_loc8_ < _loc7_.numChildren)
  713.                   {
  714.                      try
  715.                      {
  716.                         this.mx_internal::addFocusables(_loc7_.getChildAt(_loc8_));
  717.                      }
  718.                      catch(error:SecurityError)
  719.                      {
  720.                      }
  721.                      _loc8_++;
  722.                   }
  723.                }
  724.                else
  725.                {
  726.                   _loc8_ = 0;
  727.                   while(_loc8_ < _loc5_.numChildren)
  728.                   {
  729.                      try
  730.                      {
  731.                         this.mx_internal::addFocusables(_loc5_.getChildAt(_loc8_));
  732.                      }
  733.                      catch(error:SecurityError)
  734.                      {
  735.                      }
  736.                      _loc8_++;
  737.                   }
  738.                }
  739.             }
  740.          }
  741.       }
  742.       
  743.       private function isTabVisible(param1:DisplayObject) : Boolean
  744.       {
  745.          var _loc2_:DisplayObject = DisplayObject(this.mx_internal::form.systemManager);
  746.          if(!_loc2_)
  747.          {
  748.             return false;
  749.          }
  750.          var _loc3_:DisplayObjectContainer = param1.parent;
  751.          while(Boolean(_loc3_) && _loc3_ != _loc2_)
  752.          {
  753.             if(!_loc3_.tabChildren)
  754.             {
  755.                return false;
  756.             }
  757.             if(_loc3_ is IFocusManagerComponent && !IFocusManagerComponent(_loc3_).hasFocusableChildren)
  758.             {
  759.                return false;
  760.             }
  761.             _loc3_ = _loc3_.parent;
  762.          }
  763.          return true;
  764.       }
  765.       
  766.       private function isValidFocusCandidate(param1:DisplayObject, param2:String) : Boolean
  767.       {
  768.          var _loc3_:IFocusManagerGroup = null;
  769.          if(param1 is IFocusManagerComponent)
  770.          {
  771.             if(!IFocusManagerComponent(param1).focusEnabled)
  772.             {
  773.                return false;
  774.             }
  775.          }
  776.          if(!this.isEnabledAndVisible(param1))
  777.          {
  778.             return false;
  779.          }
  780.          if(param1 is IFocusManagerGroup)
  781.          {
  782.             _loc3_ = IFocusManagerGroup(param1);
  783.             if(param2 == _loc3_.groupName)
  784.             {
  785.                return false;
  786.             }
  787.          }
  788.          return true;
  789.       }
  790.       
  791.       private function getIndexOfFocusedObject(param1:DisplayObject) : int
  792.       {
  793.          var _loc4_:IUIComponent = null;
  794.          if(!param1)
  795.          {
  796.             return -1;
  797.          }
  798.          var _loc2_:int = int(this.focusableCandidates.length);
  799.          var _loc3_:int = 0;
  800.          _loc3_ = 0;
  801.          while(_loc3_ < _loc2_)
  802.          {
  803.             if(this.focusableCandidates[_loc3_] == param1)
  804.             {
  805.                return _loc3_;
  806.             }
  807.             _loc3_++;
  808.          }
  809.          _loc3_ = 0;
  810.          while(_loc3_ < _loc2_)
  811.          {
  812.             _loc4_ = this.focusableCandidates[_loc3_] as IUIComponent;
  813.             if((Boolean(_loc4_)) && Boolean(_loc4_.owns(param1)))
  814.             {
  815.                return _loc3_;
  816.             }
  817.             _loc3_++;
  818.          }
  819.          return -1;
  820.       }
  821.       
  822.       private function getIndexOfNextObject(param1:int, param2:Boolean, param3:Boolean, param4:String) : int
  823.       {
  824.          var _loc7_:DisplayObject = null;
  825.          var _loc8_:IFocusManagerGroup = null;
  826.          var _loc9_:int = 0;
  827.          var _loc10_:DisplayObject = null;
  828.          var _loc11_:IFocusManagerGroup = null;
  829.          var _loc5_:int = int(this.focusableCandidates.length);
  830.          var _loc6_:int = param1;
  831.          while(true)
  832.          {
  833.             if(param2)
  834.             {
  835.                param1--;
  836.             }
  837.             else
  838.             {
  839.                param1++;
  840.             }
  841.             if(param3)
  842.             {
  843.                if(param2 && param1 < 0)
  844.                {
  845.                   break;
  846.                }
  847.                if(!param2 && param1 == _loc5_)
  848.                {
  849.                   break;
  850.                }
  851.             }
  852.             else
  853.             {
  854.                param1 = (param1 + _loc5_) % _loc5_;
  855.                if(_loc6_ == param1)
  856.                {
  857.                   break;
  858.                }
  859.                if(_loc6_ == -1)
  860.                {
  861.                   _loc6_ = param1;
  862.                }
  863.             }
  864.             if(this.isValidFocusCandidate(this.focusableCandidates[param1],param4))
  865.             {
  866.                _loc7_ = DisplayObject(this.findFocusManagerComponent2(this.focusableCandidates[param1]));
  867.                if(_loc7_ is IFocusManagerGroup)
  868.                {
  869.                   _loc8_ = IFocusManagerGroup(_loc7_);
  870.                   _loc9_ = 0;
  871.                   while(_loc9_ < this.focusableCandidates.length)
  872.                   {
  873.                      _loc10_ = this.focusableCandidates[_loc9_];
  874.                      if(_loc10_ is IFocusManagerGroup && this.isEnabledAndVisible(_loc10_))
  875.                      {
  876.                         _loc11_ = IFocusManagerGroup(_loc10_);
  877.                         if(_loc11_.groupName == _loc8_.groupName && _loc11_.selected)
  878.                         {
  879.                            if(InteractiveObject(_loc10_).tabIndex != InteractiveObject(_loc7_).tabIndex && !_loc8_.selected)
  880.                            {
  881.                               return this.getIndexOfNextObject(param1,param2,param3,param4);
  882.                            }
  883.                            param1 = _loc9_;
  884.                            break;
  885.                         }
  886.                      }
  887.                      _loc9_++;
  888.                   }
  889.                }
  890.                return param1;
  891.             }
  892.          }
  893.          return param1;
  894.       }
  895.       
  896.       private function setFocusToNextObject(param1:FocusEvent) : void
  897.       {
  898.          this.mx_internal::focusChanged = false;
  899.          if(this.mx_internal::focusableObjects.length == 0)
  900.          {
  901.             return;
  902.          }
  903.          var _loc2_:FocusInfo = this.getNextFocusManagerComponent2(param1.shiftKey,this.mx_internal::fauxFocus);
  904.          if(!this.mx_internal::popup && (_loc2_.wrapped || !_loc2_.displayObject))
  905.          {
  906.             if(hasEventListener("focusWrapping"))
  907.             {
  908.                if(!dispatchEvent(new FocusEvent("focusWrapping",false,true,null,param1.shiftKey)))
  909.                {
  910.                   return;
  911.                }
  912.             }
  913.          }
  914.          if(!_loc2_.displayObject)
  915.          {
  916.             param1.preventDefault();
  917.             return;
  918.          }
  919.          this.setFocusToComponent(_loc2_.displayObject,param1.shiftKey);
  920.       }
  921.       
  922.       private function setFocusToComponent(param1:Object, param2:Boolean) : void
  923.       {
  924.          this.mx_internal::focusChanged = false;
  925.          if(param1)
  926.          {
  927.             if(hasEventListener("setFocusToComponent"))
  928.             {
  929.                if(!dispatchEvent(new FocusEvent("setFocusToComponent",false,true,InteractiveObject(param1),param2)))
  930.                {
  931.                   return;
  932.                }
  933.             }
  934.             if(param1 is IFocusManagerComplexComponent)
  935.             {
  936.                IFocusManagerComplexComponent(param1).assignFocus(param2 ? "bottom" : "top");
  937.                this.mx_internal::focusChanged = true;
  938.             }
  939.             else if(param1 is IFocusManagerComponent)
  940.             {
  941.                this.setFocus(IFocusManagerComponent(param1));
  942.                this.mx_internal::focusChanged = true;
  943.             }
  944.          }
  945.       }
  946.       
  947.       mx_internal function setFocusToNextIndex(param1:int, param2:Boolean) : void
  948.       {
  949.          if(this.mx_internal::focusableObjects.length == 0)
  950.          {
  951.             return;
  952.          }
  953.          if(this.mx_internal::calculateCandidates)
  954.          {
  955.             this.sortFocusableObjects();
  956.             this.mx_internal::calculateCandidates = false;
  957.          }
  958.          var _loc3_:FocusInfo = this.getNextFocusManagerComponent2(param2,null,param1);
  959.          if(!this.mx_internal::popup && _loc3_.wrapped)
  960.          {
  961.             if(hasEventListener("setFocusToNextIndex"))
  962.             {
  963.                if(!dispatchEvent(new FocusEvent("setFocusToNextIndex",false,true,null,param2)))
  964.                {
  965.                   return;
  966.                }
  967.             }
  968.          }
  969.          this.setFocusToComponent(_loc3_.displayObject,param2);
  970.       }
  971.       
  972.       public function getNextFocusManagerComponent(param1:Boolean = false) : IFocusManagerComponent
  973.       {
  974.          return this.getNextFocusManagerComponent2(param1,this.mx_internal::fauxFocus).displayObject as IFocusManagerComponent;
  975.       }
  976.       
  977.       private function getNextFocusManagerComponent2(param1:Boolean = false, param2:DisplayObject = null, param3:int = -2) : FocusInfo
  978.       {
  979.          var _loc10_:DisplayObject = null;
  980.          var _loc11_:String = null;
  981.          var _loc12_:IFocusManagerGroup = null;
  982.          if(this.mx_internal::focusableObjects.length == 0)
  983.          {
  984.             return null;
  985.          }
  986.          if(this.mx_internal::calculateCandidates)
  987.          {
  988.             this.sortFocusableObjects();
  989.             this.mx_internal::calculateCandidates = false;
  990.          }
  991.          var _loc4_:int = param3;
  992.          if(param3 == FROM_INDEX_UNSPECIFIED)
  993.          {
  994.             _loc10_ = param2;
  995.             if(!_loc10_)
  996.             {
  997.                _loc10_ = this.mx_internal::form.systemManager.stage.focus;
  998.             }
  999.             _loc10_ = DisplayObject(this.findFocusManagerComponent2(InteractiveObject(_loc10_)));
  1000.             _loc11_ = "";
  1001.             if(_loc10_ is IFocusManagerGroup)
  1002.             {
  1003.                _loc12_ = IFocusManagerGroup(_loc10_);
  1004.                _loc11_ = _loc12_.groupName;
  1005.             }
  1006.             _loc4_ = this.getIndexOfFocusedObject(_loc10_);
  1007.          }
  1008.          var _loc5_:Boolean = false;
  1009.          var _loc6_:int = _loc4_;
  1010.          if(_loc4_ == -1)
  1011.          {
  1012.             if(param1)
  1013.             {
  1014.                _loc4_ = int(this.focusableCandidates.length);
  1015.             }
  1016.             _loc5_ = true;
  1017.          }
  1018.          var _loc7_:int = this.getIndexOfNextObject(_loc4_,param1,_loc5_,_loc11_);
  1019.          var _loc8_:Boolean = false;
  1020.          if(param1)
  1021.          {
  1022.             if(_loc7_ >= _loc4_)
  1023.             {
  1024.                _loc8_ = true;
  1025.             }
  1026.          }
  1027.          else if(_loc7_ <= _loc4_)
  1028.          {
  1029.             _loc8_ = true;
  1030.          }
  1031.          var _loc9_:FocusInfo = new FocusInfo();
  1032.          _loc9_.displayObject = this.findFocusManagerComponent2(this.focusableCandidates[_loc7_]);
  1033.          _loc9_.wrapped = _loc8_;
  1034.          return _loc9_;
  1035.       }
  1036.       
  1037.       private function getTopLevelFocusTarget(param1:InteractiveObject) : InteractiveObject
  1038.       {
  1039.          while(param1 != InteractiveObject(this.mx_internal::form))
  1040.          {
  1041.             if(param1 is IFocusManagerComponent && IFocusManagerComponent(param1).focusEnabled && IFocusManagerComponent(param1).mouseFocusEnabled && (param1 is IUIComponent ? IUIComponent(param1).enabled : true))
  1042.             {
  1043.                return param1;
  1044.             }
  1045.             if(hasEventListener("getTopLevelFocusTarget"))
  1046.             {
  1047.                if(!dispatchEvent(new FocusEvent("getTopLevelFocusTarget",false,true,param1.parent)))
  1048.                {
  1049.                   return null;
  1050.                }
  1051.             }
  1052.             param1 = param1.parent;
  1053.             if(param1 == null)
  1054.             {
  1055.                break;
  1056.             }
  1057.          }
  1058.          return null;
  1059.       }
  1060.       
  1061.       override public function toString() : String
  1062.       {
  1063.          return Object(this.mx_internal::form).toString() + ".focusManager";
  1064.       }
  1065.       
  1066.       private function clearBrowserFocusComponent() : void
  1067.       {
  1068.          if(this.browserFocusComponent)
  1069.          {
  1070.             if(this.browserFocusComponent.tabIndex == this.LARGE_TAB_INDEX)
  1071.             {
  1072.                this.browserFocusComponent.tabIndex = -1;
  1073.             }
  1074.             this.browserFocusComponent = null;
  1075.          }
  1076.       }
  1077.       
  1078.       private function addedHandler(param1:Event) : void
  1079.       {
  1080.          var _loc2_:DisplayObject = DisplayObject(param1.target);
  1081.          if(_loc2_.stage)
  1082.          {
  1083.             this.mx_internal::addFocusables(DisplayObject(param1.target));
  1084.          }
  1085.       }
  1086.       
  1087.       private function removedHandler(param1:Event) : void
  1088.       {
  1089.          var _loc2_:int = 0;
  1090.          var _loc3_:DisplayObject = DisplayObject(param1.target);
  1091.          var _loc4_:DisplayObject = !!this.focusPane ? this.focusPane.parent : null;
  1092.          if((Boolean(_loc4_)) && _loc3_ != this.focusPane)
  1093.          {
  1094.             if(_loc3_ is DisplayObjectContainer && this.isParent(DisplayObjectContainer(_loc3_),this.focusPane))
  1095.             {
  1096.                if(_loc4_ is ISystemManager)
  1097.                {
  1098.                   ISystemManager(_loc4_).focusPane = null;
  1099.                }
  1100.                else
  1101.                {
  1102.                   IUIComponent(_loc4_).focusPane = null;
  1103.                }
  1104.             }
  1105.          }
  1106.          if(_loc3_ is IFocusManagerComponent)
  1107.          {
  1108.             _loc2_ = 0;
  1109.             while(_loc2_ < this.mx_internal::focusableObjects.length)
  1110.             {
  1111.                if(_loc3_ == this.mx_internal::focusableObjects[_loc2_])
  1112.                {
  1113.                   if(_loc3_ == this._lastFocus)
  1114.                   {
  1115.                      this._lastFocus.drawFocus(false);
  1116.                      this._lastFocus = null;
  1117.                   }
  1118.                   this.mx_internal::focusableObjects.splice(_loc2_,1);
  1119.                   this.focusableCandidates = [];
  1120.                   this.mx_internal::calculateCandidates = true;
  1121.                   break;
  1122.                }
  1123.                _loc2_++;
  1124.             }
  1125.             _loc3_.removeEventListener("tabFocusEnabledChange",this.tabFocusEnabledChangeHandler);
  1126.             _loc3_.removeEventListener("tabIndexChange",this.tabIndexChangeHandler);
  1127.          }
  1128.          this.removeFocusables(_loc3_,false);
  1129.       }
  1130.       
  1131.       private function removeFocusables(param1:DisplayObject, param2:Boolean) : void
  1132.       {
  1133.          var _loc3_:int = 0;
  1134.          if(param1 is DisplayObjectContainer)
  1135.          {
  1136.             if(!param2)
  1137.             {
  1138.                param1.removeEventListener("tabChildrenChange",this.tabChildrenChangeHandler);
  1139.                param1.removeEventListener("hasFocusableChildrenChange",this.hasFocusableChildrenChangeHandler);
  1140.             }
  1141.             _loc3_ = 0;
  1142.             while(_loc3_ < this.mx_internal::focusableObjects.length)
  1143.             {
  1144.                if(this.isParent(DisplayObjectContainer(param1),this.mx_internal::focusableObjects[_loc3_]))
  1145.                {
  1146.                   if(this.mx_internal::focusableObjects[_loc3_] == this._lastFocus)
  1147.                   {
  1148.                      this._lastFocus.drawFocus(false);
  1149.                      this._lastFocus = null;
  1150.                   }
  1151.                   this.mx_internal::focusableObjects[_loc3_].removeEventListener("tabFocusEnabledChange",this.tabFocusEnabledChangeHandler);
  1152.                   this.mx_internal::focusableObjects[_loc3_].removeEventListener("tabIndexChange",this.tabIndexChangeHandler);
  1153.                   this.mx_internal::focusableObjects.splice(_loc3_,1);
  1154.                   _loc3_--;
  1155.                   this.focusableCandidates = [];
  1156.                   this.mx_internal::calculateCandidates = true;
  1157.                }
  1158.                _loc3_++;
  1159.             }
  1160.          }
  1161.       }
  1162.       
  1163.       private function showHandler(param1:Event) : void
  1164.       {
  1165.          var _loc2_:IActiveWindowManager = IActiveWindowManager(this.mx_internal::form.systemManager.getImplementation("mx.managers::IActiveWindowManager"));
  1166.          if(_loc2_)
  1167.          {
  1168.             _loc2_.activate(this.mx_internal::form);
  1169.          }
  1170.       }
  1171.       
  1172.       private function hideHandler(param1:Event) : void
  1173.       {
  1174.          var _loc2_:IActiveWindowManager = IActiveWindowManager(this.mx_internal::form.systemManager.getImplementation("mx.managers::IActiveWindowManager"));
  1175.          if(_loc2_)
  1176.          {
  1177.             _loc2_.deactivate(this.mx_internal::form);
  1178.          }
  1179.       }
  1180.       
  1181.       private function childHideHandler(param1:Event) : void
  1182.       {
  1183.          var _loc2_:DisplayObject = DisplayObject(param1.target);
  1184.          if(this.mx_internal::lastFocus && !this.isEnabledAndVisible(DisplayObject(this.mx_internal::lastFocus)) && Boolean(DisplayObject(this.mx_internal::form).stage))
  1185.          {
  1186.             DisplayObject(this.mx_internal::form).stage.focus = null;
  1187.             this.mx_internal::lastFocus = null;
  1188.          }
  1189.       }
  1190.       
  1191.       private function viewHideHandler(param1:Event) : void
  1192.       {
  1193.          var _loc2_:DisplayObjectContainer = param1.target as DisplayObjectContainer;
  1194.          var _loc3_:DisplayObject = this.mx_internal::lastFocus as DisplayObject;
  1195.          if(_loc2_ && _loc3_ && _loc2_.contains(_loc3_))
  1196.          {
  1197.             this.mx_internal::lastFocus = null;
  1198.          }
  1199.       }
  1200.       
  1201.       private function creationCompleteHandler(param1:FlexEvent) : void
  1202.       {
  1203.          var _loc3_:IActiveWindowManager = null;
  1204.          var _loc2_:DisplayObject = DisplayObject(this.mx_internal::form);
  1205.          if(_loc2_.parent && _loc2_.visible && !this.activated)
  1206.          {
  1207.             _loc3_ = IActiveWindowManager(this.mx_internal::form.systemManager.getImplementation("mx.managers::IActiveWindowManager"));
  1208.             if(_loc3_)
  1209.             {
  1210.                _loc3_.activate(this.mx_internal::form);
  1211.             }
  1212.          }
  1213.       }
  1214.       
  1215.       private function tabIndexChangeHandler(param1:Event) : void
  1216.       {
  1217.          this.mx_internal::calculateCandidates = true;
  1218.       }
  1219.       
  1220.       private function tabFocusEnabledChangeHandler(param1:Event) : void
  1221.       {
  1222.          this.mx_internal::calculateCandidates = true;
  1223.          var _loc2_:IFocusManagerComponent = IFocusManagerComponent(param1.target);
  1224.          var _loc3_:int = int(this.mx_internal::focusableObjects.length);
  1225.          var _loc4_:int = 0;
  1226.          while(_loc4_ < _loc3_)
  1227.          {
  1228.             if(this.mx_internal::focusableObjects[_loc4_] == _loc2_)
  1229.             {
  1230.                break;
  1231.             }
  1232.             _loc4_++;
  1233.          }
  1234.          if(_loc2_.tabFocusEnabled)
  1235.          {
  1236.             if(_loc4_ == _loc3_ && this.isTabVisible(DisplayObject(_loc2_)))
  1237.             {
  1238.                if(this.mx_internal::focusableObjects.indexOf(_loc2_) == -1)
  1239.                {
  1240.                   this.mx_internal::focusableObjects.push(_loc2_);
  1241.                }
  1242.             }
  1243.          }
  1244.          else if(_loc4_ < _loc3_)
  1245.          {
  1246.             this.mx_internal::focusableObjects.splice(_loc4_,1);
  1247.          }
  1248.       }
  1249.       
  1250.       private function tabChildrenChangeHandler(param1:Event) : void
  1251.       {
  1252.          if(param1.target != param1.currentTarget)
  1253.          {
  1254.             return;
  1255.          }
  1256.          this.mx_internal::calculateCandidates = true;
  1257.          var _loc2_:DisplayObjectContainer = DisplayObjectContainer(param1.target);
  1258.          if(_loc2_.tabChildren)
  1259.          {
  1260.             this.mx_internal::addFocusables(_loc2_,true);
  1261.          }
  1262.          else
  1263.          {
  1264.             this.removeFocusables(_loc2_,true);
  1265.          }
  1266.       }
  1267.       
  1268.       private function hasFocusableChildrenChangeHandler(param1:Event) : void
  1269.       {
  1270.          if(param1.target != param1.currentTarget)
  1271.          {
  1272.             return;
  1273.          }
  1274.          this.mx_internal::calculateCandidates = true;
  1275.          var _loc2_:IFocusManagerComponent = IFocusManagerComponent(param1.target);
  1276.          if(_loc2_.hasFocusableChildren)
  1277.          {
  1278.             this.mx_internal::addFocusables(DisplayObject(_loc2_),true);
  1279.          }
  1280.          else
  1281.          {
  1282.             this.removeFocusables(DisplayObject(_loc2_),true);
  1283.          }
  1284.       }
  1285.       
  1286.       private function mouseFocusChangeHandler(param1:FocusEvent) : void
  1287.       {
  1288.          var _loc2_:TextField = null;
  1289.          if(param1.isDefaultPrevented())
  1290.          {
  1291.             return;
  1292.          }
  1293.          if(param1.relatedObject == null && "isRelatedObjectInaccessible" in param1 && param1["isRelatedObjectInaccessible"] == true)
  1294.          {
  1295.             return;
  1296.          }
  1297.          if(param1.relatedObject is TextField)
  1298.          {
  1299.             _loc2_ = param1.relatedObject as TextField;
  1300.             if(_loc2_.type == "input" || _loc2_.selectable)
  1301.             {
  1302.                return;
  1303.             }
  1304.          }
  1305.          param1.preventDefault();
  1306.       }
  1307.       
  1308.       mx_internal function keyFocusChangeHandler(param1:FocusEvent) : void
  1309.       {
  1310.          var _loc2_:ISystemManager = this.mx_internal::form.systemManager;
  1311.          if(hasEventListener("keyFocusChange"))
  1312.          {
  1313.             if(!dispatchEvent(new FocusEvent("keyFocusChange",false,true,InteractiveObject(param1.target))))
  1314.             {
  1315.                return;
  1316.             }
  1317.          }
  1318.          this.showFocusIndicator = true;
  1319.          this.mx_internal::focusChanged = false;
  1320.          var _loc3_:* = this.browserFocusComponent != null;
  1321.          if(this.browserFocusComponent)
  1322.          {
  1323.             this.clearBrowserFocusComponent();
  1324.          }
  1325.          if((param1.keyCode == Keyboard.TAB || this.browserMode && param1.keyCode == 0) && !param1.isDefaultPrevented())
  1326.          {
  1327.             if(_loc3_)
  1328.             {
  1329.                if(hasEventListener("browserFocusComponent"))
  1330.                {
  1331.                   dispatchEvent(new FocusEvent("browserFocusComponent",false,false,InteractiveObject(param1.target)));
  1332.                }
  1333.                return;
  1334.             }
  1335.             this.setFocusToNextObject(param1);
  1336.             if(this.mx_internal::focusChanged || _loc2_ == _loc2_.getTopLevelRoot())
  1337.             {
  1338.                param1.preventDefault();
  1339.             }
  1340.          }
  1341.       }
  1342.       
  1343.       mx_internal function keyDownHandler(param1:KeyboardEvent) : void
  1344.       {
  1345.          var _loc3_:DisplayObject = null;
  1346.          var _loc4_:String = null;
  1347.          var _loc5_:int = 0;
  1348.          var _loc6_:int = 0;
  1349.          var _loc7_:IFocusManagerGroup = null;
  1350.          var _loc2_:ISystemManager = this.mx_internal::form.systemManager;
  1351.          if(hasEventListener("keyDownFM"))
  1352.          {
  1353.             if(!dispatchEvent(new FocusEvent("keyDownFM",false,true,InteractiveObject(param1.target))))
  1354.             {
  1355.                return;
  1356.             }
  1357.          }
  1358.          if(_loc2_ is SystemManager)
  1359.          {
  1360.             SystemManager(_loc2_).mx_internal::idleCounter = 0;
  1361.          }
  1362.          if(param1.keyCode == Keyboard.TAB)
  1363.          {
  1364.             this.mx_internal::lastAction = "KEY";
  1365.             if(this.mx_internal::calculateCandidates)
  1366.             {
  1367.                this.sortFocusableObjects();
  1368.                this.mx_internal::calculateCandidates = false;
  1369.             }
  1370.          }
  1371.          if(this.browserMode)
  1372.          {
  1373.             if(this.browserFocusComponent)
  1374.             {
  1375.                this.clearBrowserFocusComponent();
  1376.             }
  1377.             if(param1.keyCode == Keyboard.TAB && this.focusableCandidates.length > 0)
  1378.             {
  1379.                _loc3_ = this.mx_internal::fauxFocus;
  1380.                if(!_loc3_)
  1381.                {
  1382.                   _loc3_ = this.mx_internal::form.systemManager.stage.focus;
  1383.                }
  1384.                _loc3_ = DisplayObject(this.findFocusManagerComponent2(InteractiveObject(_loc3_)));
  1385.                _loc4_ = "";
  1386.                if(_loc3_ is IFocusManagerGroup)
  1387.                {
  1388.                   _loc7_ = IFocusManagerGroup(_loc3_);
  1389.                   _loc4_ = _loc7_.groupName;
  1390.                }
  1391.                _loc5_ = this.getIndexOfFocusedObject(_loc3_);
  1392.                _loc6_ = this.getIndexOfNextObject(_loc5_,param1.shiftKey,false,_loc4_);
  1393.                if(param1.shiftKey)
  1394.                {
  1395.                   if(_loc6_ >= _loc5_)
  1396.                   {
  1397.                      this.browserFocusComponent = this.getBrowserFocusComponent(param1.shiftKey);
  1398.                      if(this.browserFocusComponent.tabIndex == -1)
  1399.                      {
  1400.                         this.browserFocusComponent.tabIndex = 0;
  1401.                      }
  1402.                   }
  1403.                }
  1404.                else if(_loc6_ <= _loc5_)
  1405.                {
  1406.                   this.browserFocusComponent = this.getBrowserFocusComponent(param1.shiftKey);
  1407.                   if(this.browserFocusComponent.tabIndex == -1)
  1408.                   {
  1409.                      this.browserFocusComponent.tabIndex = this.LARGE_TAB_INDEX;
  1410.                   }
  1411.                }
  1412.             }
  1413.          }
  1414.       }
  1415.       
  1416.       private function defaultButtonKeyHandler(param1:KeyboardEvent) : void
  1417.       {
  1418.          var _loc2_:ISystemManager = this.mx_internal::form.systemManager;
  1419.          if(hasEventListener("defaultButtonKeyHandler"))
  1420.          {
  1421.             if(!dispatchEvent(new FocusEvent("defaultButtonKeyHandler",false,true)))
  1422.             {
  1423.                return;
  1424.             }
  1425.          }
  1426.          if(this.defaultButtonEnabled && param1.keyCode == Keyboard.ENTER && this.defaultButton && Boolean(this.defButton.enabled))
  1427.          {
  1428.             this.mx_internal::sendDefaultButtonEvent();
  1429.          }
  1430.       }
  1431.       
  1432.       private function mouseDownCaptureHandler(param1:MouseEvent) : void
  1433.       {
  1434.          this.showFocusIndicator = false;
  1435.       }
  1436.       
  1437.       private function mouseDownHandler(param1:MouseEvent) : void
  1438.       {
  1439.          var _loc2_:ISystemManager = this.mx_internal::form.systemManager;
  1440.          var _loc3_:DisplayObject = this.getTopLevelFocusTarget(InteractiveObject(param1.target));
  1441.          if(!_loc3_)
  1442.          {
  1443.             return;
  1444.          }
  1445.          if((_loc3_ != this._lastFocus || this.mx_internal::lastAction == "ACTIVATE") && !(_loc3_ is TextField))
  1446.          {
  1447.             this.setFocus(IFocusManagerComponent(_loc3_));
  1448.          }
  1449.          else if(!this._lastFocus)
  1450.          {
  1451.          }
  1452.          if(hasEventListener("mouseDownFM"))
  1453.          {
  1454.             dispatchEvent(new FocusEvent("mouseDownFM",false,false,InteractiveObject(_loc3_)));
  1455.          }
  1456.          this.mx_internal::lastAction = "MOUSEDOWN";
  1457.       }
  1458.       
  1459.       private function getBrowserFocusComponent(param1:Boolean) : InteractiveObject
  1460.       {
  1461.          var _loc3_:int = 0;
  1462.          var _loc2_:InteractiveObject = this.mx_internal::form.systemManager.stage.focus;
  1463.          if(!_loc2_)
  1464.          {
  1465.             _loc3_ = param1 ? 0 : int(this.focusableCandidates.length - 1);
  1466.             _loc2_ = this.focusableCandidates[_loc3_];
  1467.          }
  1468.          return _loc2_;
  1469.       }
  1470.    }
  1471. }
  1472.  
  1473. import flash.display.DisplayObject;
  1474.  
  1475. class FocusInfo
  1476. {
  1477.    public var displayObject:DisplayObject;
  1478.    
  1479.    public var wrapped:Boolean;
  1480.    
  1481.    public function FocusInfo()
  1482.    {
  1483.       super();
  1484.    }
  1485. }
  1486.