home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / effects / effectClasses / ResizeInstance.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  17.2 KB  |  557 lines
  1. package mx.effects.effectClasses
  2. {
  3.    import flash.events.Event;
  4.    import mx.containers.Panel;
  5.    import mx.core.Application;
  6.    import mx.core.Container;
  7.    import mx.core.IUIComponent;
  8.    import mx.core.ScrollPolicy;
  9.    import mx.core.mx_internal;
  10.    import mx.effects.EffectManager;
  11.    import mx.events.EffectEvent;
  12.    import mx.events.ResizeEvent;
  13.    import mx.styles.IStyleClient;
  14.    
  15.    use namespace mx_internal;
  16.    
  17.    public class ResizeInstance extends TweenEffectInstance
  18.    {
  19.       mx_internal static const VERSION:String = "3.5.0.12683";
  20.       
  21.       private var left:*;
  22.       
  23.       private var origPercentHeight:Number;
  24.       
  25.       private var parentOrigHorizontalScrollPolicy:String = "";
  26.       
  27.       private var explicitWidthSet:Boolean;
  28.       
  29.       public var widthFrom:Number;
  30.       
  31.       private var origExplicitHeight:Number;
  32.       
  33.       private var _widthTo:Number;
  34.       
  35.       private var parentOrigVerticalScrollPolicy:String = "";
  36.       
  37.       private var right:*;
  38.       
  39.       private var origExplicitWidth:Number;
  40.       
  41.       private var restoreAutoLayoutArray:Array;
  42.       
  43.       private var restoreVisibleArray:Array;
  44.       
  45.       private var bottom:*;
  46.       
  47.       private var heightSet:Boolean;
  48.       
  49.       private var _heightBy:Number;
  50.       
  51.       private var widthSet:Boolean;
  52.       
  53.       private var origHorizontalScrollPolicy:String = "";
  54.       
  55.       private var numHideEffectsPlaying:Number = 0;
  56.       
  57.       private var top:*;
  58.       
  59.       private var origVerticalScrollPolicy:String = "";
  60.       
  61.       private var _heightTo:Number;
  62.       
  63.       private var explicitHeightSet:Boolean;
  64.       
  65.       public var hideChildrenTargets:Array;
  66.       
  67.       private var origPercentWidth:Number;
  68.       
  69.       public var heightFrom:Number;
  70.       
  71.       private var _widthBy:Number;
  72.       
  73.       public function ResizeInstance(param1:Object)
  74.       {
  75.          super(param1);
  76.          mx_internal::needToLayout = true;
  77.       }
  78.       
  79.       public function set widthBy(param1:Number) : void
  80.       {
  81.          _widthBy = param1;
  82.          widthSet = !isNaN(param1);
  83.       }
  84.       
  85.       public function get heightTo() : Number
  86.       {
  87.          return _heightTo;
  88.       }
  89.       
  90.       public function set heightTo(param1:Number) : void
  91.       {
  92.          _heightTo = param1;
  93.          heightSet = !isNaN(param1);
  94.       }
  95.       
  96.       private function hidePanelChildren() : Boolean
  97.       {
  98.          var _loc3_:Object = null;
  99.          var _loc4_:Number = NaN;
  100.          if(!hideChildrenTargets)
  101.          {
  102.             return false;
  103.          }
  104.          restoreVisibleArray = [];
  105.          restoreAutoLayoutArray = [];
  106.          var _loc1_:int = int(hideChildrenTargets.length);
  107.          var _loc2_:int = 0;
  108.          while(_loc2_ < _loc1_)
  109.          {
  110.             _loc3_ = hideChildrenTargets[_loc2_];
  111.             if(_loc3_ is Panel)
  112.             {
  113.                _loc4_ = numHideEffectsPlaying;
  114.                _loc3_.addEventListener(EffectEvent.EFFECT_START,mx_internal::eventHandler);
  115.                _loc3_.dispatchEvent(new Event("resizeStart"));
  116.                _loc3_.removeEventListener(EffectEvent.EFFECT_START,mx_internal::eventHandler);
  117.                if(numHideEffectsPlaying == _loc4_)
  118.                {
  119.                   makePanelChildrenInvisible(Panel(_loc3_),_loc2_);
  120.                }
  121.             }
  122.             _loc2_++;
  123.          }
  124.          return numHideEffectsPlaying > 0;
  125.       }
  126.       
  127.       override public function play() : void
  128.       {
  129.          super.play();
  130.          calculateExplicitDimensionChanges();
  131.          var _loc1_:Boolean = hidePanelChildren();
  132.          if(target is IStyleClient)
  133.          {
  134.             left = target.getStyle("left");
  135.             if(left != undefined)
  136.             {
  137.                target.setStyle("left",undefined);
  138.             }
  139.             right = target.getStyle("right");
  140.             if(right != undefined)
  141.             {
  142.                target.setStyle("right",undefined);
  143.             }
  144.             top = target.getStyle("top");
  145.             if(top != undefined)
  146.             {
  147.                target.setStyle("top",undefined);
  148.             }
  149.             bottom = target.getStyle("bottom");
  150.             if(bottom != undefined)
  151.             {
  152.                target.setStyle("bottom",undefined);
  153.             }
  154.          }
  155.          if(!_loc1_)
  156.          {
  157.             startResizeTween();
  158.          }
  159.       }
  160.       
  161.       public function set heightBy(param1:Number) : void
  162.       {
  163.          _heightBy = param1;
  164.          heightSet = !isNaN(param1);
  165.       }
  166.       
  167.       override public function initEffect(param1:Event) : void
  168.       {
  169.          super.initEffect(param1);
  170.          if(param1 is ResizeEvent && param1.type == ResizeEvent.RESIZE)
  171.          {
  172.             if(isNaN(widthBy))
  173.             {
  174.                if(isNaN(widthFrom))
  175.                {
  176.                   widthFrom = ResizeEvent(param1).oldWidth;
  177.                }
  178.                if(isNaN(widthTo))
  179.                {
  180.                   _widthTo = target.width;
  181.                }
  182.             }
  183.             if(isNaN(heightBy))
  184.             {
  185.                if(isNaN(heightFrom))
  186.                {
  187.                   heightFrom = ResizeEvent(param1).oldHeight;
  188.                }
  189.                if(isNaN(heightTo))
  190.                {
  191.                   _heightTo = target.height;
  192.                }
  193.             }
  194.          }
  195.       }
  196.       
  197.       public function get widthBy() : Number
  198.       {
  199.          return _widthBy;
  200.       }
  201.       
  202.       override public function onTweenUpdate(param1:Object) : void
  203.       {
  204.          EffectManager.suspendEventHandling();
  205.          target.width = Math.round(param1[0]);
  206.          target.height = Math.round(param1[1]);
  207.          if(tween)
  208.          {
  209.             tween.mx_internal::needToLayout = true;
  210.          }
  211.          mx_internal::needToLayout = true;
  212.          EffectManager.resumeEventHandling();
  213.       }
  214.       
  215.       override mx_internal function eventHandler(param1:Event) : void
  216.       {
  217.          var _loc3_:int = 0;
  218.          var _loc4_:int = 0;
  219.          var _loc2_:Container = param1.target as Container;
  220.          super.mx_internal::eventHandler(param1);
  221.          if(param1.type == EffectEvent.EFFECT_START)
  222.          {
  223.             _loc2_.addEventListener(EffectEvent.EFFECT_END,mx_internal::eventHandler);
  224.             ++numHideEffectsPlaying;
  225.          }
  226.          else if(param1.type == EffectEvent.EFFECT_END)
  227.          {
  228.             _loc2_.removeEventListener(EffectEvent.EFFECT_END,mx_internal::eventHandler);
  229.             _loc3_ = int(hideChildrenTargets.length);
  230.             _loc4_ = 0;
  231.             while(_loc4_ < _loc3_)
  232.             {
  233.                if(hideChildrenTargets[_loc4_] == _loc2_)
  234.                {
  235.                   break;
  236.                }
  237.                _loc4_++;
  238.             }
  239.             makePanelChildrenInvisible(_loc2_,_loc4_);
  240.             if(--numHideEffectsPlaying == 0)
  241.             {
  242.                startResizeTween();
  243.             }
  244.          }
  245.       }
  246.       
  247.       public function set widthTo(param1:Number) : void
  248.       {
  249.          _widthTo = param1;
  250.          widthSet = !isNaN(param1);
  251.       }
  252.       
  253.       private function calculateExplicitDimensionChanges() : void
  254.       {
  255.          var _loc5_:Container = null;
  256.          var _loc6_:Container = null;
  257.          var _loc1_:* = !!propertyChanges ? propertyChanges.end["explicitWidth"] : undefined;
  258.          var _loc2_:* = !!propertyChanges ? propertyChanges.end["explicitHeight"] : undefined;
  259.          var _loc3_:* = !!propertyChanges ? propertyChanges.end["percentWidth"] : undefined;
  260.          var _loc4_:* = !!propertyChanges ? propertyChanges.end["percentHeight"] : undefined;
  261.          if(!heightSet)
  262.          {
  263.             if(_loc4_ !== undefined)
  264.             {
  265.                origPercentHeight = _loc4_;
  266.             }
  267.             else
  268.             {
  269.                origPercentHeight = target.percentHeight;
  270.             }
  271.             if(isNaN(origPercentHeight))
  272.             {
  273.                if(_loc2_ !== undefined)
  274.                {
  275.                   origExplicitHeight = _loc2_;
  276.                }
  277.                else
  278.                {
  279.                   origExplicitHeight = target.explicitHeight;
  280.                }
  281.             }
  282.             _loc5_ = target as Container;
  283.             if((Boolean(_loc5_)) && _loc5_.verticalScrollBar == null)
  284.             {
  285.                origVerticalScrollPolicy = _loc5_.verticalScrollPolicy;
  286.                _loc5_.verticalScrollPolicy = ScrollPolicy.OFF;
  287.             }
  288.             if(target.parent)
  289.             {
  290.                _loc6_ = target.parent as Container;
  291.                if((Boolean(_loc6_)) && _loc6_.verticalScrollBar == null)
  292.                {
  293.                   parentOrigVerticalScrollPolicy = _loc6_.verticalScrollPolicy;
  294.                   _loc6_.verticalScrollPolicy = ScrollPolicy.OFF;
  295.                }
  296.             }
  297.          }
  298.          if(!widthSet)
  299.          {
  300.             if(_loc3_ !== undefined)
  301.             {
  302.                origPercentWidth = _loc3_;
  303.             }
  304.             else
  305.             {
  306.                origPercentWidth = target.percentWidth;
  307.             }
  308.             if(isNaN(origPercentWidth))
  309.             {
  310.                if(_loc1_ !== undefined)
  311.                {
  312.                   origExplicitWidth = _loc1_;
  313.                }
  314.                else
  315.                {
  316.                   origExplicitWidth = target.explicitWidth;
  317.                }
  318.             }
  319.             _loc5_ = target as Container;
  320.             if((Boolean(_loc5_)) && _loc5_.horizontalScrollBar == null)
  321.             {
  322.                origHorizontalScrollPolicy = _loc5_.horizontalScrollPolicy;
  323.                _loc5_.horizontalScrollPolicy = ScrollPolicy.OFF;
  324.             }
  325.             if(target.parent)
  326.             {
  327.                _loc6_ = target.parent as Container;
  328.                if((Boolean(_loc6_)) && _loc6_.horizontalScrollBar == null)
  329.                {
  330.                   parentOrigHorizontalScrollPolicy = _loc6_.horizontalScrollPolicy;
  331.                   _loc6_.horizontalScrollPolicy = ScrollPolicy.OFF;
  332.                }
  333.             }
  334.          }
  335.          if(isNaN(widthFrom))
  336.          {
  337.             widthFrom = !isNaN(widthTo) && !isNaN(widthBy) ? widthTo - widthBy : Number(target.width);
  338.          }
  339.          if(isNaN(widthTo))
  340.          {
  341.             if(isNaN(widthBy) && propertyChanges && (propertyChanges.end["width"] !== undefined || _loc1_ !== undefined))
  342.             {
  343.                if(_loc1_ !== undefined && !isNaN(_loc1_))
  344.                {
  345.                   explicitWidthSet = true;
  346.                   _widthTo = _loc1_;
  347.                }
  348.                else
  349.                {
  350.                   _widthTo = propertyChanges.end["width"];
  351.                }
  352.             }
  353.             else
  354.             {
  355.                _widthTo = !isNaN(widthBy) ? widthFrom + widthBy : Number(target.width);
  356.             }
  357.          }
  358.          if(isNaN(heightFrom))
  359.          {
  360.             heightFrom = !isNaN(heightTo) && !isNaN(heightBy) ? heightTo - heightBy : Number(target.height);
  361.          }
  362.          if(isNaN(heightTo))
  363.          {
  364.             if(isNaN(heightBy) && propertyChanges && (propertyChanges.end["height"] !== undefined || _loc2_ !== undefined))
  365.             {
  366.                if(_loc2_ !== undefined && !isNaN(_loc2_))
  367.                {
  368.                   explicitHeightSet = true;
  369.                   _heightTo = _loc2_;
  370.                }
  371.                else
  372.                {
  373.                   _heightTo = propertyChanges.end["height"];
  374.                }
  375.             }
  376.             else
  377.             {
  378.                _heightTo = !isNaN(heightBy) ? heightFrom + heightBy : Number(target.height);
  379.             }
  380.          }
  381.       }
  382.       
  383.       private function makePanelChildrenInvisible(param1:Container, param2:Number) : void
  384.       {
  385.          var _loc4_:IUIComponent = null;
  386.          var _loc3_:Array = [];
  387.          var _loc5_:int = param1.numChildren;
  388.          var _loc6_:int = 0;
  389.          while(_loc6_ < _loc5_)
  390.          {
  391.             _loc4_ = IUIComponent(param1.getChildAt(_loc6_));
  392.             if(_loc4_.visible)
  393.             {
  394.                _loc3_.push(_loc4_);
  395.                _loc4_.setVisible(false,true);
  396.             }
  397.             _loc6_++;
  398.          }
  399.          _loc4_ = param1.horizontalScrollBar;
  400.          if((Boolean(_loc4_)) && Boolean(_loc4_.visible))
  401.          {
  402.             _loc3_.push(_loc4_);
  403.             _loc4_.setVisible(false,true);
  404.          }
  405.          _loc4_ = param1.verticalScrollBar;
  406.          if((Boolean(_loc4_)) && Boolean(_loc4_.visible))
  407.          {
  408.             _loc3_.push(_loc4_);
  409.             _loc4_.setVisible(false,true);
  410.          }
  411.          restoreVisibleArray[param2] = _loc3_;
  412.          if(param1.autoLayout)
  413.          {
  414.             param1.autoLayout = false;
  415.             restoreAutoLayoutArray[param2] = true;
  416.          }
  417.       }
  418.       
  419.       override public function end() : void
  420.       {
  421.          if(!tween)
  422.          {
  423.             calculateExplicitDimensionChanges();
  424.             onTweenEnd(!!mx_internal::playReversed ? [widthFrom,heightFrom] : [widthTo,heightTo]);
  425.          }
  426.          super.end();
  427.       }
  428.       
  429.       private function startResizeTween() : void
  430.       {
  431.          EffectManager.mx_internal::startVectorEffect(IUIComponent(target));
  432.          tween = createTween(this,[widthFrom,heightFrom],[widthTo,heightTo],duration);
  433.          mx_internal::applyTweenStartValues();
  434.       }
  435.       
  436.       public function get heightBy() : Number
  437.       {
  438.          return _heightBy;
  439.       }
  440.       
  441.       private function restorePanelChildren() : void
  442.       {
  443.          var _loc1_:int = 0;
  444.          var _loc2_:int = 0;
  445.          var _loc3_:IUIComponent = null;
  446.          var _loc4_:Array = null;
  447.          var _loc5_:int = 0;
  448.          var _loc6_:int = 0;
  449.          if(hideChildrenTargets)
  450.          {
  451.             _loc1_ = int(hideChildrenTargets.length);
  452.             _loc2_ = 0;
  453.             while(_loc2_ < _loc1_)
  454.             {
  455.                _loc3_ = hideChildrenTargets[_loc2_];
  456.                _loc4_ = restoreVisibleArray[_loc2_];
  457.                if(_loc4_)
  458.                {
  459.                   _loc5_ = int(_loc4_.length);
  460.                   _loc6_ = 0;
  461.                   while(_loc6_ < _loc5_)
  462.                   {
  463.                      _loc4_[_loc6_].setVisible(true,true);
  464.                      _loc6_++;
  465.                   }
  466.                }
  467.                if(restoreAutoLayoutArray[_loc2_])
  468.                {
  469.                   Container(_loc3_).autoLayout = true;
  470.                }
  471.                _loc3_.dispatchEvent(new Event("resizeEnd"));
  472.                _loc2_++;
  473.             }
  474.          }
  475.       }
  476.       
  477.       override public function onTweenEnd(param1:Object) : void
  478.       {
  479.          var _loc2_:Container = null;
  480.          var _loc3_:Container = null;
  481.          EffectManager.mx_internal::endVectorEffect(IUIComponent(target));
  482.          Application.application.callLater(restorePanelChildren);
  483.          super.onTweenEnd(param1);
  484.          EffectManager.suspendEventHandling();
  485.          if(!heightSet)
  486.          {
  487.             target.percentHeight = origPercentHeight;
  488.             target.explicitHeight = origExplicitHeight;
  489.             if(origVerticalScrollPolicy != "")
  490.             {
  491.                _loc2_ = target as Container;
  492.                if(_loc2_)
  493.                {
  494.                   _loc2_.verticalScrollPolicy = origVerticalScrollPolicy;
  495.                   origVerticalScrollPolicy = "";
  496.                }
  497.             }
  498.             if(parentOrigVerticalScrollPolicy != "" && Boolean(target.parent))
  499.             {
  500.                _loc3_ = target.parent as Container;
  501.                if(_loc3_)
  502.                {
  503.                   _loc3_.verticalScrollPolicy = parentOrigVerticalScrollPolicy;
  504.                   parentOrigVerticalScrollPolicy = "";
  505.                }
  506.             }
  507.          }
  508.          if(!widthSet)
  509.          {
  510.             target.percentWidth = origPercentWidth;
  511.             target.explicitWidth = origExplicitWidth;
  512.             if(origHorizontalScrollPolicy != "")
  513.             {
  514.                _loc2_ = target as Container;
  515.                if(_loc2_)
  516.                {
  517.                   _loc2_.horizontalScrollPolicy = origHorizontalScrollPolicy;
  518.                   origHorizontalScrollPolicy = "";
  519.                }
  520.             }
  521.             if(parentOrigHorizontalScrollPolicy != "" && Boolean(target.parent))
  522.             {
  523.                _loc3_ = target.parent as Container;
  524.                if(_loc3_)
  525.                {
  526.                   _loc3_.horizontalScrollPolicy = parentOrigHorizontalScrollPolicy;
  527.                   parentOrigHorizontalScrollPolicy = "";
  528.                }
  529.             }
  530.          }
  531.          if(left != undefined)
  532.          {
  533.             target.setStyle("left",left);
  534.          }
  535.          if(right != undefined)
  536.          {
  537.             target.setStyle("right",right);
  538.          }
  539.          if(top != undefined)
  540.          {
  541.             target.setStyle("top",top);
  542.          }
  543.          if(bottom != undefined)
  544.          {
  545.             target.setStyle("bottom",bottom);
  546.          }
  547.          EffectManager.resumeEventHandling();
  548.       }
  549.       
  550.       public function get widthTo() : Number
  551.       {
  552.          return _widthTo;
  553.       }
  554.    }
  555. }
  556.  
  557.