/*
  VERSION: 0.98
  DATE: 10/15/2008
  ACTIONSCRIPT VERSION: 3.0 (AS2 version is also available)
  UPDATES & MORE DETAILED DOCUMENTATION AT: http://blog.greensock.com/tweengroup/
  DESCRIPTION:
  	@ax-lib-flex-animation-code-10-gs-TweenGroup is a very powerful, flexible tool for managing groups of TweenLite/TweenFilterLite/TweenMax tweens.
          Here are a few of the features:
                  
                  - pause(), resume(), reverse(), or restart() the group as a whole. This is an easy way to add
                    these capabilities to TweenLite instances without the extra Kb of TweenMax!
                    
                  - Treat a @ax-lib-flex-animation-code-10-gs-TweenGroup instance just like an Array, so you can push(), splice(), unshift(), pop(),
                    slice(), shift(), loop through the elements, access them directly like myGroup[1], and set them directly 
                    like myGroup[2] = new TweenLite(mc, 1, {x:300}) and it'll automatically adjust the timing
                    of the tweens in the group to honor the alignment and staggering effects you set with 
                    the "align" and "stagger" properties (more on that next...)
                    
                  - Easily set the alignment of the tweens inside the group, like:
                                  - myGroup.align = @ax-lib-flex-animation-code-10-gs-TweenGroup.ALIGN_SEQUENCE; //stacks them end-to-end, one after the other
                                  - myGroup.align = @ax-lib-flex-animation-code-10-gs-TweenGroup.ALIGN_START; //tweens will start at the same time
                                  - myGroup.align = @ax-lib-flex-animation-code-10-gs-TweenGroup.ALIGN_END; //tweens will end at the same time
                                  - myGroup.align = @ax-lib-flex-animation-code-10-gs-TweenGroup.ALIGN_INIT; //same as ALIGN_START except that it honors any delay set in each tween.
                                  - myGroup.align = @ax-lib-flex-animation-code-10-gs-TweenGroup.ALIGN_NONE; //no special alignment
                                  
                  - Stagger aligned tweens by a set amount of time (in seconds). For example, if the stagger value is 0.5 and 
                    the align property is set to ALIGN_START, the second tween will start 0.5 seconds after the first one starts, 
                    then 0.5 seconds later the third one will start, etc. If the align property is ALIGN_SEQUENCE, there would 
                    be 0.5 seconds added between each tween.
                    
                  - Have precise control over the progress of the group by getting/setting the "progress" property anytime. 
                    For example, to skip to half-way through the entire group of tweens, simply do this:
                                    myGroup.progress = 0.5
                    You can even tween the progress property with another tween to fastforward/rewind an entire group!
                  
                  - Call any function when the @ax-lib-flex-animation-code-10-gs-TweenGroup completes using the onComplete property, and pass any number of
                    parameters to that function using the onCompleteParams property. The AS3 version even dispatches
                    a COMPLETE event when it finishes, so if you prefer to use addEventListener() instead of the callback, you can.
                  
                  - Loop or yoyo a set amount of times or inifinitely. For example, to have your @ax-lib-flex-animation-code-10-gs-TweenGroup yoyo (reverse() when
                    it has completed) 2 times, just do myGroup.yoyo = 2; (to loop twice instead, do myGroup.loop = 2)
                    
                  - Only adds about 4Kb to your SWF (not including TweenLite and OverwriteManager).
                  
                  - Performance-wise, @ax-lib-flex-animation-code-10-gs-TweenGroup has no effect whatsoever on the actual rendering speed of the tweens it
                    contains, so you don't have to worry about lots of extra overhead. @ax-lib-flex-animation-code-10-gs-TweenGroup only uses CPU cycles
                    when you perform management tasks (getting/setting properties or calling methods).
                  
          At first glance, it may be difficult to see the value of using @ax-lib-flex-animation-code-10-gs-TweenGroup, but once you wrap your head around
          it, you'll probably find all kinds of uses for it and wonder how you lived without it. For example, what if you 
          have a menu that flies out and unfolds using several sequenced tweens but when the user clicks elsewhere, you 
          want the menu to fold back into place. With @ax-lib-flex-animation-code-10-gs-TweenGroup, it's as simple as calling myGroup.reverse(). Or if you
          have a bunch of tweens that play and then you want to loop them back to the beginning, just call myGroup.restart()
          or set myGroup.progress = 0. 
          
  
  METHODS:
          - pause():void
          - resume():void
          - restart(includeDelay:Boolean):void
          - reverse(forcePlay:Boolean):void
          - getActive():Array
          - mergeGroup(group:@ax-lib-flex-animation-code-10-gs-TweenGroup, startIndex:Number):void
          - updateTimeSpan():void
          - clear(killTweens:Boolean):void
          (also any EventDispatcher methods like addEventListener(), etc.)
          
  STATIC METHODS:
          - allTo(targets:Array, duration:Number, vars:Object, BaseTweenClass:Class):@ax-lib-flex-animation-code-10-gs-TweenGroup
          - allFrom(targets:Array, duration:Number, vars:Object, BaseTweenClass:Class):@ax-lib-flex-animation-code-10-gs-TweenGroup
          - parse(tweens:Array, BaseTweenClass:Class):Array
  
  PROPERTIES:
          - length : uint
          - progress : Number        
          - progressWithDelay : Number
          - paused : Boolean
          - reversed : Boolean
          - duration : Number [read-only]
          - durationWithDelay : Number [read-only]
          - align : String
          - stagger : Number
          - onComplete : Function
          - onCompleteParams : Array
          - loop : Number
          - yoyo : Number
          - tweens : Array
          
  
  EXAMPLES: 
          
          To set up a simple sequence of 3 tweens that should be sequenced one after the other:
                  
                  import gs.*;
                  
                  var tween1:TweenLite = new TweenLite(mc, 1, {x:300});
                  var tween2:TweenLite = new TweenLite(mc, 3, {y:400});
                  var tween3:TweenMax = new TweenMax(mc, 2, {blurFilter:{blurX:10, blurY:10}});
                  
                  var myGroup:@ax-lib-flex-animation-code-10-gs-TweenGroup = new @ax-lib-flex-animation-code-10-gs-TweenGroup([tween1, tween2, tween3]);
                  myGroup.align = @ax-lib-flex-animation-code-10-gs-TweenGroup.ALIGN_SEQUENCE;
                  
                  
          Or if you don't mind all your tweens being the same type (TweenMax in this case as opposed to TweenLite or TweenFilterLite), 
          you can do the same thing in less code like this:
          
                  var myGroup:@ax-lib-flex-animation-code-10-gs-TweenGroup = new @ax-lib-flex-animation-code-10-gs-TweenGroup([{target:mc, time:1, x:300}, {target:mc, time:3, y:400}, {target:mc, time:2, blurFilter:{blurX:10, blurY:10}}], TweenMax, @ax-lib-flex-animation-code-10-gs-TweenGroup.ALIGN_SEQUENCE);
          
          
          If you have an existing @ax-lib-flex-animation-code-10-gs-TweenGroup that you'd like to splice() a new tween into, it's as simple as:
                  
                  myGroup.splice(2, 0, new TweenLite(mc, 3, {alpha:0.5}));
          
          
          To pause the group and skip to half-way through the overall progress, do:
                  
                  myGroup.pause();
                  myGroup.progress = 0.5;
          
  
  NOTES:
          - This class adds about 4kb to your SWF (in addition to TweenLite and OverwriteManager which are about 4kb combined)
          - The TweenMax.sequence(), TweenMax.multiSequence(), TweenMax.allTo(), and TweenMax.allFrom() methods have been deprecated in favor of
            using @ax-lib-flex-animation-code-10-gs-TweenGroup because it is far more powerful and flexible. 
          - When you remove a tween from a group or replace it, that tween does NOT get killed automatically.
            It will continue to run, so you need to use TweenLite.removeTween() to kill it.
          - If you're running into problems with tweens simply not playing, it may be an overwriting issue. 
            Check out http://blog.greensock.com/overwritemanager/ for help.
          - This is a brand new class, so please check back regularly for updates and let me know if
            you run into any bugs/problems.
            
  
  CODED BY: Jack Doyle, jack@greensock.com
  Copyright 2008, GreenSock (This work is subject to the terms in http://www.greensock.com/terms_of_use.html.)
  */
  
  package gs {
          import flash.events.*;
          import flash.utils.*;
  
          dynamic public class @ax-lib-flex-animation-code-10-gs-TweenGroup extends Proxy implements IEventDispatcher {
                  public static const version:Number = 0.98;
                  public static const ALIGN_INIT:String = "init";
                  public static const ALIGN_START:String = "start";
                  public static const ALIGN_END:String = "end";
                  public static const ALIGN_SEQUENCE:String = "sequence";
                  public static const ALIGN_NONE:String = "none";                
                  protected static var _TweenFilterLite:Class;
                  protected static var _TweenMax:Class;
                  protected static var _classInitted:Boolean;
                  
                  public var onComplete:Function;
                  public var onCompleteParams:Array;
                  public var loop:Number;
                  public var yoyo:Number;
                  
                  protected var _tweens:Array;
                  protected var _pauseTime:Number;
                  protected var _startTime:Number; //time at which the first tween in the group begins (AFTER any delay)
                  protected var _endTime:Number; //time at which the last tween finishes
                  protected var _initTime:Number; //same as _startTime except it factors in the delay, so it's basically _startTime minus the first tween's delay.
                  protected var _reversed:Boolean;
                  protected var _align:String;
                  protected var _stagger:Number; //time (in seconds) to stagger each tween in the group/sequence
                  protected var _lastTweenVars:Object; //store the original vars object of the LAST tween here - we replace it with a duplicate that has an onComplete pointing to the onCompleteHandler.
                  protected var _lastTween:TweenLite; 
                  protected var _loopCount:Number; //number of times the group has yoyo'd or loop'd.
                  protected var _dispatcher:EventDispatcher;