home *** CD-ROM | disk | FTP | other *** search
/ PCGUIA 2010 Software/Programs / PCGuia_programas.iso / Software / Utils / Livebrush / Install-LivebrushLite.air / livebrush.swf / scripts / fl / managers / FocusManager.as next >
Encoding:
Text File  |  2009-10-26  |  25.0 KB  |  792 lines
  1. package fl.managers
  2. {
  3.    import fl.controls.Button;
  4.    import fl.core.UIComponent;
  5.    import flash.display.DisplayObject;
  6.    import flash.display.DisplayObjectContainer;
  7.    import flash.display.InteractiveObject;
  8.    import flash.display.SimpleButton;
  9.    import flash.display.Stage;
  10.    import flash.events.Event;
  11.    import flash.events.FocusEvent;
  12.    import flash.events.KeyboardEvent;
  13.    import flash.events.MouseEvent;
  14.    import flash.text.TextField;
  15.    import flash.text.TextFieldType;
  16.    import flash.ui.Keyboard;
  17.    import flash.utils.*;
  18.    
  19.    public class FocusManager implements IFocusManager
  20.    {
  21.       private var focusableObjects:Dictionary;
  22.       
  23.       private var _showFocusIndicator:Boolean = true;
  24.       
  25.       private var defButton:Button;
  26.       
  27.       private var focusableCandidates:Array;
  28.       
  29.       private var _form:DisplayObjectContainer;
  30.       
  31.       private var _defaultButtonEnabled:Boolean = true;
  32.       
  33.       private var activated:Boolean = false;
  34.       
  35.       private var _defaultButton:Button;
  36.       
  37.       private var calculateCandidates:Boolean = true;
  38.       
  39.       private var lastFocus:InteractiveObject;
  40.       
  41.       private var lastAction:String;
  42.       
  43.       public function FocusManager(param1:DisplayObjectContainer)
  44.       {
  45.          super();
  46.          focusableObjects = new Dictionary(true);
  47.          if(param1 != null)
  48.          {
  49.             _form = param1;
  50.             addFocusables(DisplayObject(param1));
  51.             param1.addEventListener(Event.ADDED,addedHandler);
  52.             param1.addEventListener(Event.REMOVED,removedHandler);
  53.             activate();
  54.          }
  55.       }
  56.       
  57.       public function get showFocusIndicator() : Boolean
  58.       {
  59.          return _showFocusIndicator;
  60.       }
  61.       
  62.       private function getIndexOfNextObject(param1:int, param2:Boolean, param3:Boolean, param4:String) : int
  63.       {
  64.          var _loc7_:DisplayObject = null;
  65.          var _loc8_:IFocusManagerGroup = null;
  66.          var _loc9_:int = 0;
  67.          var _loc10_:DisplayObject = null;
  68.          var _loc11_:IFocusManagerGroup = null;
  69.          var _loc5_:int = int(focusableCandidates.length);
  70.          var _loc6_:int = param1;
  71.          while(true)
  72.          {
  73.             if(param2)
  74.             {
  75.                param1--;
  76.             }
  77.             else
  78.             {
  79.                param1++;
  80.             }
  81.             if(param3)
  82.             {
  83.                if(param2 && param1 < 0)
  84.                {
  85.                   break;
  86.                }
  87.                if(!param2 && param1 == _loc5_)
  88.                {
  89.                   break;
  90.                }
  91.             }
  92.             else
  93.             {
  94.                param1 = (param1 + _loc5_) % _loc5_;
  95.                if(_loc6_ == param1)
  96.                {
  97.                   break;
  98.                }
  99.             }
  100.             if(isValidFocusCandidate(focusableCandidates[param1],param4))
  101.             {
  102.                _loc7_ = DisplayObject(findFocusManagerComponent(focusableCandidates[param1]));
  103.                if(_loc7_ is IFocusManagerGroup)
  104.                {
  105.                   _loc8_ = IFocusManagerGroup(_loc7_);
  106.                   _loc9_ = 0;
  107.                   while(_loc9_ < focusableCandidates.length)
  108.                   {
  109.                      _loc10_ = focusableCandidates[_loc9_];
  110.                      if(_loc10_ is IFocusManagerGroup)
  111.                      {
  112.                         _loc11_ = IFocusManagerGroup(_loc10_);
  113.                         if(_loc11_.groupName == _loc8_.groupName && _loc11_.selected)
  114.                         {
  115.                            param1 = _loc9_;
  116.                            break;
  117.                         }
  118.                      }
  119.                      _loc9_++;
  120.                   }
  121.                }
  122.                return param1;
  123.             }
  124.          }
  125.          return param1;
  126.       }
  127.       
  128.       private function mouseFocusChangeHandler(param1:FocusEvent) : void
  129.       {
  130.          if(param1.relatedObject is TextField)
  131.          {
  132.             return;
  133.          }
  134.          param1.preventDefault();
  135.       }
  136.       
  137.       public function set form(param1:DisplayObjectContainer) : void
  138.       {
  139.          _form = param1;
  140.       }
  141.       
  142.       private function addFocusables(param1:DisplayObject, param2:Boolean = false) : void
  143.       {
  144.          var focusable:IFocusManagerComponent = null;
  145.          var io:InteractiveObject = null;
  146.          var doc:DisplayObjectContainer = null;
  147.          var i:int = 0;
  148.          var child:DisplayObject = null;
  149.          var o:DisplayObject = param1;
  150.          var skipTopLevel:Boolean = param2;
  151.          if(!skipTopLevel)
  152.          {
  153.             if(o is IFocusManagerComponent)
  154.             {
  155.                focusable = IFocusManagerComponent(o);
  156.                if(focusable.focusEnabled)
  157.                {
  158.                   if(focusable.tabEnabled && isTabVisible(o))
  159.                   {
  160.                      focusableObjects[o] = true;
  161.                      calculateCandidates = true;
  162.                   }
  163.                   o.addEventListener(Event.TAB_ENABLED_CHANGE,tabEnabledChangeHandler);
  164.                   o.addEventListener(Event.TAB_INDEX_CHANGE,tabIndexChangeHandler);
  165.                }
  166.             }
  167.             else if(o is InteractiveObject)
  168.             {
  169.                io = o as InteractiveObject;
  170.                if(io && io.tabEnabled && findFocusManagerComponent(io) == io)
  171.                {
  172.                   focusableObjects[io] = true;
  173.                   calculateCandidates = true;
  174.                }
  175.                io.addEventListener(Event.TAB_ENABLED_CHANGE,tabEnabledChangeHandler);
  176.                io.addEventListener(Event.TAB_INDEX_CHANGE,tabIndexChangeHandler);
  177.             }
  178.          }
  179.          if(o is DisplayObjectContainer)
  180.          {
  181.             doc = DisplayObjectContainer(o);
  182.             o.addEventListener(Event.TAB_CHILDREN_CHANGE,tabChildrenChangeHandler);
  183.             if(doc is Stage || doc.parent is Stage || doc.tabChildren)
  184.             {
  185.                i = 0;
  186.                while(i < doc.numChildren)
  187.                {
  188.                   try
  189.                   {
  190.                      child = doc.getChildAt(i);
  191.                      if(child != null)
  192.                      {
  193.                         addFocusables(doc.getChildAt(i));
  194.                      }
  195.                   }
  196.                   catch(error:SecurityError)
  197.                   {
  198.                   }
  199.                   i++;
  200.                }
  201.             }
  202.          }
  203.       }
  204.       
  205.       private function getChildIndex(param1:DisplayObjectContainer, param2:DisplayObject) : int
  206.       {
  207.          return param1.getChildIndex(param2);
  208.       }
  209.       
  210.       public function findFocusManagerComponent(param1:InteractiveObject) : InteractiveObject
  211.       {
  212.          var _loc2_:InteractiveObject = param1;
  213.          while(param1)
  214.          {
  215.             if(param1 is IFocusManagerComponent && IFocusManagerComponent(param1).focusEnabled)
  216.             {
  217.                return param1;
  218.             }
  219.             param1 = param1.parent;
  220.          }
  221.          return _loc2_;
  222.       }
  223.       
  224.       private function focusOutHandler(param1:FocusEvent) : void
  225.       {
  226.          var _loc2_:InteractiveObject = param1.target as InteractiveObject;
  227.       }
  228.       
  229.       private function isValidFocusCandidate(param1:DisplayObject, param2:String) : Boolean
  230.       {
  231.          var _loc3_:IFocusManagerGroup = null;
  232.          if(!isEnabledAndVisible(param1))
  233.          {
  234.             return false;
  235.          }
  236.          if(param1 is IFocusManagerGroup)
  237.          {
  238.             _loc3_ = IFocusManagerGroup(param1);
  239.             if(param2 == _loc3_.groupName)
  240.             {
  241.                return false;
  242.             }
  243.          }
  244.          return true;
  245.       }
  246.       
  247.       private function setFocusToNextObject(param1:FocusEvent) : void
  248.       {
  249.          if(!hasFocusableObjects())
  250.          {
  251.             return;
  252.          }
  253.          var _loc2_:InteractiveObject = getNextFocusManagerComponent(param1.shiftKey);
  254.          if(_loc2_)
  255.          {
  256.             setFocus(_loc2_);
  257.          }
  258.       }
  259.       
  260.       private function sortFocusableObjectsTabIndex() : void
  261.       {
  262.          var _loc1_:Object = null;
  263.          var _loc2_:InteractiveObject = null;
  264.          focusableCandidates = [];
  265.          for(_loc1_ in focusableObjects)
  266.          {
  267.             _loc2_ = InteractiveObject(_loc1_);
  268.             if(Boolean(_loc2_.tabIndex) && !isNaN(Number(_loc2_.tabIndex)))
  269.             {
  270.                focusableCandidates.push(_loc2_);
  271.             }
  272.          }
  273.          focusableCandidates.sort(sortByTabIndex);
  274.       }
  275.       
  276.       private function removeFocusables(param1:DisplayObject) : void
  277.       {
  278.          var _loc2_:Object = null;
  279.          var _loc3_:DisplayObject = null;
  280.          if(param1 is DisplayObjectContainer)
  281.          {
  282.             param1.removeEventListener(Event.TAB_CHILDREN_CHANGE,tabChildrenChangeHandler);
  283.             param1.removeEventListener(Event.TAB_INDEX_CHANGE,tabIndexChangeHandler);
  284.             for(_loc2_ in focusableObjects)
  285.             {
  286.                _loc3_ = DisplayObject(_loc2_);
  287.                if(DisplayObjectContainer(param1).contains(_loc3_))
  288.                {
  289.                   if(_loc3_ == lastFocus)
  290.                   {
  291.                      lastFocus = null;
  292.                   }
  293.                   _loc3_.removeEventListener(Event.TAB_ENABLED_CHANGE,tabEnabledChangeHandler);
  294.                   delete focusableObjects[_loc2_];
  295.                   calculateCandidates = true;
  296.                }
  297.             }
  298.          }
  299.       }
  300.       
  301.       private function getTopLevelFocusTarget(param1:InteractiveObject) : InteractiveObject
  302.       {
  303.          while(param1 != InteractiveObject(form))
  304.          {
  305.             if(param1 is IFocusManagerComponent && IFocusManagerComponent(param1).focusEnabled && IFocusManagerComponent(param1).mouseFocusEnabled && UIComponent(param1).enabled)
  306.             {
  307.                return param1;
  308.             }
  309.             param1 = param1.parent;
  310.             if(param1 == null)
  311.             {
  312.                break;
  313.             }
  314.          }
  315.          return null;
  316.       }
  317.       
  318.       public function sendDefaultButtonEvent() : void
  319.       {
  320.          defButton.dispatchEvent(new MouseEvent(MouseEvent.CLICK));
  321.       }
  322.       
  323.       private function addedHandler(param1:Event) : void
  324.       {
  325.          var _loc2_:DisplayObject = DisplayObject(param1.target);
  326.          if(_loc2_.stage)
  327.          {
  328.             addFocusables(DisplayObject(param1.target));
  329.          }
  330.       }
  331.       
  332.       private function isEnabledAndVisible(param1:DisplayObject) : Boolean
  333.       {
  334.          var _loc3_:TextField = null;
  335.          var _loc4_:SimpleButton = null;
  336.          var _loc2_:DisplayObjectContainer = DisplayObject(form).parent;
  337.          while(param1 != _loc2_)
  338.          {
  339.             if(param1 is UIComponent)
  340.             {
  341.                if(!UIComponent(param1).enabled)
  342.                {
  343.                   return false;
  344.                }
  345.             }
  346.             else if(param1 is TextField)
  347.             {
  348.                _loc3_ = TextField(param1);
  349.                if(_loc3_.type == TextFieldType.DYNAMIC || !_loc3_.selectable)
  350.                {
  351.                   return false;
  352.                }
  353.             }
  354.             else if(param1 is SimpleButton)
  355.             {
  356.                _loc4_ = SimpleButton(param1);
  357.                if(!_loc4_.enabled)
  358.                {
  359.                   return false;
  360.                }
  361.             }
  362.             if(!param1.visible)
  363.             {
  364.                return false;
  365.             }
  366.             param1 = param1.parent;
  367.          }
  368.          return true;
  369.       }
  370.       
  371.       private function tabChildrenChangeHandler(param1:Event) : void
  372.       {
  373.          if(param1.target != param1.currentTarget)
  374.          {
  375.             return;
  376.          }
  377.          calculateCandidates = true;
  378.          var _loc2_:DisplayObjectContainer = DisplayObjectContainer(param1.target);
  379.          if(_loc2_.tabChildren)
  380.          {
  381.             addFocusables(_loc2_,true);
  382.          }
  383.          else
  384.          {
  385.             removeFocusables(_loc2_);
  386.          }
  387.       }
  388.       
  389.       private function deactivateHandler(param1:Event) : void
  390.       {
  391.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  392.       }
  393.       
  394.       public function setFocus(param1:InteractiveObject) : void
  395.       {
  396.          if(param1 is IFocusManagerComponent)
  397.          {
  398.             IFocusManagerComponent(param1).setFocus();
  399.          }
  400.          else
  401.          {
  402.             form.stage.focus = param1;
  403.          }
  404.       }
  405.       
  406.       public function getFocus() : InteractiveObject
  407.       {
  408.          var _loc1_:InteractiveObject = form.stage.focus;
  409.          return findFocusManagerComponent(_loc1_);
  410.       }
  411.       
  412.       private function hasFocusableObjects() : Boolean
  413.       {
  414.          var _loc1_:Object = null;
  415.          var _loc2_:int = 0;
  416.          var _loc3_:* = focusableObjects;
  417.          for(_loc1_ in _loc3_)
  418.          {
  419.             return true;
  420.          }
  421.          return false;
  422.       }
  423.       
  424.       private function tabIndexChangeHandler(param1:Event) : void
  425.       {
  426.          calculateCandidates = true;
  427.       }
  428.       
  429.       public function set defaultButton(param1:Button) : void
  430.       {
  431.          var _loc2_:Button = !!param1 ? Button(param1) : null;
  432.          if(_loc2_ != _defaultButton)
  433.          {
  434.             if(_defaultButton)
  435.             {
  436.                _defaultButton.emphasized = false;
  437.             }
  438.             if(defButton)
  439.             {
  440.                defButton.emphasized = false;
  441.             }
  442.             _defaultButton = _loc2_;
  443.             defButton = _loc2_;
  444.             if(_loc2_)
  445.             {
  446.                _loc2_.emphasized = true;
  447.             }
  448.          }
  449.       }
  450.       
  451.       private function sortFocusableObjects() : void
  452.       {
  453.          var _loc1_:Object = null;
  454.          var _loc2_:InteractiveObject = null;
  455.          focusableCandidates = [];
  456.          for(_loc1_ in focusableObjects)
  457.          {
  458.             _loc2_ = InteractiveObject(_loc1_);
  459.             if(_loc2_.tabIndex && !isNaN(Number(_loc2_.tabIndex)) && _loc2_.tabIndex > 0)
  460.             {
  461.                sortFocusableObjectsTabIndex();
  462.                return;
  463.             }
  464.             focusableCandidates.push(_loc2_);
  465.          }
  466.          focusableCandidates.sort(sortByDepth);
  467.       }
  468.       
  469.       private function keyFocusChangeHandler(param1:FocusEvent) : void
  470.       {
  471.          showFocusIndicator = true;
  472.          if((param1.keyCode == Keyboard.TAB || param1.keyCode == 0) && !param1.isDefaultPrevented())
  473.          {
  474.             setFocusToNextObject(param1);
  475.             param1.preventDefault();
  476.          }
  477.       }
  478.       
  479.       private function getIndexOfFocusedObject(param1:DisplayObject) : int
  480.       {
  481.          var _loc2_:int = int(focusableCandidates.length);
  482.          var _loc3_:int = 0;
  483.          _loc3_ = 0;
  484.          while(_loc3_ < _loc2_)
  485.          {
  486.             if(focusableCandidates[_loc3_] == param1)
  487.             {
  488.                return _loc3_;
  489.             }
  490.             _loc3_++;
  491.          }
  492.          return -1;
  493.       }
  494.       
  495.       public function hideFocus() : void
  496.       {
  497.       }
  498.       
  499.       private function removedHandler(param1:Event) : void
  500.       {
  501.          var _loc2_:int = 0;
  502.          var _loc4_:InteractiveObject = null;
  503.          var _loc3_:DisplayObject = DisplayObject(param1.target);
  504.          if(_loc3_ is IFocusManagerComponent && focusableObjects[_loc3_] == true)
  505.          {
  506.             if(_loc3_ == lastFocus)
  507.             {
  508.                IFocusManagerComponent(lastFocus).drawFocus(false);
  509.                lastFocus = null;
  510.             }
  511.             _loc3_.removeEventListener(Event.TAB_ENABLED_CHANGE,tabEnabledChangeHandler);
  512.             delete focusableObjects[_loc3_];
  513.             calculateCandidates = true;
  514.          }
  515.          else if(_loc3_ is InteractiveObject && focusableObjects[_loc3_] == true)
  516.          {
  517.             _loc4_ = _loc3_ as InteractiveObject;
  518.             if(_loc4_)
  519.             {
  520.                if(_loc4_ == lastFocus)
  521.                {
  522.                   lastFocus = null;
  523.                }
  524.                delete focusableObjects[_loc4_];
  525.                calculateCandidates = true;
  526.             }
  527.             _loc3_.addEventListener(Event.TAB_ENABLED_CHANGE,tabEnabledChangeHandler);
  528.          }
  529.          removeFocusables(_loc3_);
  530.       }
  531.       
  532.       private function sortByDepth(param1:InteractiveObject, param2:InteractiveObject) : Number
  533.       {
  534.          var _loc5_:int = 0;
  535.          var _loc6_:String = null;
  536.          var _loc7_:String = null;
  537.          var _loc3_:String = "";
  538.          var _loc4_:String = "";
  539.          var _loc8_:String = "0000";
  540.          var _loc9_:DisplayObject = DisplayObject(param1);
  541.          var _loc10_:DisplayObject = DisplayObject(param2);
  542.          while(_loc9_ != DisplayObject(form) && Boolean(_loc9_.parent))
  543.          {
  544.             _loc5_ = getChildIndex(_loc9_.parent,_loc9_);
  545.             _loc6_ = _loc5_.toString(16);
  546.             if(_loc6_.length < 4)
  547.             {
  548.                _loc7_ = _loc8_.substring(0,4 - _loc6_.length) + _loc6_;
  549.             }
  550.             _loc3_ = _loc7_ + _loc3_;
  551.             _loc9_ = _loc9_.parent;
  552.          }
  553.          while(_loc10_ != DisplayObject(form) && Boolean(_loc10_.parent))
  554.          {
  555.             _loc5_ = getChildIndex(_loc10_.parent,_loc10_);
  556.             _loc6_ = _loc5_.toString(16);
  557.             if(_loc6_.length < 4)
  558.             {
  559.                _loc7_ = _loc8_.substring(0,4 - _loc6_.length) + _loc6_;
  560.             }
  561.             _loc4_ = _loc7_ + _loc4_;
  562.             _loc10_ = _loc10_.parent;
  563.          }
  564.          return _loc3_ > _loc4_ ? 1 : (_loc3_ < _loc4_ ? -1 : 0);
  565.       }
  566.       
  567.       public function get defaultButton() : Button
  568.       {
  569.          return _defaultButton;
  570.       }
  571.       
  572.       private function activateHandler(param1:Event) : void
  573.       {
  574.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  575.          if(lastFocus)
  576.          {
  577.             if(lastFocus is IFocusManagerComponent)
  578.             {
  579.                IFocusManagerComponent(lastFocus).setFocus();
  580.             }
  581.             else
  582.             {
  583.                form.stage.focus = lastFocus;
  584.             }
  585.          }
  586.          lastAction = "ACTIVATE";
  587.       }
  588.       
  589.       public function showFocus() : void
  590.       {
  591.       }
  592.       
  593.       public function set defaultButtonEnabled(param1:Boolean) : void
  594.       {
  595.          _defaultButtonEnabled = param1;
  596.       }
  597.       
  598.       public function getNextFocusManagerComponent(param1:Boolean = false) : InteractiveObject
  599.       {
  600.          var _loc8_:IFocusManagerGroup = null;
  601.          if(!hasFocusableObjects())
  602.          {
  603.             return null;
  604.          }
  605.          if(calculateCandidates)
  606.          {
  607.             sortFocusableObjects();
  608.             calculateCandidates = false;
  609.          }
  610.          var _loc2_:DisplayObject = form.stage.focus;
  611.          _loc2_ = DisplayObject(findFocusManagerComponent(InteractiveObject(_loc2_)));
  612.          var _loc3_:String = "";
  613.          if(_loc2_ is IFocusManagerGroup)
  614.          {
  615.             _loc8_ = IFocusManagerGroup(_loc2_);
  616.             _loc3_ = _loc8_.groupName;
  617.          }
  618.          var _loc4_:int = getIndexOfFocusedObject(_loc2_);
  619.          var _loc5_:Boolean = false;
  620.          var _loc6_:int = _loc4_;
  621.          if(_loc4_ == -1)
  622.          {
  623.             if(param1)
  624.             {
  625.                _loc4_ = int(focusableCandidates.length);
  626.             }
  627.             _loc5_ = true;
  628.          }
  629.          var _loc7_:int = getIndexOfNextObject(_loc4_,param1,_loc5_,_loc3_);
  630.          return findFocusManagerComponent(focusableCandidates[_loc7_]);
  631.       }
  632.       
  633.       private function mouseDownHandler(param1:MouseEvent) : void
  634.       {
  635.          if(param1.isDefaultPrevented())
  636.          {
  637.             return;
  638.          }
  639.          var _loc2_:InteractiveObject = getTopLevelFocusTarget(InteractiveObject(param1.target));
  640.          if(!_loc2_)
  641.          {
  642.             return;
  643.          }
  644.          showFocusIndicator = false;
  645.          if((_loc2_ != lastFocus || lastAction == "ACTIVATE") && !(_loc2_ is TextField))
  646.          {
  647.             setFocus(_loc2_);
  648.          }
  649.          lastAction = "MOUSEDOWN";
  650.       }
  651.       
  652.       private function isTabVisible(param1:DisplayObject) : Boolean
  653.       {
  654.          var _loc2_:DisplayObjectContainer = param1.parent;
  655.          while(_loc2_ && !(_loc2_ is Stage) && !(_loc2_.parent && _loc2_.parent is Stage))
  656.          {
  657.             if(!_loc2_.tabChildren)
  658.             {
  659.                return false;
  660.             }
  661.             _loc2_ = _loc2_.parent;
  662.          }
  663.          return true;
  664.       }
  665.       
  666.       public function get nextTabIndex() : int
  667.       {
  668.          return 0;
  669.       }
  670.       
  671.       private function keyDownHandler(param1:KeyboardEvent) : void
  672.       {
  673.          if(param1.keyCode == Keyboard.TAB)
  674.          {
  675.             lastAction = "KEY";
  676.             if(calculateCandidates)
  677.             {
  678.                sortFocusableObjects();
  679.                calculateCandidates = false;
  680.             }
  681.          }
  682.          if(defaultButtonEnabled && param1.keyCode == Keyboard.ENTER && defaultButton && defButton.enabled)
  683.          {
  684.             sendDefaultButtonEvent();
  685.          }
  686.       }
  687.       
  688.       private function focusInHandler(param1:FocusEvent) : void
  689.       {
  690.          var _loc3_:Button = null;
  691.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  692.          if(form.contains(_loc2_))
  693.          {
  694.             lastFocus = findFocusManagerComponent(InteractiveObject(_loc2_));
  695.             if(lastFocus is Button)
  696.             {
  697.                _loc3_ = Button(lastFocus);
  698.                if(defButton)
  699.                {
  700.                   defButton.emphasized = false;
  701.                   defButton = _loc3_;
  702.                   _loc3_.emphasized = true;
  703.                }
  704.             }
  705.             else if(Boolean(defButton) && defButton != _defaultButton)
  706.             {
  707.                defButton.emphasized = false;
  708.                defButton = _defaultButton;
  709.                _defaultButton.emphasized = true;
  710.             }
  711.          }
  712.       }
  713.       
  714.       private function tabEnabledChangeHandler(param1:Event) : void
  715.       {
  716.          calculateCandidates = true;
  717.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  718.          var _loc3_:* = focusableObjects[_loc2_] == true;
  719.          if(_loc2_.tabEnabled)
  720.          {
  721.             if(!_loc3_ && isTabVisible(_loc2_))
  722.             {
  723.                if(!(_loc2_ is IFocusManagerComponent))
  724.                {
  725.                   _loc2_.focusRect = false;
  726.                }
  727.                focusableObjects[_loc2_] = true;
  728.             }
  729.          }
  730.          else if(_loc3_)
  731.          {
  732.             delete focusableObjects[_loc2_];
  733.          }
  734.       }
  735.       
  736.       public function set showFocusIndicator(param1:Boolean) : void
  737.       {
  738.          _showFocusIndicator = param1;
  739.       }
  740.       
  741.       public function get form() : DisplayObjectContainer
  742.       {
  743.          return _form;
  744.       }
  745.       
  746.       private function sortByTabIndex(param1:InteractiveObject, param2:InteractiveObject) : int
  747.       {
  748.          return param1.tabIndex > param2.tabIndex ? 1 : (param1.tabIndex < param2.tabIndex ? -1 : int(sortByDepth(param1,param2)));
  749.       }
  750.       
  751.       public function get defaultButtonEnabled() : Boolean
  752.       {
  753.          return _defaultButtonEnabled;
  754.       }
  755.       
  756.       public function activate() : void
  757.       {
  758.          if(activated)
  759.          {
  760.             return;
  761.          }
  762.          form.stage.addEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,mouseFocusChangeHandler,false,0,true);
  763.          form.stage.addEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler,false,0,true);
  764.          form.addEventListener(FocusEvent.FOCUS_IN,focusInHandler,true);
  765.          form.addEventListener(FocusEvent.FOCUS_OUT,focusOutHandler,true);
  766.          form.stage.addEventListener(Event.ACTIVATE,activateHandler,false,0,true);
  767.          form.stage.addEventListener(Event.DEACTIVATE,deactivateHandler,false,0,true);
  768.          form.addEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  769.          form.addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler,true);
  770.          activated = true;
  771.          if(lastFocus)
  772.          {
  773.             setFocus(lastFocus);
  774.          }
  775.       }
  776.       
  777.       public function deactivate() : void
  778.       {
  779.          form.stage.removeEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,mouseFocusChangeHandler);
  780.          form.stage.removeEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler);
  781.          form.removeEventListener(FocusEvent.FOCUS_IN,focusInHandler,true);
  782.          form.removeEventListener(FocusEvent.FOCUS_OUT,focusOutHandler,true);
  783.          form.stage.removeEventListener(Event.ACTIVATE,activateHandler);
  784.          form.stage.removeEventListener(Event.DEACTIVATE,deactivateHandler);
  785.          form.removeEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  786.          form.removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler,true);
  787.          activated = false;
  788.       }
  789.    }
  790. }
  791.  
  792.