home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / effects / effectClasses / ZoomInstance.as < prev   
Encoding:
Text File  |  2008-09-02  |  10.0 KB  |  324 lines
  1. package mx.effects.effectClasses
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.MouseEvent;
  5.    import mx.core.mx_internal;
  6.    import mx.effects.EffectManager;
  7.    import mx.events.FlexEvent;
  8.    
  9.    use namespace mx_internal;
  10.    
  11.    public class ZoomInstance extends TweenEffectInstance
  12.    {
  13.       
  14.       mx_internal static const VERSION:String = "2.0.1.0";
  15.        
  16.       
  17.       private var show:Boolean = true;
  18.       
  19.       private var origPercentHeight:Number;
  20.       
  21.       public var zoomWidthFrom:Number;
  22.       
  23.       private var origX:Number;
  24.       
  25.       private var origY:Number;
  26.       
  27.       private var scaledOriginY:Number;
  28.       
  29.       private var scaledOriginX:Number;
  30.       
  31.       private var origPercentWidth:Number;
  32.       
  33.       public var zoomWidthTo:Number;
  34.       
  35.       public var zoomHeightFrom:Number;
  36.       
  37.       private var newX:Number;
  38.       
  39.       private var newY:Number;
  40.       
  41.       public var captureRollEvents:Boolean;
  42.       
  43.       private var origScaleX:Number;
  44.       
  45.       private var origScaleY:Number;
  46.       
  47.       public var originX:Number;
  48.       
  49.       public var originY:Number;
  50.       
  51.       public var zoomHeightTo:Number;
  52.       
  53.       private var _mouseHasMoved:Boolean = false;
  54.       
  55.       public function ZoomInstance(param1:Object)
  56.       {
  57.          _mouseHasMoved = false;
  58.          show = true;
  59.          super(param1);
  60.       }
  61.       
  62.       override public function finishEffect() : void
  63.       {
  64.          if(captureRollEvents)
  65.          {
  66.             target.removeEventListener(MouseEvent.ROLL_OVER,mouseEventHandler,false);
  67.             target.removeEventListener(MouseEvent.ROLL_OUT,mouseEventHandler,false);
  68.             target.removeEventListener(MouseEvent.MOUSE_MOVE,mouseEventHandler,false);
  69.          }
  70.          super.finishEffect();
  71.       }
  72.       
  73.       private function getScaleFromWidth(param1:Number) : Number
  74.       {
  75.          return param1 / (target.width / Math.abs(target.scaleX));
  76.       }
  77.       
  78.       private function getScaleFromHeight(param1:Number) : Number
  79.       {
  80.          return param1 / (target.height / Math.abs(target.scaleY));
  81.       }
  82.       
  83.       override public function play() : void
  84.       {
  85.          super.play();
  86.          applyPropertyChanges();
  87.          if(isNaN(zoomWidthFrom) && isNaN(zoomWidthTo) && isNaN(zoomHeightFrom) && isNaN(zoomHeightTo))
  88.          {
  89.             if(show)
  90.             {
  91.                zoomWidthFrom = zoomHeightFrom = 0;
  92.                zoomWidthTo = target.scaleX;
  93.                zoomHeightTo = target.scaleY;
  94.             }
  95.             else
  96.             {
  97.                zoomWidthFrom = target.scaleX;
  98.                zoomHeightFrom = target.scaleY;
  99.                zoomWidthTo = zoomHeightTo = 0;
  100.             }
  101.          }
  102.          else
  103.          {
  104.             if(isNaN(zoomWidthFrom) && isNaN(zoomWidthTo))
  105.             {
  106.                zoomWidthFrom = zoomWidthTo = target.scaleX;
  107.             }
  108.             else if(isNaN(zoomHeightFrom) && isNaN(zoomHeightTo))
  109.             {
  110.                zoomHeightFrom = zoomHeightTo = target.scaleY;
  111.             }
  112.             if(isNaN(zoomWidthFrom))
  113.             {
  114.                zoomWidthFrom = target.scaleX;
  115.             }
  116.             else if(isNaN(zoomWidthTo))
  117.             {
  118.                zoomWidthTo = zoomWidthFrom == 1 ? 0 : 1;
  119.             }
  120.             if(isNaN(zoomHeightFrom))
  121.             {
  122.                zoomHeightFrom = target.scaleY;
  123.             }
  124.             else if(isNaN(zoomHeightTo))
  125.             {
  126.                zoomHeightTo = zoomHeightFrom == 1 ? 0 : 1;
  127.             }
  128.          }
  129.          if(zoomWidthFrom < 0.01)
  130.          {
  131.             zoomWidthFrom = 0.01;
  132.          }
  133.          if(zoomWidthTo < 0.01)
  134.          {
  135.             zoomWidthTo = 0.01;
  136.          }
  137.          if(zoomHeightFrom < 0.01)
  138.          {
  139.             zoomHeightFrom = 0.01;
  140.          }
  141.          if(zoomHeightTo < 0.01)
  142.          {
  143.             zoomHeightTo = 0.01;
  144.          }
  145.          origScaleX = target.scaleX;
  146.          origScaleY = target.scaleY;
  147.          newX = origX = target.x;
  148.          newY = origY = target.y;
  149.          if(isNaN(originX))
  150.          {
  151.             scaledOriginX = target.width / 2;
  152.          }
  153.          else
  154.          {
  155.             scaledOriginX = originX * origScaleX;
  156.          }
  157.          if(isNaN(originY))
  158.          {
  159.             scaledOriginY = target.height / 2;
  160.          }
  161.          else
  162.          {
  163.             scaledOriginY = originY * origScaleY;
  164.          }
  165.          scaledOriginX = Number(scaledOriginX.toFixed(1));
  166.          scaledOriginY = Number(scaledOriginY.toFixed(1));
  167.          origPercentWidth = target.percentWidth;
  168.          if(!isNaN(origPercentWidth))
  169.          {
  170.             target.width = target.width;
  171.          }
  172.          origPercentHeight = target.percentHeight;
  173.          if(!isNaN(origPercentHeight))
  174.          {
  175.             target.height = target.height;
  176.          }
  177.          tween = createTween(this,[zoomWidthFrom,zoomHeightFrom],[zoomWidthTo,zoomHeightTo],duration);
  178.          if(captureRollEvents)
  179.          {
  180.             target.addEventListener(MouseEvent.ROLL_OVER,mouseEventHandler,false);
  181.             target.addEventListener(MouseEvent.ROLL_OUT,mouseEventHandler,false);
  182.             target.addEventListener(MouseEvent.MOUSE_MOVE,mouseEventHandler,false);
  183.          }
  184.       }
  185.       
  186.       override public function onTweenEnd(param1:Object) : void
  187.       {
  188.          var _loc2_:Number = NaN;
  189.          var _loc3_:Number = NaN;
  190.          if(!isNaN(origPercentWidth))
  191.          {
  192.             _loc2_ = Number(target.width);
  193.             target.percentWidth = origPercentWidth;
  194.             if(Boolean(target.parent) && target.parent.autoLayout == false)
  195.             {
  196.                target._width = _loc2_;
  197.             }
  198.          }
  199.          if(!isNaN(origPercentHeight))
  200.          {
  201.             _loc3_ = Number(target.height);
  202.             target.percentHeight = origPercentHeight;
  203.             if(Boolean(target.parent) && target.parent.autoLayout == false)
  204.             {
  205.                target._height = _loc3_;
  206.             }
  207.          }
  208.          super.onTweenEnd(param1);
  209.          if(mx_internal::hideOnEffectEnd)
  210.          {
  211.             EffectManager.suspendEventHandling();
  212.             target.scaleX = origScaleX;
  213.             target.scaleY = origScaleY;
  214.             target.move(origX,origY);
  215.             EffectManager.resumeEventHandling();
  216.          }
  217.       }
  218.       
  219.       private function mouseEventHandler(param1:MouseEvent) : void
  220.       {
  221.          if(param1.type == MouseEvent.MOUSE_MOVE)
  222.          {
  223.             _mouseHasMoved = true;
  224.          }
  225.          else if(param1.type == MouseEvent.ROLL_OUT || param1.type == MouseEvent.ROLL_OVER)
  226.          {
  227.             if(!_mouseHasMoved)
  228.             {
  229.                param1.stopImmediatePropagation();
  230.             }
  231.             _mouseHasMoved = false;
  232.          }
  233.       }
  234.       
  235.       override public function onTweenUpdate(param1:Object) : void
  236.       {
  237.          var _loc2_:Number = NaN;
  238.          var _loc3_:Number = NaN;
  239.          var _loc4_:Number = NaN;
  240.          var _loc5_:Number = NaN;
  241.          EffectManager.suspendEventHandling();
  242.          if(Math.abs(newX - Number(target.x.toFixed(1))) > 0.1)
  243.          {
  244.             origX += Number(target.x.toFixed(1)) - newX;
  245.          }
  246.          if(Math.abs(newY - Number(target.y.toFixed(1))) > 0.1)
  247.          {
  248.             origY += Number(target.y.toFixed(1)) - newY;
  249.          }
  250.          target.scaleX = param1[0];
  251.          target.scaleY = param1[1];
  252.          _loc2_ = param1[0] / origScaleX;
  253.          _loc3_ = param1[1] / origScaleY;
  254.          _loc4_ = scaledOriginX * _loc2_;
  255.          _loc5_ = scaledOriginY * _loc3_;
  256.          newX = scaledOriginX - _loc4_ + origX;
  257.          newY = scaledOriginY - _loc5_ + origY;
  258.          newX = Number(newX.toFixed(1));
  259.          newY = Number(newY.toFixed(1));
  260.          target.move(newX,newY);
  261.          tween.mx_internal::needToLayout = true;
  262.          EffectManager.resumeEventHandling();
  263.       }
  264.       
  265.       override public function initEffect(param1:Event) : void
  266.       {
  267.          super.initEffect(param1);
  268.          if(param1.type == FlexEvent.HIDE || param1.type == Event.REMOVED)
  269.          {
  270.             show = false;
  271.          }
  272.       }
  273.       
  274.       private function applyPropertyChanges() : void
  275.       {
  276.          var _loc1_:PropertyChanges = null;
  277.          var _loc2_:Boolean = false;
  278.          var _loc3_:Boolean = false;
  279.          _loc1_ = propertyChanges;
  280.          if(_loc1_)
  281.          {
  282.             _loc2_ = false;
  283.             _loc3_ = false;
  284.             if(_loc1_.end["scaleX"] !== undefined)
  285.             {
  286.                zoomWidthFrom = isNaN(zoomWidthFrom) ? Number(target.scaleX) : zoomWidthFrom;
  287.                zoomWidthTo = isNaN(zoomWidthTo) ? Number(_loc1_.end["scaleX"]) : zoomWidthTo;
  288.                _loc3_ = true;
  289.             }
  290.             if(_loc1_.end["scaleY"] !== undefined)
  291.             {
  292.                zoomHeightFrom = isNaN(zoomHeightFrom) ? Number(target.scaleY) : zoomHeightFrom;
  293.                zoomHeightTo = isNaN(zoomHeightTo) ? Number(_loc1_.end["scaleY"]) : zoomHeightTo;
  294.                _loc3_ = true;
  295.             }
  296.             if(_loc3_)
  297.             {
  298.                return;
  299.             }
  300.             if(_loc1_.end["width"] !== undefined)
  301.             {
  302.                zoomWidthFrom = isNaN(zoomWidthFrom) ? getScaleFromWidth(target.width) : zoomWidthFrom;
  303.                zoomWidthTo = isNaN(zoomWidthTo) ? getScaleFromWidth(_loc1_.end["width"]) : zoomWidthTo;
  304.                _loc2_ = true;
  305.             }
  306.             if(_loc1_.end["height"] !== undefined)
  307.             {
  308.                zoomHeightFrom = isNaN(zoomHeightFrom) ? getScaleFromHeight(target.height) : zoomHeightFrom;
  309.                zoomHeightTo = isNaN(zoomHeightTo) ? getScaleFromHeight(_loc1_.end["height"]) : zoomHeightTo;
  310.                _loc2_ = true;
  311.             }
  312.             if(_loc2_)
  313.             {
  314.                return;
  315.             }
  316.             if(_loc1_.end["visible"] !== undefined)
  317.             {
  318.                show = _loc1_.end["visible"];
  319.             }
  320.          }
  321.       }
  322.    }
  323. }
  324.