home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / managers / ToolTipManagerImpl.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  24.4 KB  |  746 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.EventDispatcher;
  6.    import flash.events.IEventDispatcher;
  7.    import flash.events.MouseEvent;
  8.    import flash.events.TimerEvent;
  9.    import flash.geom.Point;
  10.    import flash.geom.Rectangle;
  11.    import flash.utils.Timer;
  12.    import mx.controls.ToolTip;
  13.    import mx.core.ApplicationGlobals;
  14.    import mx.core.IInvalidating;
  15.    import mx.core.IToolTip;
  16.    import mx.core.IUIComponent;
  17.    import mx.core.mx_internal;
  18.    import mx.effects.EffectManager;
  19.    import mx.effects.IAbstractEffect;
  20.    import mx.events.EffectEvent;
  21.    import mx.events.InterManagerRequest;
  22.    import mx.events.ToolTipEvent;
  23.    import mx.styles.IStyleClient;
  24.    import mx.validators.IValidatorListener;
  25.    
  26.    use namespace mx_internal;
  27.    
  28.    public class ToolTipManagerImpl extends EventDispatcher implements IToolTipManager2
  29.    {
  30.       private static var instance:IToolTipManager2;
  31.       
  32.       mx_internal static const VERSION:String = "3.5.0.12683";
  33.       
  34.       private var _enabled:Boolean = true;
  35.       
  36.       private var _showDelay:Number = 500;
  37.       
  38.       private var _hideEffect:IAbstractEffect;
  39.       
  40.       mx_internal var hideTimer:Timer;
  41.       
  42.       private var _scrubDelay:Number = 100;
  43.       
  44.       private var _toolTipClass:Class = ToolTip;
  45.       
  46.       mx_internal var showTimer:Timer;
  47.       
  48.       private var sandboxRoot:IEventDispatcher = null;
  49.       
  50.       mx_internal var currentText:String;
  51.       
  52.       private var _currentToolTip:DisplayObject;
  53.       
  54.       mx_internal var scrubTimer:Timer;
  55.       
  56.       mx_internal var previousTarget:DisplayObject;
  57.       
  58.       private var _currentTarget:DisplayObject;
  59.       
  60.       private var systemManager:ISystemManager = null;
  61.       
  62.       private var _showEffect:IAbstractEffect;
  63.       
  64.       private var _hideDelay:Number = 10000;
  65.       
  66.       mx_internal var initialized:Boolean = false;
  67.       
  68.       mx_internal var isError:Boolean;
  69.       
  70.       public function ToolTipManagerImpl()
  71.       {
  72.          super();
  73.          if(instance)
  74.          {
  75.             throw new Error("Instance already exists.");
  76.          }
  77.          this.systemManager = SystemManagerGlobals.topLevelSystemManagers[0] as ISystemManager;
  78.          sandboxRoot = this.systemManager.getSandboxRoot();
  79.          sandboxRoot.addEventListener(InterManagerRequest.TOOLTIP_MANAGER_REQUEST,marshalToolTipManagerHandler,false,0,true);
  80.          var _loc1_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  81.          _loc1_.name = "update";
  82.          sandboxRoot.dispatchEvent(_loc1_);
  83.       }
  84.       
  85.       public static function getInstance() : IToolTipManager2
  86.       {
  87.          if(!instance)
  88.          {
  89.             instance = new ToolTipManagerImpl();
  90.          }
  91.          return instance;
  92.       }
  93.       
  94.       mx_internal function systemManager_mouseDownHandler(param1:MouseEvent) : void
  95.       {
  96.          mx_internal::reset();
  97.       }
  98.       
  99.       public function set showDelay(param1:Number) : void
  100.       {
  101.          _showDelay = param1;
  102.       }
  103.       
  104.       mx_internal function showTimer_timerHandler(param1:TimerEvent) : void
  105.       {
  106.          if(currentTarget)
  107.          {
  108.             mx_internal::createTip();
  109.             mx_internal::initializeTip();
  110.             mx_internal::positionTip();
  111.             mx_internal::showTip();
  112.          }
  113.       }
  114.       
  115.       mx_internal function hideEffectEnded() : void
  116.       {
  117.          var _loc1_:ToolTipEvent = null;
  118.          mx_internal::reset();
  119.          if(mx_internal::previousTarget)
  120.          {
  121.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_END);
  122.             _loc1_.toolTip = currentToolTip;
  123.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  124.          }
  125.       }
  126.       
  127.       public function set scrubDelay(param1:Number) : void
  128.       {
  129.          _scrubDelay = param1;
  130.       }
  131.       
  132.       public function get currentToolTip() : IToolTip
  133.       {
  134.          return _currentToolTip as IToolTip;
  135.       }
  136.       
  137.       private function mouseIsOver(param1:DisplayObject) : Boolean
  138.       {
  139.          if(!param1 || !param1.stage)
  140.          {
  141.             return false;
  142.          }
  143.          if(param1.stage.mouseX == 0 && param1.stage.mouseY == 0)
  144.          {
  145.             return false;
  146.          }
  147.          return param1.hitTestPoint(param1.stage.mouseX,param1.stage.mouseY,true);
  148.       }
  149.       
  150.       mx_internal function toolTipMouseOutHandler(param1:MouseEvent) : void
  151.       {
  152.          mx_internal::checkIfTargetChanged(param1.relatedObject);
  153.       }
  154.       
  155.       public function get enabled() : Boolean
  156.       {
  157.          return _enabled;
  158.       }
  159.       
  160.       public function createToolTip(param1:String, param2:Number, param3:Number, param4:String = null, param5:IUIComponent = null) : IToolTip
  161.       {
  162.          var _loc6_:ToolTip = new ToolTip();
  163.          var _loc7_:ISystemManager = !!param5 ? param5.systemManager as ISystemManager : ApplicationGlobals.application.systemManager as ISystemManager;
  164.          _loc7_.topLevelSystemManager.addChildToSandboxRoot("toolTipChildren",_loc6_ as DisplayObject);
  165.          if(param4)
  166.          {
  167.             _loc6_.setStyle("styleName","errorTip");
  168.             _loc6_.setStyle("borderStyle",param4);
  169.          }
  170.          _loc6_.text = param1;
  171.          sizeTip(_loc6_);
  172.          _loc6_.move(param2,param3);
  173.          return _loc6_ as IToolTip;
  174.       }
  175.       
  176.       mx_internal function reset() : void
  177.       {
  178.          var _loc1_:ISystemManager = null;
  179.          mx_internal::showTimer.reset();
  180.          mx_internal::hideTimer.reset();
  181.          if(currentToolTip)
  182.          {
  183.             if(Boolean(showEffect) || Boolean(hideEffect))
  184.             {
  185.                currentToolTip.removeEventListener(EffectEvent.EFFECT_END,mx_internal::effectEndHandler);
  186.             }
  187.             EffectManager.endEffectsForTarget(currentToolTip);
  188.             _loc1_ = currentToolTip.systemManager as ISystemManager;
  189.             _loc1_.topLevelSystemManager.removeChildFromSandboxRoot("toolTipChildren",currentToolTip as DisplayObject);
  190.             currentToolTip = null;
  191.             mx_internal::scrubTimer.delay = scrubDelay;
  192.             mx_internal::scrubTimer.reset();
  193.             if(scrubDelay > 0)
  194.             {
  195.                mx_internal::scrubTimer.delay = scrubDelay;
  196.                mx_internal::scrubTimer.start();
  197.             }
  198.          }
  199.       }
  200.       
  201.       public function set currentToolTip(param1:IToolTip) : void
  202.       {
  203.          _currentToolTip = param1 as DisplayObject;
  204.          var _loc2_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  205.          _loc2_.name = "currentToolTip";
  206.          _loc2_.value = param1;
  207.          sandboxRoot.dispatchEvent(_loc2_);
  208.       }
  209.       
  210.       public function get toolTipClass() : Class
  211.       {
  212.          return _toolTipClass;
  213.       }
  214.       
  215.       private function hideImmediately(param1:DisplayObject) : void
  216.       {
  217.          mx_internal::checkIfTargetChanged(null);
  218.       }
  219.       
  220.       mx_internal function showTip() : void
  221.       {
  222.          var _loc2_:ISystemManager = null;
  223.          var _loc1_:ToolTipEvent = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOW);
  224.          _loc1_.toolTip = currentToolTip;
  225.          currentTarget.dispatchEvent(_loc1_);
  226.          if(mx_internal::isError)
  227.          {
  228.             currentTarget.addEventListener("change",mx_internal::changeHandler);
  229.          }
  230.          else
  231.          {
  232.             _loc2_ = getSystemManager(currentTarget);
  233.             _loc2_.addEventListener(MouseEvent.MOUSE_DOWN,mx_internal::systemManager_mouseDownHandler);
  234.          }
  235.          currentToolTip.visible = true;
  236.          if(!showEffect)
  237.          {
  238.             mx_internal::showEffectEnded();
  239.          }
  240.       }
  241.       
  242.       mx_internal function effectEndHandler(param1:EffectEvent) : void
  243.       {
  244.          if(param1.effectInstance.effect == showEffect)
  245.          {
  246.             mx_internal::showEffectEnded();
  247.          }
  248.          else if(param1.effectInstance.effect == hideEffect)
  249.          {
  250.             mx_internal::hideEffectEnded();
  251.          }
  252.       }
  253.       
  254.       public function get hideDelay() : Number
  255.       {
  256.          return _hideDelay;
  257.       }
  258.       
  259.       public function get currentTarget() : DisplayObject
  260.       {
  261.          return _currentTarget;
  262.       }
  263.       
  264.       mx_internal function showEffectEnded() : void
  265.       {
  266.          var _loc1_:ToolTipEvent = null;
  267.          if(hideDelay == 0)
  268.          {
  269.             mx_internal::hideTip();
  270.          }
  271.          else if(hideDelay < Infinity)
  272.          {
  273.             mx_internal::hideTimer.delay = hideDelay;
  274.             mx_internal::hideTimer.start();
  275.          }
  276.          if(currentTarget)
  277.          {
  278.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOWN);
  279.             _loc1_.toolTip = currentToolTip;
  280.             currentTarget.dispatchEvent(_loc1_);
  281.          }
  282.       }
  283.       
  284.       public function get hideEffect() : IAbstractEffect
  285.       {
  286.          return _hideEffect;
  287.       }
  288.       
  289.       mx_internal function changeHandler(param1:Event) : void
  290.       {
  291.          mx_internal::reset();
  292.       }
  293.       
  294.       public function set enabled(param1:Boolean) : void
  295.       {
  296.          _enabled = param1;
  297.       }
  298.       
  299.       mx_internal function errorTipMouseOverHandler(param1:MouseEvent) : void
  300.       {
  301.          mx_internal::checkIfTargetChanged(DisplayObject(param1.target));
  302.       }
  303.       
  304.       public function get showDelay() : Number
  305.       {
  306.          return _showDelay;
  307.       }
  308.       
  309.       public function get scrubDelay() : Number
  310.       {
  311.          return _scrubDelay;
  312.       }
  313.       
  314.       public function registerErrorString(param1:DisplayObject, param2:String, param3:String) : void
  315.       {
  316.          if(!param2 && Boolean(param3))
  317.          {
  318.             param1.addEventListener(MouseEvent.MOUSE_OVER,mx_internal::errorTipMouseOverHandler);
  319.             param1.addEventListener(MouseEvent.MOUSE_OUT,mx_internal::errorTipMouseOutHandler);
  320.             if(mouseIsOver(param1))
  321.             {
  322.                showImmediately(param1);
  323.             }
  324.          }
  325.          else if(Boolean(param2) && !param3)
  326.          {
  327.             param1.removeEventListener(MouseEvent.MOUSE_OVER,mx_internal::errorTipMouseOverHandler);
  328.             param1.removeEventListener(MouseEvent.MOUSE_OUT,mx_internal::errorTipMouseOutHandler);
  329.             if(mouseIsOver(param1))
  330.             {
  331.                hideImmediately(param1);
  332.             }
  333.          }
  334.       }
  335.       
  336.       mx_internal function initialize() : void
  337.       {
  338.          if(!mx_internal::showTimer)
  339.          {
  340.             mx_internal::showTimer = new Timer(0,1);
  341.             mx_internal::showTimer.addEventListener(TimerEvent.TIMER,mx_internal::showTimer_timerHandler);
  342.          }
  343.          if(!mx_internal::hideTimer)
  344.          {
  345.             mx_internal::hideTimer = new Timer(0,1);
  346.             mx_internal::hideTimer.addEventListener(TimerEvent.TIMER,mx_internal::hideTimer_timerHandler);
  347.          }
  348.          if(!mx_internal::scrubTimer)
  349.          {
  350.             mx_internal::scrubTimer = new Timer(0,1);
  351.          }
  352.          mx_internal::initialized = true;
  353.       }
  354.       
  355.       public function destroyToolTip(param1:IToolTip) : void
  356.       {
  357.          var _loc2_:ISystemManager = param1.systemManager as ISystemManager;
  358.          _loc2_.topLevelSystemManager.removeChildFromSandboxRoot("toolTipChildren",DisplayObject(param1));
  359.       }
  360.       
  361.       mx_internal function checkIfTargetChanged(param1:DisplayObject) : void
  362.       {
  363.          if(!enabled)
  364.          {
  365.             return;
  366.          }
  367.          mx_internal::findTarget(param1);
  368.          if(currentTarget != mx_internal::previousTarget)
  369.          {
  370.             mx_internal::targetChanged();
  371.             mx_internal::previousTarget = currentTarget;
  372.          }
  373.       }
  374.       
  375.       private function marshalToolTipManagerHandler(param1:Event) : void
  376.       {
  377.          var _loc2_:InterManagerRequest = null;
  378.          if(param1 is InterManagerRequest)
  379.          {
  380.             return;
  381.          }
  382.          var _loc3_:Object = param1;
  383.          switch(_loc3_.name)
  384.          {
  385.             case "currentToolTip":
  386.                _currentToolTip = _loc3_.value;
  387.                break;
  388.             case ToolTipEvent.TOOL_TIP_HIDE:
  389.                if(_currentToolTip is IToolTip)
  390.                {
  391.                   mx_internal::hideTip();
  392.                }
  393.                break;
  394.             case "update":
  395.                param1.stopImmediatePropagation();
  396.                _loc2_ = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  397.                _loc2_.name = "currentToolTip";
  398.                _loc2_.value = _currentToolTip;
  399.                sandboxRoot.dispatchEvent(_loc2_);
  400.          }
  401.       }
  402.       
  403.       public function set toolTipClass(param1:Class) : void
  404.       {
  405.          _toolTipClass = param1;
  406.       }
  407.       
  408.       private function getGlobalBounds(param1:DisplayObject, param2:DisplayObject) : Rectangle
  409.       {
  410.          var _loc3_:Point = new Point(0,0);
  411.          _loc3_ = param1.localToGlobal(_loc3_);
  412.          _loc3_ = param2.globalToLocal(_loc3_);
  413.          return new Rectangle(_loc3_.x,_loc3_.y,param1.width,param1.height);
  414.       }
  415.       
  416.       mx_internal function positionTip() : void
  417.       {
  418.          var _loc1_:Number = NaN;
  419.          var _loc2_:Number = NaN;
  420.          var _loc5_:Rectangle = null;
  421.          var _loc6_:Number = NaN;
  422.          var _loc7_:Number = NaN;
  423.          var _loc8_:ISystemManager = null;
  424.          var _loc9_:Number = NaN;
  425.          var _loc10_:Number = NaN;
  426.          var _loc11_:Point = null;
  427.          var _loc3_:Number = currentToolTip.screen.width;
  428.          var _loc4_:Number = currentToolTip.screen.height;
  429.          if(mx_internal::isError)
  430.          {
  431.             _loc5_ = getGlobalBounds(currentTarget,currentToolTip.root);
  432.             _loc1_ = _loc5_.right + 4;
  433.             _loc2_ = _loc5_.top - 1;
  434.             if(_loc1_ + currentToolTip.width > _loc3_)
  435.             {
  436.                _loc6_ = NaN;
  437.                _loc7_ = NaN;
  438.                _loc1_ = _loc5_.left - 2;
  439.                if(_loc1_ + currentToolTip.width + 4 > _loc3_)
  440.                {
  441.                   _loc6_ = _loc3_ - _loc1_ - 4;
  442.                   _loc7_ = Number(Object(toolTipClass).maxWidth);
  443.                   Object(toolTipClass).maxWidth = _loc6_;
  444.                   if(currentToolTip is IStyleClient)
  445.                   {
  446.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  447.                   }
  448.                   currentToolTip["text"] = currentToolTip["text"];
  449.                }
  450.                else
  451.                {
  452.                   if(currentToolTip is IStyleClient)
  453.                   {
  454.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  455.                   }
  456.                   currentToolTip["text"] = currentToolTip["text"];
  457.                }
  458.                if(currentToolTip.height + 2 < _loc5_.top)
  459.                {
  460.                   _loc2_ = _loc5_.top - (currentToolTip.height + 2);
  461.                }
  462.                else
  463.                {
  464.                   _loc2_ = _loc5_.bottom + 2;
  465.                   if(!isNaN(_loc6_))
  466.                   {
  467.                      Object(toolTipClass).maxWidth = _loc6_;
  468.                   }
  469.                   if(currentToolTip is IStyleClient)
  470.                   {
  471.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipBelow");
  472.                   }
  473.                   currentToolTip["text"] = currentToolTip["text"];
  474.                }
  475.             }
  476.             sizeTip(currentToolTip);
  477.             if(!isNaN(_loc7_))
  478.             {
  479.                Object(toolTipClass).maxWidth = _loc7_;
  480.             }
  481.          }
  482.          else
  483.          {
  484.             _loc8_ = getSystemManager(currentTarget);
  485.             _loc1_ = DisplayObject(_loc8_).mouseX + 11;
  486.             _loc2_ = DisplayObject(_loc8_).mouseY + 22;
  487.             _loc9_ = Number(currentToolTip.width);
  488.             if(_loc1_ + _loc9_ > _loc3_)
  489.             {
  490.                _loc1_ = _loc3_ - _loc9_;
  491.             }
  492.             _loc10_ = Number(currentToolTip.height);
  493.             if(_loc2_ + _loc10_ > _loc4_)
  494.             {
  495.                _loc2_ = _loc4_ - _loc10_;
  496.             }
  497.             _loc11_ = new Point(_loc1_,_loc2_);
  498.             _loc11_ = DisplayObject(_loc8_).localToGlobal(_loc11_);
  499.             _loc11_ = DisplayObject(sandboxRoot).globalToLocal(_loc11_);
  500.             _loc1_ = _loc11_.x;
  501.             _loc2_ = _loc11_.y;
  502.          }
  503.          currentToolTip.move(_loc1_,_loc2_);
  504.       }
  505.       
  506.       mx_internal function errorTipMouseOutHandler(param1:MouseEvent) : void
  507.       {
  508.          mx_internal::checkIfTargetChanged(param1.relatedObject);
  509.       }
  510.       
  511.       mx_internal function findTarget(param1:DisplayObject) : void
  512.       {
  513.          while(param1)
  514.          {
  515.             if(param1 is IValidatorListener)
  516.             {
  517.                mx_internal::currentText = IValidatorListener(param1).errorString;
  518.                if(mx_internal::currentText != null && mx_internal::currentText != "")
  519.                {
  520.                   currentTarget = param1;
  521.                   mx_internal::isError = true;
  522.                   return;
  523.                }
  524.             }
  525.             if(param1 is IToolTipManagerClient)
  526.             {
  527.                mx_internal::currentText = IToolTipManagerClient(param1).toolTip;
  528.                if(mx_internal::currentText != null)
  529.                {
  530.                   currentTarget = param1;
  531.                   mx_internal::isError = false;
  532.                   return;
  533.                }
  534.             }
  535.             param1 = param1.parent;
  536.          }
  537.          mx_internal::currentText = null;
  538.          currentTarget = null;
  539.       }
  540.       
  541.       public function registerToolTip(param1:DisplayObject, param2:String, param3:String) : void
  542.       {
  543.          if(!param2 && Boolean(param3))
  544.          {
  545.             param1.addEventListener(MouseEvent.MOUSE_OVER,mx_internal::toolTipMouseOverHandler);
  546.             param1.addEventListener(MouseEvent.MOUSE_OUT,mx_internal::toolTipMouseOutHandler);
  547.             if(mouseIsOver(param1))
  548.             {
  549.                showImmediately(param1);
  550.             }
  551.          }
  552.          else if(Boolean(param2) && !param3)
  553.          {
  554.             param1.removeEventListener(MouseEvent.MOUSE_OVER,mx_internal::toolTipMouseOverHandler);
  555.             param1.removeEventListener(MouseEvent.MOUSE_OUT,mx_internal::toolTipMouseOutHandler);
  556.             if(mouseIsOver(param1))
  557.             {
  558.                hideImmediately(param1);
  559.             }
  560.          }
  561.       }
  562.       
  563.       private function showImmediately(param1:DisplayObject) : void
  564.       {
  565.          var _loc2_:Number = ToolTipManager.showDelay;
  566.          ToolTipManager.showDelay = 0;
  567.          mx_internal::checkIfTargetChanged(param1);
  568.          ToolTipManager.showDelay = _loc2_;
  569.       }
  570.       
  571.       public function set hideDelay(param1:Number) : void
  572.       {
  573.          _hideDelay = param1;
  574.       }
  575.       
  576.       private function getSystemManager(param1:DisplayObject) : ISystemManager
  577.       {
  578.          return param1 is IUIComponent ? IUIComponent(param1).systemManager : null;
  579.       }
  580.       
  581.       public function set currentTarget(param1:DisplayObject) : void
  582.       {
  583.          _currentTarget = param1;
  584.       }
  585.       
  586.       public function sizeTip(param1:IToolTip) : void
  587.       {
  588.          if(param1 is IInvalidating)
  589.          {
  590.             IInvalidating(param1).validateNow();
  591.          }
  592.          param1.setActualSize(param1.getExplicitOrMeasuredWidth(),param1.getExplicitOrMeasuredHeight());
  593.       }
  594.       
  595.       public function set showEffect(param1:IAbstractEffect) : void
  596.       {
  597.          _showEffect = param1 as IAbstractEffect;
  598.       }
  599.       
  600.       mx_internal function targetChanged() : void
  601.       {
  602.          var _loc1_:ToolTipEvent = null;
  603.          var _loc2_:InterManagerRequest = null;
  604.          if(!mx_internal::initialized)
  605.          {
  606.             mx_internal::initialize();
  607.          }
  608.          if(Boolean(mx_internal::previousTarget) && Boolean(currentToolTip))
  609.          {
  610.             if(currentToolTip is IToolTip)
  611.             {
  612.                _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  613.                _loc1_.toolTip = currentToolTip;
  614.                mx_internal::previousTarget.dispatchEvent(_loc1_);
  615.             }
  616.             else
  617.             {
  618.                _loc2_ = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  619.                _loc2_.name = ToolTipEvent.TOOL_TIP_HIDE;
  620.                sandboxRoot.dispatchEvent(_loc2_);
  621.             }
  622.          }
  623.          mx_internal::reset();
  624.          if(currentTarget)
  625.          {
  626.             if(mx_internal::currentText == "")
  627.             {
  628.                return;
  629.             }
  630.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_START);
  631.             currentTarget.dispatchEvent(_loc1_);
  632.             if(showDelay == 0 || mx_internal::scrubTimer.running)
  633.             {
  634.                mx_internal::createTip();
  635.                mx_internal::initializeTip();
  636.                mx_internal::positionTip();
  637.                mx_internal::showTip();
  638.             }
  639.             else
  640.             {
  641.                mx_internal::showTimer.delay = showDelay;
  642.                mx_internal::showTimer.start();
  643.             }
  644.          }
  645.       }
  646.       
  647.       public function set hideEffect(param1:IAbstractEffect) : void
  648.       {
  649.          _hideEffect = param1 as IAbstractEffect;
  650.       }
  651.       
  652.       mx_internal function hideTimer_timerHandler(param1:TimerEvent) : void
  653.       {
  654.          mx_internal::hideTip();
  655.       }
  656.       
  657.       mx_internal function initializeTip() : void
  658.       {
  659.          if(currentToolTip is IToolTip)
  660.          {
  661.             IToolTip(currentToolTip).text = mx_internal::currentText;
  662.          }
  663.          if(mx_internal::isError && currentToolTip is IStyleClient)
  664.          {
  665.             IStyleClient(currentToolTip).setStyle("styleName","errorTip");
  666.          }
  667.          sizeTip(currentToolTip);
  668.          if(currentToolTip is IStyleClient)
  669.          {
  670.             if(showEffect)
  671.             {
  672.                IStyleClient(currentToolTip).setStyle("showEffect",showEffect);
  673.             }
  674.             if(hideEffect)
  675.             {
  676.                IStyleClient(currentToolTip).setStyle("hideEffect",hideEffect);
  677.             }
  678.          }
  679.          if(Boolean(showEffect) || Boolean(hideEffect))
  680.          {
  681.             currentToolTip.addEventListener(EffectEvent.EFFECT_END,mx_internal::effectEndHandler);
  682.          }
  683.       }
  684.       
  685.       public function get showEffect() : IAbstractEffect
  686.       {
  687.          return _showEffect;
  688.       }
  689.       
  690.       mx_internal function toolTipMouseOverHandler(param1:MouseEvent) : void
  691.       {
  692.          mx_internal::checkIfTargetChanged(DisplayObject(param1.target));
  693.       }
  694.       
  695.       mx_internal function hideTip() : void
  696.       {
  697.          var _loc1_:ToolTipEvent = null;
  698.          var _loc2_:ISystemManager = null;
  699.          if(mx_internal::previousTarget)
  700.          {
  701.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  702.             _loc1_.toolTip = currentToolTip;
  703.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  704.          }
  705.          if(currentToolTip)
  706.          {
  707.             currentToolTip.visible = false;
  708.          }
  709.          if(mx_internal::isError)
  710.          {
  711.             if(currentTarget)
  712.             {
  713.                currentTarget.removeEventListener("change",mx_internal::changeHandler);
  714.             }
  715.          }
  716.          else if(mx_internal::previousTarget)
  717.          {
  718.             _loc2_ = getSystemManager(mx_internal::previousTarget);
  719.             _loc2_.removeEventListener(MouseEvent.MOUSE_DOWN,mx_internal::systemManager_mouseDownHandler);
  720.          }
  721.          if(!hideEffect)
  722.          {
  723.             mx_internal::hideEffectEnded();
  724.          }
  725.       }
  726.       
  727.       mx_internal function createTip() : void
  728.       {
  729.          var _loc1_:ToolTipEvent = new ToolTipEvent(ToolTipEvent.TOOL_TIP_CREATE);
  730.          currentTarget.dispatchEvent(_loc1_);
  731.          if(_loc1_.toolTip)
  732.          {
  733.             currentToolTip = _loc1_.toolTip;
  734.          }
  735.          else
  736.          {
  737.             currentToolTip = new toolTipClass();
  738.          }
  739.          currentToolTip.visible = false;
  740.          var _loc2_:ISystemManager = getSystemManager(currentTarget) as ISystemManager;
  741.          _loc2_.topLevelSystemManager.addChildToSandboxRoot("toolTipChildren",currentToolTip as DisplayObject);
  742.       }
  743.    }
  744. }
  745.  
  746.